Base recipe provides public interface to Application. More...

#include <executionrecipe.h>

Inheritance diagram for ExecutionRecipe:

Collaboration diagram for ExecutionRecipe:

Public Member Functions
	ExecutionRecipe (std::vector< std::unique_ptr< Solver > > const solvers, std::vector< std::unique_ptr< Coupling > > const couplers)

virtual void	preTimeStep () final
	: Calls each solvers preTimeStep - might be empty More...

virtual void	timeStep ()
	: Single solver time step function. Calls solutionStep() of the specific solver More...

virtual void	postTimeStep () final
	: Calls each solvers postTimeStep - might be empty More...

virtual void	preCouple () final
	: Calls each couplers preCouple - might be empty More...

virtual void	postCouple () final
	: Calls each couplers postCouple - might be empty More...

virtual MBool	updateCallOrder ()

MInt	a_step () const

MInt &	a_step ()

MBool	callAdaptation () const

Protected Member Functions
void	readCallOrder ()
	: Reads the call order of solvers, couplers and adaptation More...

void	initFunctionPointers ()
	: Initialize the vector containing function pointers to preTimeStep, solutionStep and postTimestep as well as preCouple, subCouple and postCouple. All are set active. More...

void	setSolverStatus (MInt, MBool)
	: Wrapper function to set solvers active or idle More...

void	setCouplerStatus (const MInt couplerId, const MBool active)
	: Wrapper function to set couplers active or empty More...

MInt	noSolvers () const

MInt	noCouplers () const

void	nextStep ()

MBool	solverOrder (const MInt solverId) const

MBool	couplerOrder (const MInt couplerId) const

void	setAdaptation ()

MInt	maxNoSteps () const

MBool	solutionStep (const MInt solverId)

void	preSolutionStep (const MInt solverId, const MInt mode)

MBool	postSolutionStep (const MInt solverId)

void	subCouple (const MInt couplerId, const MInt step, const MInt solverId, std::vector< MBool > &solverCompleted)

const std::vector< std::unique_ptr< Solver > > *	a_solvers () const

const std::vector< std::unique_ptr< Coupling > > *	a_couplers () const

MInt	swapedSolverId (const MInt oldSolverId)

void	startLoadTimer (const MInt solverId)

void	stopLoadTimer (const MInt solverId)

MBool	solverIsActive (const MInt solverId)

Protected Attributes
MInt	m_maxSolutionIteration = 1

std::map< MInt, MInt >	m_swapSolverIds {}

Private Attributes
const std::vector< std::unique_ptr< Solver > > *const	m_solvers

const std::vector< std::unique_ptr< Coupling > > *const	m_couplers

std::vector< std::function< void()> >	m_preStep

std::vector< std::function< void(const MInt)> >	m_preSolutionStep

std::vector< std::function< MBool()> >	m_solutionStep

std::vector< std::function< MBool()> >	m_postSolutionStep

std::vector< std::function< void()> >	m_postStep

std::vector< std::function< void(const MInt)> >	m_preCouple

std::vector< std::function< void(const MInt, const MInt, std::vector< MBool > &)> >	m_subCouple

std::vector< std::function< void(const MInt)> >	m_postCouple

MBool	m_allowAdaptation = true

MInt	m_step = -1

MInt	m_maxNoSteps = 1

std::vector< std::vector< MBool > >	m_solverOrder {}

std::vector< std::vector< MBool > >	m_couplerOrder {}

std::vector< MBool >	m_adaptationOrder {}

Detailed Description

Definition at line 21 of file executionrecipe.h.

Constructor & Destructor Documentation

◆ ExecutionRecipe()

ExecutionRecipe::ExecutionRecipe	(	std::vector< std::unique_ptr< Solver > > *const	solvers,
		std::vector< std::unique_ptr< Coupling > > *const	couplers
	)

inline

Definition at line 23 of file executionrecipe.h.

    : m_solvers(solvers), m_couplers(couplers) {
    // This function initializes function pointers to the preTimeStep, solutionStep
    // and postTimeStep functions of each solver
    initFunctionPointers();
  }

Member Function Documentation

◆ a_couplers()

const std::vector< std::unique_ptr< Coupling > > * ExecutionRecipe::a_couplers ( ) const

inlineprotected

Definition at line 79 of file executionrecipe.h.

79{ return m_couplers; }

◆ a_solvers()

const std::vector< std::unique_ptr< Solver > > * ExecutionRecipe::a_solvers ( ) const

inlineprotected

Definition at line 77 of file executionrecipe.h.

77{ return m_solvers; }

◆ a_step() [1/2]

MInt & ExecutionRecipe::a_step ( )

inline

Definition at line 43 of file executionrecipe.h.

43{ return m_step; }

ExecutionRecipe::m_step

MInt m_step

Definition: executionrecipe.h:128

◆ a_step() [2/2]

MInt ExecutionRecipe::a_step ( ) const

inline

Definition at line 42 of file executionrecipe.h.

42{ return m_step; }

◆ callAdaptation()

MBool ExecutionRecipe::callAdaptation ( ) const

inline

Definition at line 45 of file executionrecipe.h.

45{ return m_allowAdaptation; }

ExecutionRecipe::m_allowAdaptation

MBool m_allowAdaptation

Definition: executionrecipe.h:126

◆ couplerOrder()

MBool ExecutionRecipe::couplerOrder ( const MInt couplerId ) const

inlineprotected

Definition at line 61 of file executionrecipe.h.

61{ return m_couplerOrder[m_step][couplerId]; }

ExecutionRecipe::m_couplerOrder

std::vector< std::vector< MBool > > m_couplerOrder

Definition: executionrecipe.h:131

◆ initFunctionPointers()

void ExecutionRecipe::initFunctionPointers ( )

protected

Author: Thomas Hoesgen

Date: 01/2020

Definition at line 312 of file executionrecipe.h.

                                           {
  TRACE();
 
  for(MInt i = 0; i < noSolvers(); i++) {
    m_preStep.emplace_back([=]() { m_solvers->at(i)->preTimeStep(); });
    m_preSolutionStep.emplace_back([=](MInt b) { m_solvers->at(i)->preSolutionStep(b); });
    m_solutionStep.emplace_back([=]() { return m_solvers->at(i)->solutionStep(); });
    m_postSolutionStep.emplace_back([=]() { return m_solvers->at(i)->postSolutionStep(); });
    m_postStep.emplace_back([=]() { m_solvers->at(i)->postTimeStep(); });
  }
 
  for(MInt i = 0; i < noCouplers(); i++) {
    m_preCouple.emplace_back([=](MInt v) { m_couplers->at(i)->preCouple(v); });
    m_subCouple.emplace_back(
        [=](const MInt v, const MInt s, std::vector<MBool>& sc) { return m_couplers->at(i)->subCouple(v, s, sc); });
    m_postCouple.emplace_back([=](MInt v) { m_couplers->at(i)->postCouple(v); });
  }
}

◆ maxNoSteps()

MInt ExecutionRecipe::maxNoSteps ( ) const

inlineprotected

Definition at line 65 of file executionrecipe.h.

65{ return m_maxNoSteps; }

ExecutionRecipe::m_maxNoSteps

MInt m_maxNoSteps

Definition: executionrecipe.h:129

◆ nextStep()

void ExecutionRecipe::nextStep ( )

inlineprotected

Definition at line 57 of file executionrecipe.h.

57{ ++m_step; }

◆ noCouplers()

MInt ExecutionRecipe::noCouplers ( ) const

inlineprotected

Definition at line 55 of file executionrecipe.h.

55{ return m_couplers->size(); }

◆ noSolvers()

MInt ExecutionRecipe::noSolvers ( ) const

inlineprotected

Definition at line 54 of file executionrecipe.h.

54{ return m_solvers->size(); }

◆ postCouple()

void ExecutionRecipe::postCouple ( )

finalvirtual

Author: Thomas Hoesgen

Date: 01/2020

Definition at line 408 of file executionrecipe.h.

                                 {
  TRACE();
 
  for(auto&& coupler : *m_couplers) {
    coupler->startLoadTimer(AT_);
    m_postCouple[coupler->couplerId()](a_step());
    coupler->stopLoadTimer(AT_);
  }
}

◆ postSolutionStep()

MBool ExecutionRecipe::postSolutionStep ( const MInt solverId )

inlineprotected

Definition at line 71 of file executionrecipe.h.

71{ return m_postSolutionStep[solverId](); }

◆ postTimeStep()

void ExecutionRecipe::postTimeStep ( )

finalvirtual

Author: Thomas Hoesgen

Date: 01/2020

Definition at line 377 of file executionrecipe.h.

                                   {
  TRACE();
  for(auto&& solver : *m_solvers) {
    const MInt solverId = m_swapSolverIds.empty() ? solver->solverId() : swapedSolverId(solver->solverId());
    if(!solverIsActive(solverId)) {
      continue; // skip inactive solvers
    }
    startLoadTimer(solverId);
    m_postStep[solverId]();
    stopLoadTimer(solverId);
  }
}

◆ preCouple()

void ExecutionRecipe::preCouple ( )

inlinefinalvirtual

Author: Thomas Hoesgen

Date: 01/2020

Definition at line 394 of file executionrecipe.h.

                                       {
  TRACE();
 
  for(auto&& coupler : *m_couplers) {
    coupler->startLoadTimer(AT_);
    m_preCouple[coupler->couplerId()](a_step());
    coupler->stopLoadTimer(AT_);
  }
}

◆ preSolutionStep()

void ExecutionRecipe::preSolutionStep	(	const MInt	solverId,
		const MInt	mode
	)

inlineprotected

Definition at line 69 of file executionrecipe.h.

69{ return m_preSolutionStep[solverId](mode); }

◆ preTimeStep()

void ExecutionRecipe::preTimeStep ( )

inlinefinalvirtual

Author: Thomas Hoesgen

Date: 01/2020

Definition at line 335 of file executionrecipe.h.

                                         {
  TRACE();
  for(auto&& solver : *m_solvers) {
    if(!solver->isActive()) {
      continue; // skip inactive solvers
    }
 
    solver->startLoadTimer(AT_);
    m_preStep[solver->solverId()]();
    solver->stopLoadTimer(AT_);
  }
}

◆ readCallOrder()

void ExecutionRecipe::readCallOrder ( )

protected

For some multisolver applications the solvers can not be executed simultaneously. E.g. in level-set moving boundary problems the new level-set solution needs to be known before the fvMbSolver can perform its time step. Therefore, a callOrder is specified in the propertiesFile for the solvers, couplers and the adaptation. According to the callOrder solvers and couplers are set to active or empty and the adaptation can be turned on and off. The callOrder is updated in each step of the advance time step iteration inside the time step loop ( updateCallOrder() ). In the first step of level-set moving boundary problems the LS solver is set active and the fvMb solver is set to idle. In the subsequent step the LS solver is deactivated, while the fvMb solver is activated.

Author: Thomas Hoesgen

Date: 01/2020

Definition at line 153 of file executionrecipe.h.

                                    {
  TRACE();
 
  a_step() = 0;
 
  // TODO labels:COUPLER,DOC,toenhance allow a default call order to be defined by the couplers (when there is only one
  // coupler)
  // @ansgar this would make sense e.g. for the multilevel interpolation coupler!
 
  m_maxNoSteps = 1;
  m_maxNoSteps = Context::getBasicProperty<MInt>("recipeMaxNoSteps", AT_, &m_maxNoSteps);
 
 
  m_maxSolutionIteration = 1;
  m_maxSolutionIteration = Context::getBasicProperty<MInt>("maxIterations", AT_, &m_maxSolutionIteration);
 
  m_solverOrder.resize(m_maxNoSteps, std::vector<MBool>(noSolvers()));
  m_couplerOrder.resize(m_maxNoSteps, std::vector<MBool>(noCouplers()));
  m_adaptationOrder.resize(m_maxNoSteps);
 
  // Read solverOrder_x properties defining when the solvers should be executed, e.g. solverOrder_1 =
  // [1, 0] to execute the solver #1 in the first step but not in the second step
  for(MInt solver = 0; solver < noSolvers(); solver++) {
    const MString propName = "solverOrder_" + std::to_string(solver);
    Context::assertPropertyLength(propName, m_maxNoSteps);
 
    for(MInt step = 0; step < m_maxNoSteps; step++) {
      m_solverOrder[step][solver] = (MBool)Context::getBasicProperty<MInt>(propName, AT_, step);
    }
  }
 
  // Read couplerOrder_x properties defining when the coupler should be executed, e.g. [0, 1] to
  // execute the coupler only in the second step
  for(MInt coupler = 0; coupler < noCouplers(); coupler++) {
    const MString propName = "couplerOrder_" + std::to_string(coupler);
    Context::assertPropertyLength(propName, m_maxNoSteps);
 
    for(MInt step = 0; step < m_maxNoSteps; step++) {
      m_couplerOrder[step][coupler] = (MBool)Context::getBasicProperty<MInt>(propName, AT_, step);
    }
  }
 
  for(MInt step = 0; step < m_maxNoSteps; step++) {
    // Property adaptationOrder is an array of length m_maxNoSteps - e.g. [0,1]
    Context::assertPropertyLength("adaptationOrder", m_maxNoSteps);
    m_adaptationOrder[step] = (MBool)Context::getBasicProperty<MInt>("adaptationOrder", AT_, step);
  }
 
  // Set solver and coupler statuses for recipe step 0
  for(MInt blck = 0; blck < noSolvers(); blck++) {
    setSolverStatus(blck, m_solverOrder[a_step()][blck]);
  }
 
  for(MInt cpl = 0; cpl < noCouplers(); cpl++) {
    setCouplerStatus(cpl, m_couplerOrder[a_step()][cpl]);
  }
 
  m_allowAdaptation = m_adaptationOrder[a_step()];
 
  // Print execution recipe call order to m_log
  m_log << " === Execution recipe: call order with " << m_maxNoSteps << " steps" << std::endl;
  m_log << "step:      ";
  for(MInt step = 0; step < m_maxNoSteps; step++) {
    m_log << " " << step;
  }
  m_log << std::endl;
 
  for(MInt solver = 0; solver < noSolvers(); solver++) {
    m_log << "solver #" << solver << ":  ";
    for(MInt step = 0; step < m_maxNoSteps; step++) {
      m_log << " " << m_solverOrder[step][solver];
    }
    m_log << std::endl;
  }
  for(MInt cpl = 0; cpl < noCouplers(); cpl++) {
    m_log << "coupler #" << cpl << ":";
    for(MInt step = 0; step < m_maxNoSteps; step++) {
      m_log << " " << m_couplerOrder[step][cpl];
    }
    m_log << std::endl;
  }
 
  for(MInt blck = 0; blck < noSolvers(); blck++) {
    setSolverStatus(blck, solverOrder(blck));
  }
 
  for(MInt cpl = 0; cpl < noCouplers(); cpl++) {
    setCouplerStatus(cpl, couplerOrder(cpl));
  }
 
  setAdaptation();
 
  m_swapSolverIds.clear();
  if(Context::propertyExists("swapSolverSolutionStep")) {
    MInt size = Context::propertyLength("swapSolverSolutionStep") / 2;
    for(MInt i = 0; i < size; i++) {
      const MInt oldId = Context::getBasicProperty<MInt>("swapSolverSolutionStep", AT_, i);
      const MInt newId = Context::getBasicProperty<MInt>("swapSolverSolutionStep", AT_, i + 1);
      m_swapSolverIds.insert(std::make_pair(oldId, newId));
      m_swapSolverIds.insert(std::make_pair(newId, oldId));
    }
  }
}

◆ setAdaptation()

void ExecutionRecipe::setAdaptation ( )

inlineprotected

Definition at line 63 of file executionrecipe.h.

63{ m_allowAdaptation = m_adaptationOrder[m_step]; }

◆ setCouplerStatus()

void ExecutionRecipe::setCouplerStatus	(	const MInt	couplerId,
		const MBool	active
	)

protected

Author: Thomas Hoesgen

Date: 01/2020

Definition at line 289 of file executionrecipe.h.

                                                                               {
  TRACE();
 
  if(active) {
    m_preCouple[couplerId] = [=](MInt i) { m_couplers->at(couplerId)->preCouple(i); };
    m_subCouple[couplerId] = [=](const MInt i, const MInt s, std::vector<MBool>& sc) {
      return m_couplers->at(couplerId)->subCouple(i, s, sc);
    };
    m_postCouple[couplerId] = [=](MInt i) { m_couplers->at(couplerId)->postCouple(i); };
  } else {
    // set to empty lambda
    m_preCouple[couplerId] = [](const MInt) {};
    m_subCouple[couplerId] = [](const MInt, const MInt, std::vector<MBool>&) { return true; };
    m_postCouple[couplerId] = [](const MInt) {};
  }
}

◆ setSolverStatus()

void ExecutionRecipe::setSolverStatus	(	MInt	solverId,
		MBool	active
	)

protected

Author: Thomas Hoesgen

Date: 01/2020

Definition at line 261 of file executionrecipe.h.

                                                                 {
  TRACE();
 
  // Tell the solver its current status such that a coupler can ask the solver if its currently active
  // inside of the execution recipe
  m_solvers->at(solverId)->setSolverStatus(active);
 
 
  if(active) {
    m_preStep[solverId] = [=]() { m_solvers->at(solverId)->preTimeStep(); };
    m_preSolutionStep[solverId] = [=](MInt mode) { m_solvers->at(solverId)->preSolutionStep(mode); };
    m_solutionStep[solverId] = [=]() { return m_solvers->at(solverId)->solutionStep(); };
    m_postSolutionStep[solverId] = [=]() { return m_solvers->at(solverId)->postSolutionStep(); };
    m_postStep[solverId] = [=]() { m_solvers->at(solverId)->postTimeStep(); };
  } else {
    // set to empty lambda
    m_preStep[solverId] = []() {};
    m_preSolutionStep[solverId] = [](MInt) {};
    m_solutionStep[solverId] = []() { return true; };
    m_postSolutionStep[solverId] = []() { return true; };
    m_postStep[solverId] = []() {};
  }
}

◆ solutionStep()

MBool ExecutionRecipe::solutionStep ( const MInt solverId )

inlineprotected

Definition at line 67 of file executionrecipe.h.

67{ return m_solutionStep[solverId](); }

◆ solverIsActive()

MBool ExecutionRecipe::solverIsActive ( const MInt solverId )

inlineprotected

Definition at line 107 of file executionrecipe.h.

107{ return m_solvers->at(solverId)->isActive(); }

◆ solverOrder()

MBool ExecutionRecipe::solverOrder ( const MInt solverId ) const

inlineprotected

Definition at line 59 of file executionrecipe.h.

59{ return m_solverOrder[m_step][solverId]; }

◆ startLoadTimer()

void ExecutionRecipe::startLoadTimer ( const MInt solverId )

inlineprotected

Definition at line 103 of file executionrecipe.h.

103{ m_solvers->at(solverId)->startLoadTimer(AT_); }

◆ stopLoadTimer()

void ExecutionRecipe::stopLoadTimer ( const MInt solverId )

inlineprotected

Definition at line 105 of file executionrecipe.h.

105{ m_solvers->at(solverId)->stopLoadTimer(AT_); }

◆ subCouple()

void ExecutionRecipe::subCouple	(	const MInt	couplerId,
		const MInt	step,
		const MInt	solverId,
		std::vector< MBool > &	solverCompleted
	)

inlineprotected

Definition at line 73 of file executionrecipe.h.

                                                                                                                {
    m_subCouple[couplerId](step, solverId, solverCompleted);
  }

◆ swapedSolverId()

MInt ExecutionRecipe::swapedSolverId ( const MInt oldSolverId )

inlineprotected

Definition at line 85 of file executionrecipe.h.

                                              {
    // switch solver order during execution, this becomes necessary during intraStep-coupling,
    // when however one solver depends on a certain solver initialisation, thus prescrining the
    // solverId-oder, but during the time-step the order needs to be the other way around!
 
    ASSERT(!m_swapSolverIds.empty(), "");
 
    MInt solverId = oldSolverId;
    auto it = m_swapSolverIds.find(solverId);
    if(it != m_swapSolverIds.end()) {
      solverId = it->second;
    }
 
    ASSERT(solverOrder(oldSolverId) == solverOrder(solverId), "");
 
    return solverId;
  }

◆ timeStep()

void ExecutionRecipe::timeStep ( )

inlinevirtual

Author: Thomas Hoesgen

Date: 01/2020

Reimplemented in ExecutionRecipeIntraStepCoupling, and ExecutionRecipeSolutionIteration.

Definition at line 353 of file executionrecipe.h.

                                      {
  TRACE();
 
  // For a single solver run, there is obviously only one solver!
  for(auto&& solver : *m_solvers) {
    if(!solver->isActive()) {
      continue; // skip inactive solvers
    }
 
    // Outer loop over substep iterations
    MBool completed = false;
    while(!completed) {
      // Solution step
      solver->startLoadTimer(AT_);
      completed = m_solutionStep[solver->solverId()]();
      solver->stopLoadTimer(AT_);
    }
  }
}

◆ updateCallOrder()

virtual MBool ExecutionRecipe::updateCallOrder ( )

inlinevirtual

Reimplemented in ExecutionRecipeIntraStepCoupling, and ExecutionRecipeSolutionIteration.

Definition at line 40 of file executionrecipe.h.

40{ return true; };

Member Data Documentation

◆ m_adaptationOrder

std::vector<MBool> ExecutionRecipe::m_adaptationOrder {}

private

Definition at line 132 of file executionrecipe.h.

◆ m_allowAdaptation

MBool ExecutionRecipe::m_allowAdaptation = true

private

Definition at line 126 of file executionrecipe.h.

◆ m_couplerOrder

std::vector<std::vector<MBool> > ExecutionRecipe::m_couplerOrder {}

private

Definition at line 131 of file executionrecipe.h.

◆ m_couplers

const std::vector<std::unique_ptr<Coupling> >* const ExecutionRecipe::m_couplers

private

Definition at line 111 of file executionrecipe.h.

◆ m_maxNoSteps

MInt ExecutionRecipe::m_maxNoSteps = 1

private

Definition at line 129 of file executionrecipe.h.

◆ m_maxSolutionIteration

MInt ExecutionRecipe::m_maxSolutionIteration = 1

protected

Definition at line 81 of file executionrecipe.h.

◆ m_postCouple

std::vector<std::function<void(const MInt)> > ExecutionRecipe::m_postCouple

private

Definition at line 123 of file executionrecipe.h.

◆ m_postSolutionStep

std::vector<std::function<MBool()> > ExecutionRecipe::m_postSolutionStep

private

Definition at line 116 of file executionrecipe.h.

◆ m_postStep

std::vector<std::function<void()> > ExecutionRecipe::m_postStep

private

Definition at line 117 of file executionrecipe.h.

◆ m_preCouple

std::vector<std::function<void(const MInt)> > ExecutionRecipe::m_preCouple

private

Definition at line 119 of file executionrecipe.h.

◆ m_preSolutionStep

std::vector<std::function<void(const MInt)> > ExecutionRecipe::m_preSolutionStep

private

Definition at line 114 of file executionrecipe.h.

◆ m_preStep

std::vector<std::function<void()> > ExecutionRecipe::m_preStep

private

Definition at line 113 of file executionrecipe.h.

◆ m_solutionStep

std::vector<std::function<MBool()> > ExecutionRecipe::m_solutionStep

private

Definition at line 115 of file executionrecipe.h.

◆ m_solverOrder

std::vector<std::vector<MBool> > ExecutionRecipe::m_solverOrder {}

private

Definition at line 130 of file executionrecipe.h.

◆ m_solvers

const std::vector<std::unique_ptr<Solver> >* const ExecutionRecipe::m_solvers

private

Definition at line 110 of file executionrecipe.h.

◆ m_step

MInt ExecutionRecipe::m_step = -1

private

Definition at line 128 of file executionrecipe.h.

◆ m_subCouple

std::vector<std::function<void(const MInt, const MInt, std::vector<MBool>&)> > ExecutionRecipe::m_subCouple

private

Definition at line 121 of file executionrecipe.h.

◆ m_swapSolverIds

std::map<MInt, MInt> ExecutionRecipe::m_swapSolverIds {}

protected

Definition at line 83 of file executionrecipe.h.

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

/home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/executionrecipe.h

Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ExecutionRecipe()

Member Function Documentation

◆ a_couplers()

◆ a_solvers()

◆ a_step() [1/2]

◆ a_step() [2/2]

◆ callAdaptation()

◆ couplerOrder()

◆ initFunctionPointers()

◆ maxNoSteps()

◆ nextStep()

◆ noCouplers()

◆ noSolvers()

◆ postCouple()

◆ postSolutionStep()

◆ postTimeStep()

◆ preCouple()

◆ preSolutionStep()

◆ preTimeStep()

◆ readCallOrder()

◆ setAdaptation()

◆ setCouplerStatus()

◆ setSolverStatus()

◆ solutionStep()

◆ solverIsActive()

◆ solverOrder()

◆ startLoadTimer()

◆ stopLoadTimer()

◆ subCouple()

◆ swapedSolverId()

◆ timeStep()

◆ updateCallOrder()

Member Data Documentation

◆ m_adaptationOrder

◆ m_allowAdaptation

◆ m_couplerOrder

◆ m_couplers

◆ m_maxNoSteps

◆ m_maxSolutionIteration

◆ m_postCouple

◆ m_postSolutionStep

◆ m_postStep

◆ m_preCouple

◆ m_preSolutionStep

◆ m_preStep

◆ m_solutionStep

◆ m_solverOrder

◆ m_solvers

◆ m_step

◆ m_subCouple

◆ m_swapSolverIds