Application Class Reference

Manages the initialisation of the solvers, the methods depending to the solvers and the start of the solving steps. More...

#include <application.h>

Collaboration diagram for Application:

Public Member Functions
	Application ()
	Gets initial data from the property file and creates the solvers and methods. More...
	~Application ()
template<MInt nDim>
void	run ()
	Application (const Application &)=delete
	Application (Application &&)=delete
Application &	operator= (const Application &)=delete
Application &	operator= (Application &&)=delete

Private Member Functions
MInt	gridType (const MString solverType)
	Return the type of grid for a given solver type. More...
MInt	getInitialTimeStep (const MBool restartFile, const MPI_Comm comm)
	Return the initial global time step. More...
void	initTimings ()
	Initialize the collection of solver/coupler timings for performance evaluations. More...
void	collectTimingsAndSolverInformation (const MBool finalTimeStep)
	Collect the timings of all solvers and domain decomposition information. More...
void	storeTimingsAndSolverInformation (const MBool finalTimeStep)
	Store timings for all solvers and domain decomposition information on all domains. More...
void	cleanUp ()
	call cleanup functions in all solvers and couplers before returning from the application More...
template<MInt nDim>
void	createSolver (CartesianGrid< nDim > *grid, const MInt solverId, Geometry< nDim > *geometry, MBool *propertiesGroup, MBool &isActive)
	This function handels the creation of new solvers. More...
template<MInt nDim>
void	createSolver (StructuredGrid< nDim > *grid, const MInt solverId, MBool *propertiesGroups, const MPI_Comm comm)
	This function handles the creation of new structured solvers. More...
template<MInt nDim>
void	createSolver (const MInt solverId, const MPI_Comm comm)
	Handles the creation of gridless solvers. More...
template<MInt nDim>
void	createCoupler (MInt)
	This function handels the creation of new couplers. More...
template<MInt nDim>
PostProcessingInterface *	createPostProcessing (MInt)
	This function handels the creation of the Postprocessing classes. More...
ExecutionRecipe *	createRecipe ()
	This function handels the creation of the execution recipe. More...

Static Private Member Functions
static MBool *	readPropertiesGroups ()
	Reads in the properties groups. More...

Private Attributes
MBool	m_dualTimeStepping
MInt	m_maxIterations
	Maximum number of iterations. More...
MInt	m_restartBackupInterval
	The number of timesteps before executing a restart-backup. More...
MInt	m_noSolvers = -1
	The number of solvers. More...
std::vector< std::unique_ptr< Solver > >	m_solvers
	The list of solvers. More...
MBool	m_initialAdaptation = true
	Initial adaptation. More...
MInt	m_noCouplers = 0
	The number of couplers. More...
std::vector< std::unique_ptr< Coupling > >	m_couplers
	The list of couplers. More...
MInt	m_noPostProcessing
	The number of postprocessing solvers. More...
MBool	m_postProcessing
MInt	m_postDataSolverId = -1
MBool	m_displayMemoryStatistics = false
	Memory statistics controller. More...
MBool	m_ppAfterTS = false
	post-processing in-solve position More...
MBool	m_writeSolverTimings = false
	Solver/coupler timings for performance evaluations. More...
MBool	m_writeAllSolverTimings = true
	Switch timings mode between ALL timings (default) and a reduced/essential timings mode. More...
MInt	m_solverTimingsWriteInterval = -1
	Write interval for timings. More...
MInt	m_solverTimingsSampleInterval = 1
	Sampling interval for timings. More...
MInt	m_noGlobalSolverTimers = -1
const MInt	m_maxNoSolverTimings = 100000
std::vector< std::vector< MFloat > >	m_solverTimings {}
std::vector< MFloat >	m_solverTimingsPrevTime {}
std::vector< MInt >	m_solverTimingsTimeStep {}
std::vector< MString >	m_solverTimingsNames {}
std::vector< std::pair< MString, MInt > >	m_domainInfo {}

Detailed Description

Definition at line 37 of file application.h.

Constructor & Destructor Documentation

Application() [1/3]

Application::Application

(

)

This constructor creates a list of solvers and corresponding methods. The list entries are created according to the definitions in the property file. While the solver type is already specified here, the method type will be specified in the Methods constructor (see also methods.h). Basic application properties are also read here.

~Application()

Application::~Application

(

)

Definition at line 511 of file application.cpp.

                          {
  for(auto& coupler : m_couplers) {
    coupler.reset();
  }
  m_couplers.clear();
 
  for(auto& solver : m_solvers) {
    solver.reset();
  }
  m_solvers.clear();
}

Application() [2/3]

Application::Application ( const Application &  )

delete

Application() [3/3]

Application::Application ( Application &&  )

delete

Member Function Documentation

cleanUp()

void Application::cleanUp ( )

private

Definition at line 2534 of file application.cpp.

                          {
  TRACE();
 
  // Clean up
  for(MInt i = 0; i < m_noSolvers; i++) {
    m_solvers[i]->cleanUp();
  }
  for(auto&& coupler : m_couplers) {
    coupler->cleanUp();
  }
}

collectTimingsAndSolverInformation()

void Application::collectTimingsAndSolverInformation ( const MBool  finalTimeStep )

private

Definition at line 2346 of file application.cpp.

                                                                              {
  // Return if not enabled
  if(!m_writeSolverTimings) {
    return;
  }
 
  const MBool isSamplingStep = (globalTimeStep % m_solverTimingsSampleInterval == 0);
  const MInt noSolversAndCouplers = m_noSolvers + m_noCouplers;
  const MBool allTimings = m_writeAllSolverTimings;
 
  if(isSamplingStep) {
    // Store time step
    m_solverTimingsTimeStep.push_back(globalTimeStep);
 
    // TODO labels:TIMERS store domainInfo for each sampling time step/for each changed domain decomposition?
    // Determine domain decomposition information of each solver
    m_domainInfo.clear();
    for(MInt solverId = 0; solverId < m_noSolvers; solverId++) {
      m_solvers[solverId]->getDomainDecompositionInformation(m_domainInfo);
    }
    for(MInt i = 0; i < m_noCouplers; i++) {
      m_couplers[i]->getDomainDecompositionInformation(m_domainInfo);
    }
  }
 
  // TODO labels:TIMERS if a sample interval N > 1 is given, just sample every N-th step (current status ) or
  // compute an average? Note: for computing an average the number of timings might not correspond
  // to the sample-interval
  MInt timerIndex = 0;
  for(MInt j = 0; j < noSolversAndCouplers; j++) {
    const MBool isSolver = (j < m_noSolvers);
    const MInt noTimers = (isSolver) ? m_solvers[j]->noSolverTimers(allTimings)
                                     : m_couplers[j - m_noSolvers]->noCouplingTimers(allTimings);
 
    // Get timing records of solver/coupler
    std::vector<std::pair<MString, MFloat>> timings{};
    (isSolver) ? m_solvers[j]->getSolverTimings(timings, allTimings)
               : m_couplers[j - m_noSolvers]->getCouplingTimings(timings, allTimings);
 
    if((MInt)timings.size() != noTimers) {
      TERMM(1, "Wrong number of solver timings returned by getSolverTimings(): is " + std::to_string(timings.size())
                   + ", should be " + std::to_string(noTimers));
    }
 
    for(MInt i = 0; i < noTimers; i++) {
      const MFloat timing = timings[i].second;
      const MString name = timings[i].first;
      // Compute time difference
      MFloat diff = timing - m_solverTimingsPrevTime[timerIndex];
 
      if(name != m_solverTimingsNames[timerIndex]) {
        TERMM(1, "Timer name does not match.");
      }
 
      // This happens if the DLB timers were reset from the gridcontroller
      if(diff < 0.0) {
        diff = timing;
      }
 
      // Only store timing if it should be written to the timings file
      if(isSamplingStep) {
        m_solverTimings[timerIndex].push_back(diff);
      }
 
      m_solverTimingsPrevTime[timerIndex] = timing;
      timerIndex++;
    }
  }
 
  // Store timings if this is the final time step or a timings write time step
  storeTimingsAndSolverInformation(finalTimeStep);
}

createCoupler()

template<MInt nDim>

void Application::createCoupler ( MInt  couplerId )

private

Author

Thomas Hoesgen

Date

10/2019

Definition at line 1588 of file application.cpp.

                                              {
  TRACE();
 
  const MString couplerType = Context::getBasicProperty<MString>("couplerType_" + std::to_string(couplerId), AT_);
 
  cerr0 << "=== Create coupler #" << couplerId << " " << couplerType << std::endl;
 
  // Determine which solvers the coupler is supposed to couple
  // TODO labels:COUPLER allow more than 2 solvers to be coupled, e.g. for multilevel
  MInt solverToCoupleLength = Context::propertyLength("solversToCouple_" + std::to_string(couplerId));
  std::vector<MInt> solversToCouple;
  for(MInt solver = 0; solver < solverToCoupleLength; solver++) {
    solversToCouple.push_back(-1);
    if(Context::propertyExists("solversToCouple_" + std::to_string(couplerId))) {
      solversToCouple[solver] =
          Context::getBasicProperty<MInt>("solversToCouple_" + std::to_string(couplerId), AT_, nullptr, solver);
      if(solversToCouple[solver] < 0 || solversToCouple[solver] >= m_noSolvers) {
        TERMM(1, "Invalid solver id: " + std::to_string(solversToCouple[solver]));
      }
    } else {
      TERMM(1, "solversToCouple_" + std::to_string(couplerId) + " has to be specified!");
    }
  }
 
  // Create the coupler
  //
  switch(string2enum(couplerType)) {
    case COUPLER_LB_DG_APE: {
      const MInt nDist = Context::getSolverProperty<MInt>("noDistributions", solversToCouple[0], AT_);
      switch(nDist) {
        case 19: {
          using SysEqnLb = lb::LbSysEqnIncompressible<3, 19>;
          const auto lbSolver = static_cast<LbSolverDxQy<3, 19, SysEqnLb>*>(m_solvers[solversToCouple[0]].get());
          const auto dgSolver =
              static_cast<DgCartesianSolver<3, DgSysEqnAcousticPerturb<3>>*>(m_solvers[solversToCouple[1]].get());
          m_couplers[couplerId] = make_unique<LbDgApe<3, 19, SysEqnLb>>(couplerId, lbSolver, dgSolver);
          break;
        }
        case 27: {
          using SysEqnLb = lb::LbSysEqnIncompressible<3, 27>;
          const auto lbSolver = static_cast<LbSolverDxQy<3, 27, SysEqnLb>*>(m_solvers[solversToCouple[0]].get());
          const auto dgSolver =
              static_cast<DgCartesianSolver<3, DgSysEqnAcousticPerturb<3>>*>(m_solvers[solversToCouple[1]].get());
          m_couplers[couplerId] = make_unique<LbDgApe<3, 27, SysEqnLb>>(couplerId, lbSolver, dgSolver);
          break;
        }
        default: {
          mTerm(1, "Unknown number of distributions! Only working for q19 and q27, yet.");
        }
      }
      break;
    }
    case COUPLER_LS_FV_MB: {
      MInt fvSystemEquations = string2enum("FV_SYSEQN_NS");
      if(Context::propertyExists("fvSystemEquations", solversToCouple[1])) {
        fvSystemEquations =
            string2enum(Context::getSolverProperty<MString>("fvSystemEquations", solversToCouple[1], AT_));
      }
      switch(fvSystemEquations) {
        case FV_SYSEQN_RANS: {
          m_couplers[couplerId] =
              make_unique<typename LsFvMbXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>::type>(
                  couplerId,
                  static_cast<typename LsCartesianSolverXD<nDim>::type*>(m_solvers[solversToCouple[0]].get()),
                  static_cast<FvMbCartesianSolverXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>*>(
                      m_solvers[solversToCouple[1]].get()));
          break;
        }
        case FV_SYSEQN_NS:
        default: {
          m_couplers[couplerId] = make_unique<typename LsFvMbXD<nDim, FvSysEqnNS<nDim>>::type>(
              couplerId,
              static_cast<typename LsCartesianSolverXD<nDim>::type*>(m_solvers[solversToCouple[0]].get()),
              static_cast<FvMbCartesianSolverXD<nDim, FvSysEqnNS<nDim>>*>(m_solvers[solversToCouple[1]].get()));
          break;
        }
      }
 
      break;
    }
    case COUPLER_FV_ZONAL_RTV: {
      MString ransMethod = "";
      if(Context::propertyExists("ransMethod", solversToCouple[0])) {
        ransMethod = Context::getSolverProperty<MString>("ransMethod", solversToCouple[0], AT_);
      }
      switch(string2enum(ransMethod)) {
        case RANS_SA:
        case RANS_SA_DV: {
          m_couplers[couplerId] = make_unique<FvZonalRTV<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>>(
              couplerId,
              static_cast<FvCartesianSolverXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>*>(
                  m_solvers[solversToCouple[0]].get()),
              static_cast<FvCartesianSolverXD<nDim, FvSysEqnNS<nDim>>*>(m_solvers[solversToCouple[1]].get()));
          break;
        }
        case RANS_FS: {
          m_couplers[couplerId] = make_unique<FvZonalRTV<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_FS>>>>(
              couplerId,
              static_cast<FvCartesianSolverXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_FS>>>*>(
                  m_solvers[solversToCouple[0]].get()),
              static_cast<FvCartesianSolverXD<nDim, FvSysEqnNS<nDim>>*>(m_solvers[solversToCouple[1]].get()));
          break;
        }
        default: {
          TERMM(1, "Unknown RANS model for solver " + to_string(solversToCouple[0]));
        }
      }
      break;
    }
    case COUPLER_FV_ZONAL_STG: {
      MString ransMethod = "";
      if(Context::propertyExists("ransMethod", solversToCouple[0])) {
        ransMethod = Context::getSolverProperty<MString>("ransMethod", solversToCouple[0], AT_);
      }
      switch(string2enum(ransMethod)) {
        case RANS_SA:
        case RANS_SA_DV: {
          m_couplers[couplerId] = make_unique<FvZonalSTG<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>>(
              couplerId,
              static_cast<FvCartesianSolverXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>*>(
                  m_solvers[solversToCouple[0]].get()),
              static_cast<FvCartesianSolverXD<nDim, FvSysEqnNS<nDim>>*>(m_solvers[solversToCouple[1]].get()));
          break;
        }
        case RANS_FS: {
          m_couplers[couplerId] = make_unique<FvZonalSTG<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_FS>>>>(
              couplerId,
              static_cast<FvCartesianSolverXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_FS>>>*>(
                  m_solvers[solversToCouple[0]].get()),
              static_cast<FvCartesianSolverXD<nDim, FvSysEqnNS<nDim>>*>(m_solvers[solversToCouple[1]].get()));
          break;
        }
        default: {
          TERMM(1, "Unknown RANS model for solver " + to_string(solversToCouple[0]));
        }
      }
      break;
    }
    case COUPLER_FV_MB_ZONAL: {
      MInt fvSystemEquations = string2enum("FV_SYSEQN_NS");
      if(Context::propertyExists("fvSystemEquations", solversToCouple[1])) {
        fvSystemEquations =
            string2enum(Context::getSolverProperty<MString>("fvSystemEquations", solversToCouple[1], AT_));
      }
      switch(fvSystemEquations) {
        case FV_SYSEQN_RANS: {
          m_couplers[couplerId] =
              make_unique<CouplerFvMbZonal<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>>(
                  couplerId,
                  static_cast<FvMbCartesianSolverXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>*>(
                      m_solvers[solversToCouple[0]].get()),
                  static_cast<FvMbCartesianSolverXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>*>(
                      m_solvers[solversToCouple[1]].get()));
          break;
        }
        case FV_SYSEQN_NS:
        default: {
          m_couplers[couplerId] = make_unique<CouplerFvMbZonal<nDim, FvSysEqnNS<nDim>>>(
              couplerId,
              static_cast<FvMbCartesianSolverXD<nDim, FvSysEqnNS<nDim>>*>(m_solvers[solversToCouple[0]].get()),
              static_cast<FvMbCartesianSolverXD<nDim, FvSysEqnNS<nDim>>*>(m_solvers[solversToCouple[1]].get()));
          break;
        }
      }
      break;
    }
 
    case COUPLER_CARTESIAN_INTERPOLATION: {
      MInt fvSystemEquations = string2enum("FV_SYSEQN_NS");
      if(Context::propertyExists("fvSystemEquations", solversToCouple[1])) {
        fvSystemEquations =
            string2enum(Context::getSolverProperty<MString>("fvSystemEquations", solversToCouple[1], AT_));
      }
      switch(fvSystemEquations) {
        case FV_SYSEQN_RANS: {
          m_couplers[couplerId] =
              make_unique<FvCartesianInterpolation<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>,
                                                   FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>>(
                  couplerId,
                  static_cast<FvCartesianSolverXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>*>(
                      m_solvers[solversToCouple[0]].get()),
                  static_cast<FvCartesianSolverXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>*>(
                      m_solvers[solversToCouple[1]].get()));
          break;
        }
        case FV_SYSEQN_NS:
        default: {
          m_couplers[couplerId] = make_unique<
              FvCartesianInterpolation<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>, FvSysEqnNS<nDim>>>(
              couplerId,
              static_cast<FvCartesianSolverXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>*>(
                  m_solvers[solversToCouple[0]].get()),
              static_cast<FvCartesianSolverXD<nDim, FvSysEqnNS<nDim>>*>(m_solvers[solversToCouple[1]].get()));
          break;
        }
      }
      break;
    }
 
    case COUPLER_FV_MULTILEVEL: {
      // Note: couple all solvers (FV) in a multilevel computation
      auto fvSolvers = std::vector<FvCartesianSolverXD<nDim, FvSysEqnNS<nDim>>*>{};
      for(MInt s = 0; s < (MInt)solversToCouple.size(); s++) {
        fvSolvers.push_back(
            static_cast<FvCartesianSolverXD<nDim, FvSysEqnNS<nDim>>*>(m_solvers[solversToCouple[s]].get()));
      }
      m_couplers[couplerId] = make_unique<CouplerFvMultilevel<nDim, FvSysEqnNS<nDim>>>(couplerId, fvSolvers);
 
      break;
    }
 
    case COUPLER_FV_MULTILEVEL_INTERPOLATION: {
      // Multilevel interpolation: use coarse grid restart and interpolate it onto the finer grid(s)/solver(s)
      auto fvSolvers = std::vector<FvCartesianSolverXD<nDim, FvSysEqnNS<nDim>>*>{};
      for(MInt s = 0; s < (MInt)solversToCouple.size(); s++) {
        fvSolvers.push_back(
            static_cast<FvCartesianSolverXD<nDim, FvSysEqnNS<nDim>>*>(m_solvers[solversToCouple[s]].get()));
      }
      m_couplers[couplerId] =
          make_unique<CouplerFvMultilevelInterpolation<nDim, FvSysEqnNS<nDim>>>(couplerId, fvSolvers);
      break;
    }
 
    case COUPLER_FV_DG_APE: {
      m_couplers[couplerId] = make_unique<DgCcAcousticPerturb<nDim, FvSysEqnNS<nDim>>>(
          couplerId,
          static_cast<FvCartesianSolverXD<nDim, FvSysEqnNS<nDim>>*>(m_solvers[solversToCouple[0]].get()),
          static_cast<DgCartesianSolver<nDim, DgSysEqnAcousticPerturb<nDim>>*>(m_solvers[solversToCouple[1]].get()));
      break;
    }
    case COUPLER_LS_LB: {
      MInt nDist = 27;
      nDist = Context::getSolverProperty<MInt>("noDistributions", solversToCouple[1], AT_, &nDist);
 
      switch(nDist) {
        case 9: {
          auto lsSolver = static_cast<typename LsCartesianSolverXD<2>::type*>(m_solvers[solversToCouple[0]].get());
          using SysEqnLb = lb::LbSysEqnIncompressible<2, 9>;
          auto lbSolver = static_cast<LbSolverDxQy<2, 9, SysEqnLb>*>(m_solvers[solversToCouple[1]].get());
          m_couplers[couplerId] = make_unique<LsLb<2, 9, SysEqnLb>>(couplerId, lsSolver, lbSolver);
 
          break;
        }
        case 19: {
          auto lsSolver = static_cast<typename LsCartesianSolverXD<3>::type*>(m_solvers[solversToCouple[0]].get());
          using SysEqnLb = lb::LbSysEqnIncompressible<3, 19>;
          auto lbSolver = static_cast<LbSolverDxQy<3, 19, SysEqnLb>*>(m_solvers[solversToCouple[1]].get());
          m_couplers[couplerId] = make_unique<LsLb<3, 19, SysEqnLb>>(couplerId, lsSolver, lbSolver);
 
          break;
        }
        case 27: {
          auto lsSolver = static_cast<typename LsCartesianSolverXD<3>::type*>(m_solvers[solversToCouple[0]].get());
          using SysEqnLb = lb::LbSysEqnIncompressible<3, 27>;
          auto lbSolver = static_cast<LbSolverDxQy<3, 27, SysEqnLb>*>(m_solvers[solversToCouple[1]].get());
          m_couplers[couplerId] = make_unique<LsLb<3, 27, SysEqnLb>>(couplerId, lsSolver, lbSolver);
 
          break;
        }
        default: {
          mTerm(1, "Unknown number of distributions!");
        }
      }
 
      break;
    }
 
    case COUPLER_LB_RB: {
      MInt nDist = 27;
      nDist = Context::getSolverProperty<MInt>("noDistributions", solversToCouple[0], AT_, &nDist);
 
      switch(nDist) {
        case 9: {
          using SysEqnLb = lb::LbSysEqnIncompressible<2, 9>;
          auto lbSolver = static_cast<LbSolverDxQy<2, 9, SysEqnLb>*>(m_solvers[solversToCouple[0]].get());
          auto rigidBodies = static_cast<RigidBodies<2>*>(m_solvers[solversToCouple[1]].get());
          m_couplers[couplerId] = make_unique<LbRb<2, 9, SysEqnLb>>(couplerId, lbSolver, rigidBodies);
 
          break;
        }
        case 19: {
          using SysEqnLb = lb::LbSysEqnIncompressible<3, 19>;
          auto lbSolver = static_cast<LbSolverDxQy<3, 19, SysEqnLb>*>(m_solvers[solversToCouple[0]].get());
          auto rigidBodies = static_cast<RigidBodies<3>*>(m_solvers[solversToCouple[1]].get());
          m_couplers[couplerId] = make_unique<LbRb<3, 19, SysEqnLb>>(couplerId, lbSolver, rigidBodies);
 
          break;
        }
        case 27: {
          using SysEqnLb = lb::LbSysEqnIncompressible<3, 27>;
          auto lbSolver = static_cast<LbSolverDxQy<3, 27, SysEqnLb>*>(m_solvers[solversToCouple[0]].get());
          auto rigidBodies = static_cast<RigidBodies<3>*>(m_solvers[solversToCouple[1]].get());
          m_couplers[couplerId] = make_unique<LbRb<3, 27, SysEqnLb>>(couplerId, lbSolver, rigidBodies);
 
          break;
        }
        default: {
          mTerm(1, "Unknown number of distributions!");
        }
      }
      break;
    }
 
    case COUPLER_LB_LPT: {
      MInt nDist = 27;
      nDist = Context::getSolverProperty<MInt>("noDistributions", solversToCouple[1], AT_, &nDist);
 
      switch(nDist) {
        case 9: {
          IF_CONSTEXPR(nDim == 3) { mTerm(1, "LPT not supported in 2D!"); }
          break;
        }
        case 19: {
          using SysEqnLb = lb::LbSysEqnIncompressible<3, 19>;
          auto lbSolver = static_cast<LbSolverDxQy<3, 19, SysEqnLb>*>(m_solvers[solversToCouple[0]].get());
          auto particleSolver = static_cast<LPT<3>*>(m_solvers[solversToCouple[1]].get());
          m_couplers[couplerId] = make_unique<LbLpt<3, 19, SysEqnLb>>(couplerId, particleSolver, lbSolver);
 
          break;
        }
        case 27: {
          using SysEqnLb = lb::LbSysEqnIncompressible<3, 27>;
          auto lbSolver = static_cast<LbSolverDxQy<3, 27, SysEqnLb>*>(m_solvers[solversToCouple[0]].get());
          auto particleSolver = static_cast<LPT<3>*>(m_solvers[solversToCouple[1]].get());
          m_couplers[couplerId] = make_unique<LbLpt<3, 27, SysEqnLb>>(couplerId, particleSolver, lbSolver);
 
          break;
        }
        default: {
          mTerm(1, "Unknown number of distributions!");
        }
      }
      break;
    }
 
    case COUPLER_LS_LB_SURFACE: {
      MInt nDist = 27;
      nDist = Context::getSolverProperty<MInt>("noDistributions", solversToCouple[1], AT_, &nDist);
 
      switch(nDist) {
        case 9: {
          auto lsSolver = static_cast<typename LsCartesianSolverXD<2>::type*>(m_solvers[solversToCouple[0]].get());
          using SysEqnLb = lb::LbSysEqnIncompressible<2, 9>;
          auto lbSolver = static_cast<LbSolverDxQy<2, 9, SysEqnLb>*>(m_solvers[solversToCouple[1]].get());
          m_couplers[couplerId] = make_unique<LsLbSurface<2, 9, SysEqnLb>>(couplerId, lsSolver, lbSolver);
 
          break;
        }
        case 19: {
          auto lsSolver = static_cast<typename LsCartesianSolverXD<3>::type*>(m_solvers[solversToCouple[0]].get());
          using SysEqnLb = lb::LbSysEqnIncompressible<3, 19>;
          auto lbSolver = static_cast<LbSolverDxQy<3, 19, SysEqnLb>*>(m_solvers[solversToCouple[1]].get());
          m_couplers[couplerId] = make_unique<LsLbSurface<3, 19, SysEqnLb>>(couplerId, lsSolver, lbSolver);
 
          break;
        }
        case 27: {
          auto lsSolver = static_cast<typename LsCartesianSolverXD<3>::type*>(m_solvers[solversToCouple[0]].get());
          using SysEqnLb = lb::LbSysEqnIncompressible<3, 27>;
          auto lbSolver = static_cast<LbSolverDxQy<3, 27, SysEqnLb>*>(m_solvers[solversToCouple[1]].get());
          m_couplers[couplerId] = make_unique<LsLbSurface<3, 27, SysEqnLb>>(couplerId, lsSolver, lbSolver);
 
          break;
        }
        default: {
          mTerm(1, "Unknown number of distributions!");
        }
      }
 
      break;
    }
 
    case COUPLER_LS_FV: {
      auto lsSolver = static_cast<typename LsCartesianSolverXD<nDim>::type*>(m_solvers[solversToCouple[0]].get());
      MInt fvSystemEquations = string2enum("FV_SYSEQN_NS");
      if(Context::propertyExists("fvSystemEquations", solversToCouple[1])) {
        fvSystemEquations =
            string2enum(Context::getSolverProperty<MString>("fvSystemEquations", solversToCouple[1], AT_));
      }
      switch(fvSystemEquations) {
        case FV_SYSEQN_RANS: {
          auto fvSolvers = (FvCartesianSolverXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>*)
                               m_solvers[solversToCouple[1]]
                                   .get();
          m_couplers[couplerId] =
              make_unique<typename CouplingLsFvXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>::type>(
                  couplerId, lsSolver, fvSolvers);
          break;
        }
        default: {
          auto fvSolvers = (FvCartesianSolverXD<nDim, FvSysEqnNS<nDim>>*)m_solvers[solversToCouple[1]].get();
          m_couplers[couplerId] =
              make_unique<typename CouplingLsFvXD<nDim, FvSysEqnNS<nDim>>::type>(couplerId, lsSolver, fvSolvers);
        }
      }
 
      break;
    }
 
    case COUPLER_LS_FV_COMBUSTION: {
      auto lsSolverId = solversToCouple[0];
      auto fvSolverId = solversToCouple[1];
 
      m_couplers[couplerId] = make_unique<typename LsFvCombustionXD<nDim, FvSysEqnNS<nDim>>::type>(
          couplerId,
          static_cast<typename LsCartesianSolverXD<nDim>::type*>(m_solvers[lsSolverId].get()),
          static_cast<FvCartesianSolverXD<nDim, FvSysEqnNS<nDim>>*>(m_solvers[fvSolverId].get()));
      break;
    }
 
    case COUPLER_LB_FV_EE_MULTIPHASE: {
      MInt fvSystemEquations = string2enum("FV_SYSEQN_NS");
      if(Context::propertyExists("fvSystemEquations", solversToCouple[1])) {
        fvSystemEquations =
            string2enum(Context::getSolverProperty<MString>("fvSystemEquations", solversToCouple[1], AT_));
      }
      if(nDim != 3) mTerm(1, AT_, "LB-FV-Euler-Euler-Multiphase only implemented for nDim = 3");
 
      switch(fvSystemEquations) {
        case FV_SYSEQN_RANS: {
          mTerm(1, AT_, "RANS not supported in combination with LB-FV-EE-Multiphase!");
          break;
        }
        case FV_SYSEQN_EEGAS: {
          MInt nDist = 27;
          nDist = Context::getSolverProperty<MInt>("noDistributions", solversToCouple[0], AT_, &nDist);
 
          switch(nDist) {
            case 9: {
              mTerm(1, "nDist = 9 not supported with EE Multiphase!");
 
              break;
            }
            case 19: {
              using SysEqnLb = lb::LbSysEqnIncompressible<3, 19>;
              auto lbSolver = static_cast<LbSolverDxQy<3, 19, SysEqnLb>*>(m_solvers[solversToCouple[0]].get());
              auto fvSolver =
                  static_cast<FvCartesianSolverXD<3, FvSysEqnEEGas<3>>*>(m_solvers[solversToCouple[1]].get());
 
              m_couplers[couplerId] = make_unique<CouplerLbFvEEMultiphase<3, 19, SysEqnLb, FvSysEqnEEGas<3>>>(
                  couplerId, lbSolver, fvSolver);
 
              break;
            }
            case 27: {
              using SysEqnLb = lb::LbSysEqnIncompressible<3, 27>;
              auto lbSolver = static_cast<LbSolverDxQy<3, 27, SysEqnLb>*>(m_solvers[solversToCouple[0]].get());
              auto fvSolver =
                  static_cast<FvCartesianSolverXD<3, FvSysEqnEEGas<3>>*>(m_solvers[solversToCouple[1]].get());
 
              m_couplers[couplerId] = make_unique<CouplerLbFvEEMultiphase<3, 27, SysEqnLb, FvSysEqnEEGas<3>>>(
                  couplerId, lbSolver, fvSolver);
 
              break;
            }
            default: {
              mTerm(1, "Unknown number of distributions!");
            }
          }
          break;
        }
        case FV_SYSEQN_NS:
        default: {
          mTerm(1, AT_, "This SysEqn is not supported in combination with LB-FV-EE-Multiphase!");
          break;
        }
      }
      break;
    }
 
    case COUPLER_LB_LB: {
      MInt nDist = 27;
      nDist = Context::getSolverProperty<MInt>("noDistributions", solversToCouple[0], AT_, &nDist);
      {
        const MInt tempNDist = Context::getSolverProperty<MInt>("noDistributions", solversToCouple[1], AT_, &nDist);
        if(nDist != tempNDist) mTerm(1, AT_, "Can't couple LB solvers with different noDistributions!");
      }
      switch(nDist) {
        case 9: {
          using SysEqnLb = lb::LbSysEqnIncompressible<2, 9>;
          std::vector<LbSolverDxQy<2, 9, SysEqnLb>*> lbSolvers;
          lbSolvers.push_back(static_cast<LbSolverDxQy<2, 9, SysEqnLb>*>(m_solvers[solversToCouple[0]].get()));
          lbSolvers.push_back(static_cast<LbSolverDxQy<2, 9, SysEqnLb>*>(m_solvers[solversToCouple[1]].get()));
          m_couplers[couplerId] = make_unique<CouplerLbLb<2, 9, SysEqnLb>>(couplerId, lbSolvers);
          break;
        }
        case 19: {
          using SysEqnLb = lb::LbSysEqnIncompressible<3, 19>;
          std::vector<LbSolverDxQy<3, 19, SysEqnLb>*> lbSolvers;
          lbSolvers.push_back(static_cast<LbSolverDxQy<3, 19, SysEqnLb>*>(m_solvers[solversToCouple[0]].get()));
          lbSolvers.push_back(static_cast<LbSolverDxQy<3, 19, SysEqnLb>*>(m_solvers[solversToCouple[1]].get()));
          m_couplers[couplerId] = make_unique<CouplerLbLb<3, 19, SysEqnLb>>(couplerId, lbSolvers);
          break;
        }
        case 27: {
          using SysEqnLb = lb::LbSysEqnIncompressible<3, 27>;
          std::vector<LbSolverDxQy<3, 27, SysEqnLb>*> lbSolvers;
          lbSolvers.push_back(static_cast<LbSolverDxQy<3, 27, SysEqnLb>*>(m_solvers[solversToCouple[0]].get()));
          lbSolvers.push_back(static_cast<LbSolverDxQy<3, 27, SysEqnLb>*>(m_solvers[solversToCouple[1]].get()));
          m_couplers[couplerId] = make_unique<CouplerLbLb<3, 27, SysEqnLb>>(couplerId, lbSolvers);
          break;
        }
        default: {
          mTerm(1, "Unknown number of distributions!");
        }
      }
      break;
    }
 
    case COUPLER_FV_PARTICLE: {
      auto particleSolver = static_cast<LPT<nDim>*>(m_solvers[solversToCouple[1]].get());
      MInt fvSystemEquations = string2enum("FV_SYSEQN_NS");
      if(Context::propertyExists("fvSystemEquations", solversToCouple[1])) {
        fvSystemEquations =
            string2enum(Context::getSolverProperty<MString>("fvSystemEquations", solversToCouple[1], AT_));
      }
      switch(fvSystemEquations) {
        case FV_SYSEQN_RANS: {
          auto fvSolver = static_cast<FvCartesianSolverXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>*>(
              m_solvers[solversToCouple[0]].get());
          if(nDim == 3) {
            m_couplers[couplerId] =
                make_unique<CouplerFvParticle<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>>(
                    couplerId, particleSolver, fvSolver);
          } else {
            mTerm(1, AT_, "FV Particle not supported in 2D!");
          }
          break;
        }
        case FV_SYSEQN_NS:
        default: {
          auto fvSolver =
              static_cast<FvCartesianSolverXD<nDim, FvSysEqnNS<nDim>>*>(m_solvers[solversToCouple[0]].get());
          if(nDim == 3) {
            m_couplers[couplerId] =
                make_unique<CouplerFvParticle<nDim, FvSysEqnNS<nDim>>>(couplerId, particleSolver, fvSolver);
          } else {
            mTerm(1, AT_, "FV Particle not supported in 2D!");
          }
 
          break;
        }
      }
      break;
    }
 
    default: {
      TERMM(1, "Unknown coupler type '" + couplerType + "', exiting ... ");
    }
  }
 
  m_log << "Created coupler #" << std::to_string(couplerId) << ": " << couplerType << " for solvers";
  for(MInt solver = 0; solver < 2; solver++) {
    m_log << " " << solversToCouple[solver];
  }
  m_log << std::endl;
}

createPostProcessing()

template<MInt nDim>

PostProcessingInterface * Application::createPostProcessing ( MInt  postprocessingId )

private

Author

Jannik Borgelt

Date

07/2020

Definition at line 2186 of file application.cpp.

                                                                                {
  TRACE();
 
  PostProcessingInterface* pp = nullptr;
 
  const MString postprocessingType =
      Context::getBasicProperty<MString>("postProcessingType_" + std::to_string(postprocessingId), AT_);
 
  // FIXME labels:PP,DOC read with _$postprocessingId and allow for multiple postProcessingSolverIds
  //       to specify the second/third solver Ids in coupled cases!
  const MInt postprocessingSolverId =
      Context::getBasicProperty<MInt>("postProcessingSolverIds", AT_, nullptr, postprocessingId);
 
  PostData<nDim>* postDataPointer = nullptr;
  // postprocessing for special output that does not need a PostData Solver
  if(m_postDataSolverId == -1) {
    if(globalDomainId() == 0)
      cerr << "\033[0;31m#### WARNING:\033[0m You are using a postprocessing routine without a PostData Solver!"
           << endl;
    m_postDataSolverId = postprocessingSolverId;
  } else {
    postDataPointer = static_cast<PostData<nDim>*>(m_solvers[m_postDataSolverId].get());
  }
 
  // Create the PostProcessing
  //
  switch(string2enum(postprocessingType)) {
    case POSTPROCESSING_FV: {
      MInt fvSystemEquations = string2enum("FV_SYSEQN_NS");
      if(Context::propertyExists("fvSystemEquations", postprocessingSolverId)) {
        fvSystemEquations =
            string2enum(Context::getSolverProperty<MString>("fvSystemEquations", postprocessingSolverId, AT_));
      }
      switch(fvSystemEquations) {
        case FV_SYSEQN_RANS: {
          pp = new PostProcessingFv<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>(
              postprocessingId,
              postDataPointer,
              static_cast<FvCartesianSolverXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>*>(
                  m_solvers[postprocessingSolverId].get()));
          break;
        }
        case FV_SYSEQN_EEGAS: {
          IF_CONSTEXPR(nDim == 2)
          mTerm(1, AT_, "FVSysEqnEEGas is not tested for 2D at all and probably does not make much sense!");
          else pp = new PostProcessingFv<nDim, FvSysEqnEEGas<nDim>>(
              postprocessingId,
              postDataPointer,
              static_cast<FvCartesianSolverXD<nDim, FvSysEqnEEGas<nDim>>*>(m_solvers[postprocessingSolverId].get()));
          break;
        }
        case FV_SYSEQN_NS: {
          pp = new PostProcessingFv<nDim, FvSysEqnNS<nDim>>(
              postprocessingId,
              postDataPointer,
              static_cast<FvCartesianSolverXD<nDim, FvSysEqnNS<nDim>>*>(m_solvers[postprocessingSolverId].get()));
          break;
        }
        case FV_SYSEQN_DETCHEM: {
          pp = new PostProcessingFv<nDim, FvSysEqnDetChem<nDim>>(
              postprocessingId,
              static_cast<PostData<nDim>*>(m_solvers[m_postDataSolverId].get()),
              static_cast<FvCartesianSolverXD<nDim, FvSysEqnDetChem<nDim>>*>(m_solvers[postprocessingSolverId].get()));
          break;
        }
        default:
          TERMM(1, "Unsupported system of equations.");
      }
      break;
    }
    case POSTPROCESSING_DG: {
      const MInt dgSystemEquations =
          string2enum(Context::getSolverProperty<MString>("dgSystemEquations", postprocessingSolverId, AT_));
      switch(dgSystemEquations) {
        case DG_SYSEQN_ACOUSTICPERTURB: {
          pp = new PostProcessingDg<nDim, DgSysEqnAcousticPerturb<nDim>>(
              postprocessingId,
              postDataPointer,
              static_cast<DgCartesianSolver<nDim, DgSysEqnAcousticPerturb<nDim>>*>(
                  m_solvers[postprocessingSolverId].get()));
          break;
        }
        case DG_SYSEQN_LINEARSCALARADV: {
          pp = new PostProcessingDg<nDim, DgSysEqnLinearScalarAdv<nDim>>(
              postprocessingId,
              postDataPointer,
              static_cast<DgCartesianSolver<nDim, DgSysEqnLinearScalarAdv<nDim>>*>(
                  m_solvers[postprocessingSolverId].get()));
          break;
        }
        default:
          TERMM(1, "Unsupported system of equations.");
      }
      break;
    }
    case POSTPROCESSING_LB: {
      pp = new PostProcessingLb<nDim>(postprocessingId, postDataPointer,
                                      static_cast<LbSolver<nDim>*>(m_solvers[postprocessingSolverId].get()));
      break;
    }
    case POSTPROCESSING_FVLPT: {
      MInt fvSystemEquations = string2enum("FV_SYSEQN_NS");
      if(Context::propertyExists("fvSystemEquations", postprocessingSolverId)) {
        fvSystemEquations =
            string2enum(Context::getSolverProperty<MString>("fvSystemEquations", postprocessingSolverId, AT_));
      }
      switch(fvSystemEquations) {
        case FV_SYSEQN_RANS: {
          if(nDim == 3) {
            pp = new PostProcessingFvLPT<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>(
                postprocessingId,
                postDataPointer,
                static_cast<FvCartesianSolverXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>*>(
                    m_solvers[postprocessingSolverId].get()),
                static_cast<LPT<nDim>*>(m_solvers[postprocessingSolverId + 1].get()));
          } else {
            mTerm(1, AT_, "LPT not supported in 2D!");
          }
          break;
        }
        case FV_SYSEQN_NS: {
          if(nDim == 3) {
            pp = new PostProcessingFvLPT<nDim, FvSysEqnNS<nDim>>(
                postprocessingId,
                postDataPointer,
                static_cast<FvCartesianSolverXD<nDim, FvSysEqnNS<nDim>>*>(m_solvers[postprocessingSolverId].get()),
                static_cast<LPT<nDim>*>(m_solvers[postprocessingSolverId + 1].get()));
          } else {
            mTerm(1, AT_, "LPT not supported in 2D!");
          }
          break;
        }
        default:
          TERMM(1, "Unsupported system of equations.");
      }
      break;
    }
    case POSTPROCESSING_LBLPT: {
      if(nDim == 3) {
        pp = new PostProcessingLbLPT<nDim>(postprocessingId,
                                           postDataPointer,
                                           static_cast<LbSolver<nDim>*>(m_solvers[postprocessingSolverId].get()),
                                           static_cast<LPT<nDim>*>(m_solvers[postprocessingSolverId + 1].get()));
      } else {
        mTerm(1, AT_, "LPT not supported in 2D!");
      }
      break;
    }
    default: {
      TERMM(1, "Unknown postprocessing type '" + postprocessingType + "', exiting ... ");
    }
  }
 
  m_log << "Created postprocessing #" << std::to_string(postprocessingId) << ": " << postprocessingType << " for solver"
        << " " << postprocessingSolverId << std::endl;
 
  return pp;
}

createRecipe()

ExecutionRecipe * Application::createRecipe ( )

private

Author

Thomas Hoesgen

Date

10/2019

Definition at line 2151 of file application.cpp.

                                           {
  TRACE();
 
  ExecutionRecipe* recipe = nullptr;
 
  const MString recipeType = Context::getBasicProperty<MString>("executionRecipe", AT_);
 
  switch(string2enum(recipeType)) {
    case RECIPE_BASE: {
      recipe = new ExecutionRecipe(&m_solvers, &m_couplers);
      break;
    }
    case RECIPE_INTRASTEP: {
      recipe = new ExecutionRecipeIntraStepCoupling(&m_solvers, &m_couplers);
      break;
    }
    case RECIPE_ITERATION: {
      recipe = new ExecutionRecipeSolutionIteration(&m_solvers, &m_couplers);
      break;
    }
    default: {
      TERMM(1, "Unknown execution recipe '" + recipeType + "', exiting ... ");
    }
  }
 
  m_log << "Created execution recipe: " << recipeType << " for " << m_noSolvers << " solvers" << std::endl;
 
  return recipe;
}

createSolver() [1/3]

template<MInt nDim>

void Application::createSolver ( CartesianGrid< nDim > *  grid, const MInt  solverId, Geometry< nDim > *  geometry, MBool *  propertiesGroups, MBool &  isActive  )

private

Author

Thomas Hoesgen

Date

10/2019

Definition at line 1361 of file application.cpp.

                                                                         {
  TRACE();
 
 
  // Determine solver type from property file
  const MString solverType = Context::getSolverProperty<MString>("solvertype", solverId, AT_);
 
  grid::Proxy<nDim>* gridProxy = nullptr;
  gridProxy = new grid::Proxy<nDim>(solverId, *grid, *geometry);
  isActive = gridProxy->isActive();
 
  // Now create the specified solver
  switch(string2enum(solverType)) {
    case MAIA_LEVELSET_SOLVER: {
      m_solvers[solverId] = LsCartesianSolverFactory<nDim>::create(solverId, propertiesGroups, *gridProxy, *geometry,
                                                                   gridProxy->mpiComm());
      break;
    }
    case MAIA_FINITE_VOLUME: {
      MInt noSpecies = 0;
      noSpecies = Context::getSolverProperty<MInt>("noSpecies", solverId, AT_, &noSpecies);
      MInt fvSystemEquations = string2enum("FV_SYSEQN_NS");
      if(Context::propertyExists("fvSystemEquations", solverId)) {
        fvSystemEquations = string2enum(Context::getSolverProperty<MString>("fvSystemEquations", solverId, AT_));
      }
      MString ransMethod = "";
      if(Context::propertyExists("ransMethod", solverId)) {
        ransMethod = Context::getSolverProperty<MString>("ransMethod", solverId, AT_);
      }
      // cerr << ransMethod << endl;
      switch(fvSystemEquations) {
        case FV_SYSEQN_RANS: {
          switch(string2enum(ransMethod)) {
            case RANS_SA:
            case RANS_SA_DV: {
              m_solvers[solverId] =
                  make_unique<FvCartesianSolverXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>>(
                      solverId, noSpecies, propertiesGroups, *gridProxy, *geometry, gridProxy->mpiComm());
              break;
            }
            case RANS_FS: {
              m_solvers[solverId] =
                  make_unique<FvCartesianSolverXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_FS>>>>(
                      solverId, noSpecies, propertiesGroups, *gridProxy, *geometry, gridProxy->mpiComm());
              break;
            }
            case RANS_KOMEGA: {
              m_solvers[solverId] =
                  make_unique<FvCartesianSolverXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_KOMEGA>>>>(
                      solverId, noSpecies, propertiesGroups, *gridProxy, *geometry, gridProxy->mpiComm());
              break;
            }
            default: {
              TERMM(1, "Unknown RANS model for solver " + to_string(solverId));
            }
          }
          break;
        }
        case FV_SYSEQN_EEGAS: {
          IF_CONSTEXPR(nDim == 2)
          mTerm(1, AT_, "FVSysEqnEEGas is not tested for 2D at all and probably does not make much sense!");
          else m_solvers[solverId] = make_unique<FvCartesianSolverXD<nDim, FvSysEqnEEGas<nDim>>>(
              solverId, noSpecies, propertiesGroups, *gridProxy, *geometry, gridProxy->mpiComm());
          break;
        }
        case FV_SYSEQN_NS: {
          m_solvers[solverId] = make_unique<FvCartesianSolverXD<nDim, FvSysEqnNS<nDim>>>(
              solverId, noSpecies, propertiesGroups, *gridProxy, *geometry, gridProxy->mpiComm());
          break;
        }
        case FV_SYSEQN_DETCHEM: {
          m_solvers[solverId] = make_unique<FvCartesianSolverXD<nDim, FvSysEqnDetChem<nDim>>>(
              solverId, noSpecies, propertiesGroups, *gridProxy, *geometry, gridProxy->mpiComm());
          break;
        }
        default:
          TERMM(1, "Unsupported system of equations.");
      }
      break;
    }
    case MAIA_FV_APE: {
      // TODO labels:FV switch to FV-solver with fvSystemEquations=APE?
      m_solvers[solverId] = make_unique<typename FvApeSolverXD<nDim>::type>(solverId, 0, propertiesGroups, *gridProxy,
                                                                            *geometry, gridProxy->mpiComm());
      break;
    }
    case MAIA_FV_MB: {
      MInt noSpecies = 0;
      noSpecies = Context::getSolverProperty<MInt>("noSpecies", solverId, AT_, &noSpecies);
      MInt fvSystemEquations = string2enum("FV_SYSEQN_NS");
      if(Context::propertyExists("fvSystemEquations", solverId)) {
        fvSystemEquations = string2enum(Context::getSolverProperty<MString>("fvSystemEquations", solverId, AT_));
      }
      switch(fvSystemEquations) {
        case FV_SYSEQN_RANS: {
          m_solvers[solverId] =
              make_unique<FvMbCartesianSolverXD<nDim, FvSysEqnRANS<nDim, RANSModelConstants<RANS_SA_DV>>>>(
                  solverId, noSpecies, propertiesGroups, *gridProxy, *geometry, gridProxy->mpiComm());
          break;
        }
        case FV_SYSEQN_NS: {
          m_solvers[solverId] = make_unique<FvMbCartesianSolverXD<nDim, FvSysEqnNS<nDim>>>(
              solverId, noSpecies, propertiesGroups, *gridProxy, *geometry, gridProxy->mpiComm());
          break;
        }
        default:
          TERMM(1, "Unsupported system of equations.");
      }
      break;
    }
    case MAIA_DISCONTINUOUS_GALERKIN: {
      const MInt dgSystemEquations =
          string2enum(Context::getSolverProperty<MString>("dgSystemEquations", solverId, AT_));
      switch(dgSystemEquations) {
        case DG_SYSEQN_ACOUSTICPERTURB: {
          m_solvers[solverId] = make_unique<DgCartesianSolver<nDim, DgSysEqnAcousticPerturb<nDim>>>(
              solverId, *gridProxy, *geometry, gridProxy->mpiComm());
          break;
        }
        case DG_SYSEQN_LINEARSCALARADV: {
          m_solvers[solverId] = make_unique<DgCartesianSolver<nDim, DgSysEqnLinearScalarAdv<nDim>>>(
              solverId, *gridProxy, *geometry, gridProxy->mpiComm());
          break;
        }
        default:
          TERMM(1, "Unsupported system of equations.");
      }
      break;
    }
    case MAIA_LATTICE_BOLTZMANN: {
      m_solvers[solverId] =
          maia::lb::LbSolverFactory<nDim>::create(solverId, *gridProxy, *geometry, gridProxy->mpiComm());
      break;
    }
    case MAIA_FINITE_CELL: {
      m_solvers[solverId] = make_unique<FcSolver<nDim>>(solverId, *gridProxy, *geometry, gridProxy->mpiComm());
      break;
    }
    case MAIA_PARTICLE: {
      IF_CONSTEXPR(nDim == 3) {
        m_solvers[solverId] = make_unique<LPT<nDim>>(solverId, *gridProxy, *geometry, gridProxy->mpiComm());
      }
      else {
        TERMM(-1, "LPT not currently supported in 2D");
      }
      break;
    }
    case MAIA_RIGID_BODIES: {
      m_solvers[solverId] = make_unique<RigidBodies<nDim>>(solverId, *gridProxy, *geometry, gridProxy->mpiComm());
      break;
    }
    case MAIA_POST_DATA: {
      m_solvers[solverId] = make_unique<PostData<nDim>>(solverId, *gridProxy, *geometry, gridProxy->mpiComm());
      if(m_postDataSolverId != -1) TERMM(1, "Currently not more than 1 PostData possible!");
      m_postDataSolverId = solverId;
      break;
    }
    default: {
      TERMM(1, "Unknown solver type '" + solverType + "', exiting ... ");
    }
  }
 
  m_log << "Created solver #" << std::to_string(solverId) << ": " << solverType
        << m_solvers[solverId]->getIdentifier(false, " with alias: ", "") << std::endl;
}

createSolver() [2/3]

template<MInt nDim>

void Application::createSolver ( const MInt  solverId, const MPI_Comm  comm  )

private

Definition at line 1562 of file application.cpp.

                                                                       {
  TRACE();
 
  // Determine solver type from property file
  const MString solverType = Context::getSolverProperty<MString>("solvertype", solverId, AT_);
 
  switch(string2enum(solverType)) {
    case MAIA_ACOUSTIC_ANALOGY: {
      m_solvers[solverId] = make_unique<AcaSolver<nDim>>(solverId, comm);
      break;
    }
    default: {
      TERMM(1, "Unknown solver type '" + solverType + "', exiting ... ");
    }
  }
 
  m_log << "Created solver #" << std::to_string(solverId) << ": " << solverType
        << m_solvers[solverId]->getIdentifier(false, " with alias: ", "") << std::endl;
}

createSolver() [3/3]

template<MInt nDim>

void Application::createSolver ( StructuredGrid< nDim > *  grid, const MInt  solverId, MBool *  propertiesGroups, const MPI_Comm  comm  )

private

Author

Julian Stemmermann

Date

05/2020

Definition at line 1534 of file application.cpp.

                                                    {
  TRACE();
 
 
  // Determine solver type from property file
  const MString solverType = Context::getSolverProperty<MString>("solvertype", solverId, AT_);
 
  // Now create the specified solver
  switch(string2enum(solverType)) {
    case MAIA_STRUCTURED: {
      m_solvers[solverId] =
          make_unique<typename FvStructuredSolverXD<nDim>::type>(solverId, grid, propertiesGroups, comm);
      break;
    }
    default: {
      TERMM(1, "Unknown solver type '" + solverType + "', exiting ... ");
    }
  }
 
  m_log << "Created solver #" << std::to_string(solverId) << ": " << solverType
        << m_solvers[solverId]->getIdentifier(false, " with alias: ", "") << std::endl;
}

getInitialTimeStep()

MInt Application::getInitialTimeStep ( const MBool  restartFile, const MPI_Comm  comm  )

private

Definition at line 1266 of file application.cpp.

                                                                                 {
  TRACE();
  if(!restartFile) {
    return 0;
  } else {
    MBool useNonSpecifiedRestartFile = false;
    useNonSpecifiedRestartFile =
        Context::getBasicProperty<MBool>("useNonSpecifiedRestartFile", AT_, &useNonSpecifiedRestartFile);
 
    if(!useNonSpecifiedRestartFile) {
      // Use given restart time step from properties
      return Context::getBasicProperty<MInt>("restartTimeStep", AT_);
    } else {
      // Restart time step not specified in properties, use the first suitable solver on rank 0 to
      // load time step from restart file and broadcast result
      MInt timeStep = -1;
      // TODO labels:totest,noissue this will not work if rank 0 does not have a solver with restart time step
      // information!
      if(globalDomainId() == 0) {
        for(MInt solver = 0; solver < m_noSolvers; solver++) {
          if(m_solvers[solver]->hasRestartTimeStep()) {
            timeStep = m_solvers[solver]->determineRestartTimeStep();
            break;
          }
        }
      }
      MPI_Bcast(&timeStep, 1, maia::type_traits<MInt>::mpiType(), 0, comm, AT_, "timeStep");
      m_log << "Determined global time step from restart file: " << timeStep << std::endl;
      return timeStep;
    }
  }
}

gridType()

MInt Application::gridType ( const MString  solverType )

private

Definition at line 1341 of file application.cpp.

                                                   {
  switch(string2enum(solverType)) {
    case MAIA_STRUCTURED: {
      return MAIA_GRID_STRUCTURED;
    }
    case MAIA_ACOUSTIC_ANALOGY: {
      return MAIA_GRID_NONE; // No grid required for acoustic extrapolation (e.g. FWH)
    }
    default: { // Default Cartesian grid
      return MAIA_GRID_CARTESIAN;
    }
  }
}

initTimings()

void Application::initTimings ( )

private

Definition at line 524 of file application.cpp.

                              {
  TRACE();
 
  // Return if not enabled
  if(!m_writeSolverTimings) {
    return;
  }
 
  const MInt noSolversAndCouplers = m_noSolvers + m_noCouplers;
  const MBool allTimings = m_writeAllSolverTimings;
  // Determine total number of timers and domain decomposition information of each solver/coupler
  m_noGlobalSolverTimers = 0;
 
  for(MInt i = 0; i < noSolversAndCouplers; i++) {
    const MInt noTimers = (i < m_noSolvers) ? m_solvers[i]->noSolverTimers(allTimings)
                                            : m_couplers[i - m_noSolvers]->noCouplingTimers(allTimings);
    m_noGlobalSolverTimers += noTimers;
  }
 
  MInt maxNoGlobalSolverTimers = -1;
  MPI_Allreduce(&m_noGlobalSolverTimers, &maxNoGlobalSolverTimers, 1, maia::type_traits<MInt>::mpiType(), MPI_MAX,
                MPI_COMM_WORLD, AT_, "m_noGlobalSolverTimers", "maxNoGlobalSolverTimers");
  if(maxNoGlobalSolverTimers != m_noGlobalSolverTimers) {
    TERMM(1, "Error: number of global solver timings does not match on all domains.");
  }
 
  m_solverTimings.clear();
  m_solverTimings.resize(m_noGlobalSolverTimers);
 
  m_solverTimingsPrevTime.clear();
  m_solverTimingsPrevTime.resize(m_noGlobalSolverTimers);
 
  m_solverTimingsTimeStep.clear();
  m_solverTimingsTimeStep.reserve(m_maxNoSolverTimings);
 
  // Reserve memory for timings (should be enough to avoid reallocation during solver run)
  for(MInt timerId = 0; timerId < m_noGlobalSolverTimers; timerId++) {
    m_solverTimings[timerId].clear();
    m_solverTimings[timerId].reserve(m_maxNoSolverTimings);
 
    m_solverTimingsPrevTime[timerId] = 0.0;
  }
 
  for(MInt i = 0; i < noSolversAndCouplers; i++) {
    const MInt noTimers = (i < m_noSolvers) ? m_solvers[i]->noSolverTimers(allTimings)
                                            : m_couplers[i - m_noSolvers]->noCouplingTimers(allTimings);
    // Get solver timer names
    std::vector<std::pair<MString, MFloat>> timings{};
    (i < m_noSolvers) ? m_solvers[i]->getSolverTimings(timings, allTimings)
                      : m_couplers[i - m_noSolvers]->getCouplingTimings(timings, allTimings);
    ASSERT((MInt)timings.size() == noTimers, "number of timings mismatch #" + std::to_string(i) + ": "
                                                 + std::to_string(timings.size()) + " != " + std::to_string(noTimers));
 
    for(MInt j = 0; j < noTimers; j++) {
      m_solverTimingsNames.push_back(timings[j].first);
    }
  }
 
  m_log << "Initialized collection of solver timings: " << m_noGlobalSolverTimers << std::endl;
}

operator=() [1/2]

Application & Application::operator= ( Application &&  )

delete

operator=() [2/2]

Application & Application::operator= ( const Application &  )

delete

readPropertiesGroups()

MBool * Application::readPropertiesGroups ( )

staticprivate

Author

Thomas Hoesgen

Date

10/2019

Definition at line 1304 of file application.cpp.

                                         {
  TRACE();
 
  MBool tmpFalse = false;
 
  auto* propertiesGroups = new MBool[PROPERTIESGROUPS_COUNT];
 
  fill(propertiesGroups, propertiesGroups + PROPERTIESGROUPS_COUNT, tmpFalse);
 
  propertiesGroups[LEVELSETMB] = Context::getBasicProperty<MBool>("levelSetMb", AT_, &tmpFalse);
  propertiesGroups[LEVELSET] = Context::getBasicProperty<MBool>("levelSet", AT_, &tmpFalse);
  propertiesGroups[LB] = Context::getBasicProperty<MBool>("lb", AT_, &tmpFalse);
  propertiesGroups[LS_SOLVER] = Context::getBasicProperty<MBool>("lsSolver", AT_, &tmpFalse);
  propertiesGroups[COMBUSTION] = Context::getBasicProperty<MBool>("combustion", AT_, &tmpFalse);
  propertiesGroups[DG] = Context::getBasicProperty<MBool>("DG", AT_, &tmpFalse);
  propertiesGroups[LS_RANS] = Context::getBasicProperty<MBool>("levelSetRans", AT_, &tmpFalse);
 
  MString couplerTypeDefault = "";
  MString couplerType = Context::getBasicProperty<MString>("couplerType_0", AT_, &couplerTypeDefault);
  propertiesGroups[LEVELSET_LB] = couplerType == "COUPLER_LS_LB";
 
  if(globalDomainId() == 0) {
    cerr << "FV-MB is " << ((propertiesGroups[LEVELSETMB]) ? "on" : "off") << endl;
    cerr << "FV-LS is " << ((propertiesGroups[LEVELSET]) ? "on" : "off") << endl;
    cerr << "LB is " << ((propertiesGroups[LB]) ? "on" : "off") << endl;
    cerr << "LB LS is " << ((propertiesGroups[LEVELSET_LB]) ? "on" : "off") << endl;
    cerr << "LS SOLVER is " << ((propertiesGroups[LS_SOLVER]) ? "on" : "off") << endl;
    cerr << "COMBUSTION is " << ((propertiesGroups[COMBUSTION]) ? "on" : "off") << endl;
    cerr << "DG is " << ((propertiesGroups[DG]) ? "on" : "off") << endl;
    cerr << "LS-RANS is " << ((propertiesGroups[LS_RANS]) ? "on" : "off") << endl;
  }
 
  return propertiesGroups;
}

run()

template<MInt nDim>

template void Application::run< 3 >

(

)

storeTimingsAndSolverInformation()

void Application::storeTimingsAndSolverInformation ( const MBool  finalTimeStep )

private

Definition at line 2421 of file application.cpp.

                                                                            {
  TRACE();
  using namespace maia::parallel_io;
 
  // Return if not enabled
  if(!m_writeSolverTimings) {
    return;
  }
 
  // Check if timings should be written at this step
  const MBool writeStep = (m_solverTimingsWriteInterval > 0)
                              ? (globalTimeStep % m_solverTimingsWriteInterval == 0 || finalTimeStep)
                              : finalTimeStep;
  if(!writeStep) {
    return;
  }
 
  const MInt noValues = m_solverTimings.size();
  if(noValues == 0) {
    return;
  }
  const MInt noTimings = m_solverTimings[0].size();
  if(noTimings == 0) {
    return;
  }
 
  // Timings output file name
  stringstream fileName;
  fileName << "solverTimings_n" << globalNoDomains() << "_" << globalTimeStep << ParallelIo::fileExt();
 
  // check for existing file
  if(globalDomainId() == 0) {
    ifstream readFile;
    readFile.open(fileName.str());
    if(readFile) {
      stringstream fileNameNew;
      fileNameNew << "solverTimings_n" << globalNoDomains() << "_" << globalTimeStep << "_bu" << ParallelIo::fileExt();
      std::rename(fileName.str().c_str(), fileNameNew.str().c_str());
    }
  }
 
  ParallelIo file(fileName.str(), PIO_REPLACE, MPI_COMM_WORLD);
  file.defineArray(PIO_INT, "timeStep", noTimings);
 
  const MInt noInfo = m_domainInfo.size();
 
  // TODO labels:TIMERS store domainInfo for each changed configuration when using DLB?
  // Domain information
  ParallelIo::size_type dimSizesInfo[] = {globalNoDomains(), noInfo};
  file.defineArray(PIO_INT, "domainInfo", 2, &dimSizesInfo[0]);
  file.setAttribute("domain index", "dim_0", "domainInfo");
  file.setAttribute("information index", "dim_1", "domainInfo");
 
  for(MInt i = 0; i < noInfo; i++) {
    std::stringstream var;
    var << "var_" << i;
    file.setAttribute(m_domainInfo[i].first, var.str(), "domainInfo");
  }
 
  // Dimensions of timings: noDomains x noTimings x noValues
  ParallelIo::size_type dimSizesTimings[] = {globalNoDomains(), noTimings, noValues};
 
  file.defineArray(PIO_FLOAT, "timings", 3, &dimSizesTimings[0]);
 
  file.setAttribute("domain index", "dim_0", "timings");
  file.setAttribute("time step index", "dim_1", "timings");
  file.setAttribute("timings index", "dim_2", "timings");
 
  for(MInt i = 0; i < noValues; i++) {
    std::stringstream var;
    var << "var_" << i;
    file.setAttribute(m_solverTimingsNames[i], var.str(), "timings");
  }
 
  // Assemble domain information
  MFloatScratchSpace info(noInfo, AT_, "data");
  for(MInt i = 0; i < noInfo; i++) {
    info[i] = m_domainInfo[i].second;
  }
 
  // Assemble timings
  MFloatScratchSpace data(noTimings, noValues, AT_, "data");
  for(MInt i = 0; i < noTimings; i++) {
    for(MInt j = 0; j < noValues; j++) {
      data(i, j) = m_solverTimings[j][i];
    }
  }
 
  // root writes timestep data
  if(globalDomainId() == 0) {
    file.setOffset(noTimings, 0);
  } else {
    file.setOffset(0, 0);
  }
  file.writeArray(&m_solverTimingsTimeStep[0], "timeStep");
 
  // Write domain information
  file.setOffset(1, globalDomainId(), 2);
  file.writeArray(&info[0], "domainInfo");
 
  // Write timings of all domains
  file.setOffset(1, globalDomainId(), 3);
  file.writeArray(&data[0], "timings");
 
 
  // Clear collected timings
  for(MInt timerId = 0; timerId < m_noGlobalSolverTimers; timerId++) {
    m_solverTimings[timerId].clear();
    m_solverTimingsTimeStep.clear();
  }
}

Member Data Documentation

m_couplers

std::vector<std::unique_ptr<Coupling> > Application::m_couplers

private

Definition at line 90 of file application.h.

m_displayMemoryStatistics

MBool Application::m_displayMemoryStatistics = false

private

Definition at line 98 of file application.h.

m_domainInfo

std::vector<std::pair<MString, MInt> > Application::m_domainInfo {}

private

Definition at line 119 of file application.h.

m_dualTimeStepping

MBool Application::m_dualTimeStepping

private

Definition at line 76 of file application.h.

m_initialAdaptation

MBool Application::m_initialAdaptation = true

private

Definition at line 86 of file application.h.

m_maxIterations

MInt Application::m_maxIterations

private

Definition at line 78 of file application.h.

m_maxNoSolverTimings

const MInt Application::m_maxNoSolverTimings = 100000

private

Definition at line 114 of file application.h.

m_noCouplers

MInt Application::m_noCouplers = 0

private

Definition at line 88 of file application.h.

m_noGlobalSolverTimers

MInt Application::m_noGlobalSolverTimers = -1

private

Definition at line 113 of file application.h.

m_noPostProcessing

MInt Application::m_noPostProcessing

private

Definition at line 92 of file application.h.

m_noSolvers

MInt Application::m_noSolvers = -1

private

Definition at line 82 of file application.h.

m_postDataSolverId

MInt Application::m_postDataSolverId = -1

private

Definition at line 96 of file application.h.

m_postProcessing

MBool Application::m_postProcessing

private

Definition at line 94 of file application.h.

m_ppAfterTS

MBool Application::m_ppAfterTS = false

private

Definition at line 100 of file application.h.

m_restartBackupInterval

MInt Application::m_restartBackupInterval

private

Definition at line 80 of file application.h.

m_solvers

std::vector<std::unique_ptr<Solver> > Application::m_solvers

private

Definition at line 84 of file application.h.

m_solverTimings

std::vector<std::vector<MFloat> > Application::m_solverTimings {}

private

Definition at line 115 of file application.h.

m_solverTimingsNames

std::vector<MString> Application::m_solverTimingsNames {}

private

Definition at line 118 of file application.h.

m_solverTimingsPrevTime

std::vector<MFloat> Application::m_solverTimingsPrevTime {}

private

Definition at line 116 of file application.h.

m_solverTimingsSampleInterval

MInt Application::m_solverTimingsSampleInterval = 1

private

Definition at line 112 of file application.h.

m_solverTimingsTimeStep

std::vector<MInt> Application::m_solverTimingsTimeStep {}

private

Definition at line 117 of file application.h.

m_solverTimingsWriteInterval

MInt Application::m_solverTimingsWriteInterval = -1

private

Definition at line 110 of file application.h.

m_writeAllSolverTimings

MBool Application::m_writeAllSolverTimings = true

private

Definition at line 108 of file application.h.

m_writeSolverTimings

MBool Application::m_writeSolverTimings = false

private

Definition at line 106 of file application.h.

---

The documentation for this class was generated from the following files:

• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/application.h
• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/application.cpp