Advection diffusion - DO NOT MERGE

Code/CMakeLists.txt

@@ -17,9 +17,9 @@ option(HEMELB_BUILD_DEBUGGER "Build the built in debugger" ON)
 # mark_as_advanced(HEMELB_DEBUGGER_IMPLEMENTATION)
 
 option(HEMELB_VALIDATE_GEOMETRY "Validate geometry" OFF)
-option(HEMELB_BUILD_TESTS_ALL "Build all the tests" ON)
-option(HEMELB_BUILD_TESTS_UNIT "Build the unit-tests (HEMELB_BUILD_TESTS_ALL takes precedence)" ON)
-option(HEMELB_BUILD_TESTS_FUNCTIONAL "Build the functional tests (HEMELB_BUILD_TESTS_ALL takes precedence)" ON)
+option(HEMELB_BUILD_TESTS_ALL "Build all the tests" OFF)
+option(HEMELB_BUILD_TESTS_UNIT "Build the unit-tests (HEMELB_BUILD_TESTS_ALL takes precedence)" OFF)
+option(HEMELB_BUILD_TESTS_FUNCTIONAL "Build the functional tests (HEMELB_BUILD_TESTS_ALL takes precedence)" OFF)
 option(HEMELB_USE_ALL_WARNINGS_GNU "Show all compiler warnings on development builds (gnu-style-compilers)" ON)
 option(HEMELB_USE_STREAKLINES "Calculate streakline images" OFF)
 option(HEMELB_DEPENDENCIES_SET_RPATH "Set runtime RPATH" ON)
@@ -49,19 +49,19 @@ set(HEMELB_DEPENDENCIES_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../dependencies"
 set(HEMELB_DEPENDENCIES_INSTALL_PATH ${HEMELB_DEPENDENCIES_PATH}
 	CACHE FILEPATH "Path to find dependency includes and libraries")
 set(HEMELB_OPTIMISATION "-O3" CACHE STRING "Optimisation level (can be blank or -O1 to -O4)")
-set(HEMELB_LATTICE "D3Q15"
+set(HEMELB_LATTICE "D3Q19"
   CACHE STRING "Select the lattice type to use (D3Q15,D3Q19,D3Q27,D3Q15i)")
 set(HEMELB_KERNEL "LBGK"
   CACHE STRING "Select the kernel to use (LBGK,EntropicAnsumali,EntropicChik,MRT,TRT,NNCY,NNCYMOUSE,NNC,NNTPL)")
 set(HEMELB_WALL_BOUNDARY "SIMPLEBOUNCEBACK"
   CACHE STRING "Select the boundary conditions to be used at the walls (BFL,GZS,SIMPLEBOUNCEBACK,JUNKYANG)")
-set(HEMELB_INLET_BOUNDARY "NASHZEROTHORDERPRESSUREIOLET"
+set(HEMELB_INLET_BOUNDARY "LADDIOLET"
   CACHE STRING "Select the boundary conditions to be used at the inlet (NASHZEROTHORDERPRESSUREIOLET,LADDIOLET)")
 set(HEMELB_OUTLET_BOUNDARY "NASHZEROTHORDERPRESSUREIOLET"
   CACHE STRING "Select the boundary conditions to be used at the outlets (NASHZEROTHORDERPRESSUREIOLET,LADDIOLET)")
 set(HEMELB_COMPUTE_ARCHITECTURE "AMDBULLDOZER"
   CACHE STRING "Select the architecture of the machine being used (INTELSANDYBRIDGE,AMDBULLDOZER,NEUTRAL,ISBFILEVELOCITYINLET)")
-set(HEMELB_WALL_INLET_BOUNDARY "NASHZEROTHORDERPRESSURESBB"
+set(HEMELB_WALL_INLET_BOUNDARY "LADDIOLETSBB"
   CACHE STRING "Select the boundary conditions to be used at corners between walls and inlets (NASHZEROTHORDERPRESSURESBB,NASHZEROTHORDERPRESSUREBFL,LADDIOLETSBB,LADDIOLETBFL)")
 set(HEMELB_WALL_OUTLET_BOUNDARY "NASHZEROTHORDERPRESSURESBB"
   CACHE STRING "Select the boundary conditions to be used at corners between walls and outlets (NASHZEROTHORDERPRESSURESBB,NASHZEROTHORDERPRESSUREBFL,LADDIOLETSBB,LADDIOLETBFL)")
@@ -75,8 +75,8 @@ option(HEMELB_SEPARATE_CONCERNS "Communicate for each concern separately" OFF)
 
 # Add warnings flags to development build types
 if (HEMELB_USE_ALL_WARNINGS_GNU)
-	set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
-	set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall")
+	set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -fpermissive")
+	set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -fpermissive")
 endif()
 if(HEMELB_OPTIMISATION)
 	set( CMAKE_CXX_FLAGS_RELEASE ${HEMELB_OPTIMISATION})

Code/Doxyfile

@@ -1294,7 +1294,7 @@ GROUP_GRAPHS           = YES
 # collaboration diagrams in a style similar to the OMG's Unified Modeling 
 # Language.
 
-UML_LOOK               = NO
+UML_LOOK               = YES
 
 # If set to YES, the inheritance and collaboration graphs will show the 
 # relations between templates and their instances.

Code/SimulationMaster.cc

@@ -37,6 +37,14 @@ SimulationMaster::SimulationMaster(hemelb::configuration::CommandLine & options,
 {
   timings[hemelb::reporting::Timers::total].Start();
 
+  advectionDiffusionData = NULL;
+  advectionDiffusionModel = NULL;
+  advectionDiffusionDataManager = NULL;
+  advectionDiffusionDataSource = NULL;
+  stentValues = NULL;
+  advectionDiffusionOutletValues = NULL;
+  advectionDiffusionInletValues = NULL;
+
   latticeData = NULL;
 
   colloidController = NULL;
@@ -54,10 +62,12 @@ SimulationMaster::SimulationMaster(hemelb::configuration::CommandLine & options,
 
   fileManager = new hemelb::io::PathManager(options, IsCurrentProcTheIOProc(), GetProcessorCount());
   simConfig = hemelb::configuration::SimConfig::New(fileManager->GetInputFile());
+
+  /* This is ugly design. References to encapuslated data members are
+     indicative of an ill-designed class hierarchy. */
   unitConverter = &simConfig->GetUnitConverter();
   monitoringConfig = simConfig->GetMonitoringConfiguration();
 
-  fileManager->SaveConfiguration(simConfig);
   Initialise();
   if (IsCurrentProcTheIOProc())
   {
@@ -86,6 +96,13 @@ SimulationMaster::~SimulationMaster()
   {
     delete imageSendCpt;
   }
+  delete advectionDiffusionData;
+  delete advectionDiffusionModel;
+  delete advectionDiffusionDataManager;
+  delete advectionDiffusionDataSource;
+  delete stentValues;
+  delete advectionDiffusionOutletValues;
+  delete advectionDiffusionInletValues;
   delete latticeData;
   delete colloidController;
   delete latticeBoltzmannModel;
@@ -170,7 +187,19 @@ void SimulationMaster::Initialise()
                                                            timings,
                                                            neighbouringDataManager);
 
-  hemelb::lb::MacroscopicPropertyCache& propertyCache = latticeBoltzmannModel->GetPropertyCache();
+  if (simConfig->EnableADE())
+  {
+  hemelb::log::Logger::Log<hemelb::log::Info, hemelb::log::Singleton>("Initialising ADE.");
+  advectionDiffusionData = new hemelb::geometry::LatticeData(advectionDiffusionLatticeType::GetLatticeInfo(), readGeometryData, ioComms);
+  advectionDiffusionDataManager = new hemelb::geometry::neighbouring::NeighbouringDataManager(*advectionDiffusionData, advectionDiffusionData->GetNeighbouringData(), communicationNet);
+  advectionDiffusionModel = new hemelb::lb::ADELBM<advectionDiffusionLatticeType>(simConfig,
+                                                                                  &communicationNet,
+                                                                                  advectionDiffusionData,
+                                                                                  simulationState,
+                                                                                  timings,
+                                                                                  advectionDiffusionDataManager,
+                                                                                  latticeBoltzmannModel->GetPropertyCache());
+  }
 
   if (simConfig->HasColloidSection())
   {
@@ -185,6 +214,8 @@ void SimulationMaster::Initialise()
     hemelb::log::Logger::Log<hemelb::log::Info, hemelb::log::Singleton>("Creating Boundary Conditions.");
     hemelb::colloids::BoundaryConditions::InitBoundaryConditions(latticeData, xml);
 
+    hemelb::lb::MacroscopicPropertyCache& propertyCache = latticeBoltzmannModel->GetPropertyCache();
+
     hemelb::log::Logger::Log<hemelb::log::Info, hemelb::log::Singleton>("Initialising Colloids.");
     colloidController =
         new hemelb::colloids::ColloidController(*latticeData,
@@ -267,10 +298,40 @@ void SimulationMaster::Initialise()
                                                         ioComms,
                                                         *unitConverter);
 
+  if (simConfig->EnableADE())
+  {
+  stentValues = new hemelb::lb::stents::BoundaryValues(advectionDiffusionData,
+						       simConfig->GetStents(),
+						       simulationState,
+						       ioComms,
+						       *unitConverter);
+
+  advectionDiffusionOutletValues = new hemelb::lb::iolets::BoundaryValues(hemelb::geometry::OUTLET_TYPE,
+                                                                          advectionDiffusionData,
+                                                                          simConfig->GetOutlets(),
+                                                                          simulationState,
+                                                                          ioComms,
+                                                                          *unitConverter);
+
+  advectionDiffusionInletValues = new hemelb::lb::iolets::BoundaryValues(hemelb::geometry::INLET_TYPE,
+                                                                         advectionDiffusionData,
+                                                                         simConfig->GetInlets(),
+                                                                         simulationState,
+                                                                         ioComms,
+                                                                         *unitConverter);
+  }
+
   latticeBoltzmannModel->Initialise(visualisationControl, inletValues, outletValues, unitConverter);
   neighbouringDataManager->ShareNeeds();
   neighbouringDataManager->TransferNonFieldDependentInformation();
 
+  if (simConfig->EnableADE())
+  {
+  advectionDiffusionModel->Initialise(visualisationControl, stentValues, advectionDiffusionOutletValues, advectionDiffusionInletValues, unitConverter);
+  advectionDiffusionDataManager->ShareNeeds();
+  advectionDiffusionDataManager->TransferNonFieldDependentInformation();
+  }
+
   steeringCpt = new hemelb::steering::SteeringComponent(network,
                                                         visualisationControl,
                                                         imageSendCpt,
@@ -283,24 +344,38 @@ void SimulationMaster::Initialise()
   latticeBoltzmannModel->ReadVisParameters();
 
   propertyDataSource =
-      new hemelb::extraction::LbDataSourceIterator(latticeBoltzmannModel->GetPropertyCache(),
-                                                   *latticeData,
-                                                   ioComms.Rank(),
-                                                   *unitConverter);
+    new hemelb::extraction::LbDataSourceIterator(latticeBoltzmannModel->GetPropertyCache(),
+						 *latticeData,
+						 ioComms.Rank(),
+						 *unitConverter);
+
+  if (simConfig->EnableADE())
+  {
+  advectionDiffusionDataSource =
+    new hemelb::extraction::LbDataSourceIterator(advectionDiffusionModel->GetPropertyCache(),
+						 *advectionDiffusionData,
+						 ioComms.Rank(),
+						 *unitConverter);
+  }
 
   if (simConfig->PropertyOutputCount() > 0)
   {
 
     for (unsigned outputNumber = 0; outputNumber < simConfig->PropertyOutputCount(); ++outputNumber)
     {
+      /* This is ugly. The path would better be set during
+	 instantiation of simConfig. Alas, sufficient effort has been
+	 made to make that change nontrivial. This is C++ after all,
+	 and things have to be obfuscated. */
       simConfig->GetPropertyOutput(outputNumber)->filename = fileManager->GetDataExtractionPath()
           + simConfig->GetPropertyOutput(outputNumber)->filename;
     }
 
     propertyExtractor = new hemelb::extraction::PropertyActor(*simulationState,
                                                               simConfig->GetPropertyOutputs(),
-                                                              *propertyDataSource,
+							      dataSourceMap,
                                                               timings, ioComms);
+
   }
 
   imagesPeriod = OutputPeriod(imagesPerSimulation);
@@ -310,12 +385,22 @@ void SimulationMaster::Initialise()
                                                      hemelb::net::separate_communications);
   netConcern = new hemelb::net::phased::NetConcern(communicationNet);
   stepManager->RegisterIteratedActorSteps(*neighbouringDataManager, 0);
+  if (simConfig->EnableADE())
+  {
+  stepManager->RegisterIteratedActorSteps(*advectionDiffusionDataManager, 0);
+  }
   if (colloidController != NULL)
   {
     stepManager->RegisterIteratedActorSteps(*colloidController, 1);
   }
+  if (simConfig->EnableADE())
+  {
+  stepManager->RegisterIteratedActorSteps(*advectionDiffusionModel, 1);
+  stepManager->RegisterIteratedActorSteps(*stentValues, 1);
+  stepManager->RegisterIteratedActorSteps(*advectionDiffusionOutletValues, 1);
+  stepManager->RegisterIteratedActorSteps(*advectionDiffusionInletValues, 1);
+  }
   stepManager->RegisterIteratedActorSteps(*latticeBoltzmannModel, 1);
-
   stepManager->RegisterIteratedActorSteps(*inletValues, 1);
   stepManager->RegisterIteratedActorSteps(*outletValues, 1);
   stepManager->RegisterIteratedActorSteps(*steeringCpt, 1);
@@ -578,7 +663,12 @@ void SimulationMaster::RecalculatePropertyRequirements()
   // Get the property cache & reset its list of properties to get.
   hemelb::lb::MacroscopicPropertyCache& propertyCache = latticeBoltzmannModel->GetPropertyCache();
 
+  /* TODO: This should really be an iteration over all property caches */
   propertyCache.ResetRequirements();
+  if (simConfig->EnableADE())
+  {
+  advectionDiffusionModel->GetPropertyCache().ResetRequirements();
+  }
 
   // Check whether we're rendering images on this iteration.
   if (visualisationControl->IsRendering())
@@ -605,7 +695,7 @@ void SimulationMaster::RecalculatePropertyRequirements()
   // If extracting property results, check what's required by them.
   if (propertyExtractor != NULL)
   {
-    propertyExtractor->SetRequiredProperties(propertyCache);
+    propertyExtractor->SetRequiredProperties(dataSourceMap);
   }
 
   // If using streaklines, the velocity will be needed.

Code/SimulationMaster.h

@@ -6,15 +6,18 @@
 
 #ifndef HEMELB_SIMULATIONMASTER_H
 #define HEMELB_SIMULATIONMASTER_H
+#define HEMELB_ADE_LATTICE D3Q15
 #include "lb/lattices/Lattices.h"
 #include "extraction/PropertyActor.h"
 #include "lb/lb.hpp"
+#include "lb/ADELB.hpp"
 #include "lb/StabilityTester.h"
 #include "net/net.h"
 #include "steering/ImageSendComponent.h"
 #include "steering/SteeringComponent.h"
 #include "lb/EntropyTester.h"
 #include "lb/iolets/BoundaryValues.h"
+#include "lb/stents/BoundaryValues.h"
 #include "util/UnitConverter.h"
 #include "configuration/CommandLine.h"
 #include "io/PathManager.h"
@@ -48,6 +51,10 @@ class SimulationMaster
 
     hemelb::lb::iolets::BoundaryValues* inletValues;
     hemelb::lb::iolets::BoundaryValues* outletValues;
+    hemelb::lb::stents::BoundaryValues* stentValues;
+    hemelb::lb::iolets::BoundaryValues* advectionDiffusionOutletValues;
+    hemelb::lb::iolets::BoundaryValues* advectionDiffusionInletValues;
+
     virtual void DoTimeStep();
 
     /* The next quantities are protected because they are used by MultiscaleSimulationMaster */
@@ -56,6 +63,10 @@ class SimulationMaster
     hemelb::geometry::LatticeData* latticeData;
     hemelb::lb::LBM<latticeType>* latticeBoltzmannModel;
     hemelb::geometry::neighbouring::NeighbouringDataManager *neighbouringDataManager;
+    typedef hemelb::lb::lattices:: HEMELB_ADE_LATTICE advectionDiffusionLatticeType;
+    hemelb::geometry::LatticeData* advectionDiffusionData;
+    hemelb::lb::ADELBM<advectionDiffusionLatticeType>* advectionDiffusionModel;
+    hemelb::geometry::neighbouring::NeighbouringDataManager *advectionDiffusionDataManager;
     const hemelb::net::IOCommunicator& ioComms;
 
   private:
@@ -107,6 +118,7 @@ class SimulationMaster
 
     hemelb::vis::Control* visualisationControl;
     hemelb::extraction::IterableDataSource* propertyDataSource;
+    hemelb::extraction::IterableDataSource* advectionDiffusionDataSource;
     hemelb::extraction::PropertyActor* propertyExtractor;
 
     hemelb::net::phased::StepManager* stepManager;
@@ -116,6 +128,22 @@ class SimulationMaster
     int steeringSessionId;
     unsigned int imagesPeriod;
     static const hemelb::LatticeTimeStep FORCE_FLUSH_PERIOD=1000;
+
+    std::map<hemelb::extraction::OutputField::FieldType, hemelb::extraction::IterableDataSource**>
+      dataSourceMap
+      = { { hemelb::extraction::OutputField::Pressure,                     &propertyDataSource },
+	  { hemelb::extraction::OutputField::Velocity,                     &propertyDataSource },
+	  { hemelb::extraction::OutputField::ShearStress,                  &propertyDataSource },
+	  { hemelb::extraction::OutputField::VonMisesStress,               &propertyDataSource },
+	  { hemelb::extraction::OutputField::ShearRate,                    &propertyDataSource },
+	  { hemelb::extraction::OutputField::StressTensor,                 &propertyDataSource },
+	  { hemelb::extraction::OutputField::Traction,                     &propertyDataSource },
+	  { hemelb::extraction::OutputField::TangentialProjectionTraction, &propertyDataSource },
+          { hemelb::extraction::OutputField::Concentration,          &advectionDiffusionDataSource },
+          { hemelb::extraction::OutputField::Flux,                   &advectionDiffusionDataSource },
+	  { hemelb::extraction::OutputField::MpiRank,                      &propertyDataSource }
+    };
+
 };
 
 #endif /* HEMELB_SIMULATIONMASTER_H */