LbSolver is a generic solver for Lattice-Boltzmann problems. More...

#include <lbSolver.h>

Inheritance diagram for olb::LbSolver< T, PARAMETERS, LATTICES >:

Collaboration diagram for olb::LbSolver< T, PARAMETERS, LATTICES >:

Public Member Functions
	LbSolver (utilities::TypeIndexedSharedPtrTuple< PARAMETERS > params)

void	buildAndReturn ()
	Build geometry, lattice and call computeResults.

void	initialize () override
	Set up geometry.

Public Member Functions inherited from olb::BaseSolver< T, PARAMETERS >
	BaseSolver (utilities::TypeIndexedSharedPtrTuple< PARAMETERS > params)

virtual void	preProcess ()
	Configurations that take place before solving.

void	solve ()

virtual void	postProcess ()
	Actions that take place after solving.

template<typename KEY >
auto &	parameters (KEY=KEY())
	Access to parameter structs as parameters(KEY())

template<typename KEY >
auto &	parameters (KEY=KEY()) const

template<typename KEY >
auto &	parameters (meta::id< KEY >)

template<typename KEY >
auto &	parameters (meta::id< KEY >) const

Protected Types
template<typename... DESCRIPTORS>
using	SuperLattices = std::tuple<std::shared_ptr<SuperLattice<T,DESCRIPTORS>>...>

Protected Member Functions
void	prepareSimulation () override
	Set up lattice and initialize fields.

void	timeStep (std::size_t iT) override
	Collide-and-stream + additional computations.

void	postSimulation () override
	Evaluate results.

virtual void	prepareGeometry ()=0
	Define the geometry.

virtual void	prepareLattices ()=0
	Choose dynamics and boundary conditions.

virtual void	setInitialValues ()=0
	Define fields and initialize lattice populations.

virtual void	setBoundaryValues (std::size_t iT)=0
	Update fields and boundary values.

virtual void	getResults (std::size_t iT)
	Computation of results and output with full flexibility.

virtual void	computeResults (std::size_t iT)
	Perform further computations (compute errors etc.)

virtual void	computeResults ()

virtual bool	exitCondition (std::size_t iT) const override
	Condition, when to exit the time-stepping loop Returns true if the loop shall be continued.

virtual bool	checkStability (std::size_t iT)
	check stability: maxU should be <= _boundMaxU for a stable simulation Returns true if this fulfilled

virtual void	printLog (std::size_t iT) const

virtual void	writeLogConverter () const

virtual void	prepareVTK () const
	Write geometric information for vtk output The default version writes geometry, cuboid, rank and works for several lattices.

virtual void	writeVTK (std::size_t iT) const

virtual void	writeImages (std::size_t iT) const

virtual void	writeGnuplot (std::size_t iT) const

template<typename... ARGS>
auto &	converter (ARGS &&... args)

template<typename... ARGS>
auto &	converter (ARGS &&... args) const

template<typename KEY >
auto &	lattice (KEY=KEY())

template<typename KEY >
auto &	lattice (KEY=KEY()) const

template<typename KEY >
auto &	lattice (meta::id< KEY >)

template<typename KEY >
auto &	lattice (meta::id< KEY >) const

auto &	lattice ()

auto &	lattice () const

auto &	geometry ()

auto &	geometry () const

Static Protected Member Functions
static constexpr unsigned	getNumberStationaryLattices ()

Protected Attributes
std::shared_ptr< SuperGeometry< T, dim > >	_sGeometry

std::shared_ptr< CuboidGeometry< T, dim > >	_cGeometry

std::shared_ptr< LoadBalancer< T > >	_loadBalancer

LATTICES::values_t::template decompose_into< SuperLattices >	_sLattices

std::unique_ptr< util::Timer< BaseType< T > > >	_timer

std::array< std::unique_ptr< util::ValueTracer< T > >, getNumberStationaryLattices()>	_convergenceCheck

bool	_exitMaxU {false}

BaseType< T >	_boundMaxU {1.0}

std::size_t	_itCheckStability {1}

std::size_t	_itBoundaryUpdate {1}

Protected Attributes inherited from olb::BaseSolver< T, PARAMETERS >
bool	_isInitialized {false}

std::size_t	_iT {0}

bool	_finishedTimeLoop {false}

Static Protected Attributes
static constexpr unsigned	dim = LATTICES::values_t::template get<0>::d

static constexpr bool	isStationary = PARAMETERS::keys_t::template contains<names::Stationarity>()

static constexpr bool	outputGnuplot = PARAMETERS::keys_t::template contains<names::VisualizationGnuplot>()

static constexpr bool	outputImages = PARAMETERS::keys_t::template contains<names::VisualizationImages>()

static constexpr bool	outputVTK = PARAMETERS::keys_t::template contains<names::VisualizationVTK>()

Additional Inherited Members
Public Types inherited from olb::BaseSolver< T, PARAMETERS >
using	t = T

using	Parameters_t = PARAMETERS

Public Attributes inherited from olb::BaseSolver< T, PARAMETERS >
utilities::TypeIndexedSharedPtrTuple< PARAMETERS >	_parameters

Detailed Description

template<typename T, typename PARAMETERS, typename LATTICES>
class olb::LbSolver< T, PARAMETERS, LATTICES >

LbSolver is a generic solver for Lattice-Boltzmann problems.

It holds geometry and lattices and defines the abstract methods of BaseSolver. Every simulation app should be able to inherit from this class.

Definition at line 130 of file lbSolver.h.

Member Typedef Documentation

◆ SuperLattices

template<typename T , typename PARAMETERS , typename LATTICES >

template<typename... DESCRIPTORS>

using olb::LbSolver< T, PARAMETERS, LATTICES >::SuperLattices = std::tuple<std::shared_ptr<SuperLattice<T,DESCRIPTORS>>...>

protected

Definition at line 139 of file lbSolver.h.

Constructor & Destructor Documentation

◆ LbSolver()

template<typename T , typename PARAMETERS , typename LATTICES >

olb::LbSolver< T, PARAMETERS, LATTICES >::LbSolver ( utilities::TypeIndexedSharedPtrTuple< PARAMETERS > params )

inline

Definition at line 171 of file lbSolver.h.

171 : LbSolver::BaseSolver(params)

172 { }

olb::BaseSolver::BaseSolver

BaseSolver(utilities::TypeIndexedSharedPtrTuple< PARAMETERS > params)

Definition lbSolver.h:56

Member Function Documentation

◆ buildAndReturn()

template<typename T , typename PARAMETERS , typename LATTICES >

void olb::LbSolver< T, PARAMETERS, LATTICES >::buildAndReturn ( )

Build geometry, lattice and call computeResults.

Definition at line 60 of file lbSolver.hh.

{
  if (! this->_isInitialized) {
    this->initialize();
  }
  build();
  computeResults();
}

◆ checkStability()

template<typename T , typename PARAMETERS , typename LATTICES >

bool olb::LbSolver< T, PARAMETERS, LATTICES >::checkStability ( std::size_t iT )

protectedvirtual

check stability: maxU should be <= _boundMaxU for a stable simulation Returns true if this fulfilled

Definition at line 278 of file lbSolver.hh.

{
  bool result = true;
  meta::tuple_for_each(_sLattices, [&](auto& lattice){
    if (lattice->getStatistics().getMaxU() > _boundMaxU) {
      clout << "PROBLEM uMax=" << lattice->getStatistics().getMaxU() << std::endl;
      lattice->getStatistics().print(iT, converter().getPhysTime(iT));
      if (_exitMaxU) {
        exit(1);
      }
      result = false;
    }
  });
  return result;
}

References olb::meta::tuple_for_each().

Here is the call graph for this function:

◆ computeResults() [1/2]

template<typename T , typename PARAMETERS , typename LATTICES >

virtual void olb::LbSolver< T, PARAMETERS, LATTICES >::computeResults ( )

inlineprotectedvirtual

Definition at line 217 of file lbSolver.h.

217{ };

◆ computeResults() [2/2]

template<typename T , typename PARAMETERS , typename LATTICES >

virtual void olb::LbSolver< T, PARAMETERS, LATTICES >::computeResults ( std::size_t iT )

inlineprotectedvirtual

Perform further computations (compute errors etc.)

Definition at line 215 of file lbSolver.h.

215{ };

◆ converter() [1/2]

template<typename T , typename PARAMETERS , typename LATTICES >

template<typename... ARGS>

auto & olb::LbSolver< T, PARAMETERS, LATTICES >::converter ( ARGS &&... args )

inlineprotected

Definition at line 255 of file lbSolver.h.

                                  {
    using SimulationParameters_t = typename PARAMETERS::template value<names::Simulation>;
    if constexpr(std::is_invocable_v<decltype(&SimulationParameters_t::converter),ARGS...>) {
      return this->parameters(names::Simulation()).converter(args...);
    }
    else {
      return *this->parameters(names::Simulation()).converter;
    }
    __builtin_unreachable();
  }

References olb::BaseSolver< T, PARAMETERS >::parameters().

Here is the call graph for this function:

◆ converter() [2/2]

template<typename T , typename PARAMETERS , typename LATTICES >

template<typename... ARGS>

auto & olb::LbSolver< T, PARAMETERS, LATTICES >::converter ( ARGS &&... args ) const

inlineprotected

Definition at line 266 of file lbSolver.h.

                                        {
    using SimulationParameters_t = typename PARAMETERS::template value<names::Simulation>;
    if constexpr(std::is_invocable_v<decltype(&SimulationParameters_t::converter),ARGS...>) {
      return this->parameters(names::Simulation()).converter(args...);
    }
    else {
      return *this->parameters(names::Simulation()).converter;
    }
    __builtin_unreachable();
  }

References olb::BaseSolver< T, PARAMETERS >::parameters().

Here is the call graph for this function:

◆ exitCondition()

template<typename T , typename PARAMETERS , typename LATTICES >

bool olb::LbSolver< T, PARAMETERS, LATTICES >::exitCondition ( std::size_t iT ) const

overrideprotectedvirtual

Condition, when to exit the time-stepping loop Returns true if the loop shall be continued.

Implements olb::BaseSolver< T, PARAMETERS >.

Definition at line 257 of file lbSolver.hh.

{
  if (iT > this->converter().getLatticeTime(this->parameters(names::Simulation()).maxTime)){
    return true;
  }
 
  if constexpr (isStationary){
    if (std::all_of(_convergenceCheck.cbegin(), _convergenceCheck.cend(), [](auto& c){
      return c->hasConverged();
      } )) {
      if (this->parameters(names::Output()).verbose) {
        clout << "Simulation converged." << std::endl;
      }
      return true;
    }
  }
 
  return false;
}

◆ geometry() [1/2]

template<typename T , typename PARAMETERS , typename LATTICES >

auto & olb::LbSolver< T, PARAMETERS, LATTICES >::geometry ( )

inlineprotected

Definition at line 300 of file lbSolver.h.

                   {
    return *_sGeometry;
  }

References olb::LbSolver< T, PARAMETERS, LATTICES >::_sGeometry.

Here is the caller graph for this function:

◆ geometry() [2/2]

template<typename T , typename PARAMETERS , typename LATTICES >

auto & olb::LbSolver< T, PARAMETERS, LATTICES >::geometry ( ) const

inlineprotected

Definition at line 303 of file lbSolver.h.

                         {
    return *_sGeometry;
  }

References olb::LbSolver< T, PARAMETERS, LATTICES >::_sGeometry.

◆ getNumberStationaryLattices()

template<typename T , typename PARAMETERS , typename LATTICES >

static constexpr unsigned olb::LbSolver< T, PARAMETERS, LATTICES >::getNumberStationaryLattices ( )

inlinestaticconstexprprotected

Definition at line 150 of file lbSolver.h.

                                                          {
    if constexpr (isStationary) {
      return PARAMETERS::template value<names::Stationarity>::numberOfStationaryLattices;
    } else {
      return 0;
    }
    __builtin_unreachable();
  }

References olb::LbSolver< T, PARAMETERS, LATTICES >::isStationary.

◆ getResults()

template<typename T , typename PARAMETERS , typename LATTICES >

virtual void olb::LbSolver< T, PARAMETERS, LATTICES >::getResults ( std::size_t iT )

inlineprotectedvirtual

Computation of results and output with full flexibility.

Definition at line 210 of file lbSolver.h.

210{ };

◆ initialize()

template<typename T , typename PARAMETERS , typename LATTICES >

void olb::LbSolver< T, PARAMETERS, LATTICES >::initialize ( )

overridevirtual

Set up geometry.

Implements olb::BaseSolver< T, PARAMETERS >.

Definition at line 36 of file lbSolver.hh.

{
  if (this->parameters(names::Output()).verbose) {
    clout << "Start initialization" << std::endl;
  }
 
  this->prepareGeometry();
  // Removes all not needed boundary voxels outside the surface
  //this->geometry().clean(this->parameters(names::Output()).verbose);
  // Removes all not needed boundary voxels inside the surface
  this->geometry().innerClean(this->parameters(names::Output()).verbose);
  geometry().checkForErrors(this->parameters(names::Output()).verbose);
  if (this->parameters(names::Output()).verbose) {
    geometry().getStatistics().print();
  }
 
  this->_isInitialized = true;
 
  if (this->parameters(names::Output()).verbose) {
    clout << "Finished initialization" << std::endl;
  }
}

◆ lattice() [1/6]

template<typename T , typename PARAMETERS , typename LATTICES >

auto & olb::LbSolver< T, PARAMETERS, LATTICES >::lattice ( )

inlineprotected

Definition at line 292 of file lbSolver.h.

                  {
    static_assert((LATTICES::size == 1), "Lattice name must be provided");
    return *std::get<0>(_sLattices);
  }

References olb::LbSolver< T, PARAMETERS, LATTICES >::_sLattices.

Here is the caller graph for this function:

◆ lattice() [2/6]

template<typename T , typename PARAMETERS , typename LATTICES >

auto & olb::LbSolver< T, PARAMETERS, LATTICES >::lattice ( ) const

inlineprotected

Definition at line 296 of file lbSolver.h.

                        {
    static_assert((LATTICES::size == 1), "Lattice name must be provided");
    return *std::get<0>(_sLattices);
  }

References olb::LbSolver< T, PARAMETERS, LATTICES >::_sLattices.

◆ lattice() [3/6]

template<typename T , typename PARAMETERS , typename LATTICES >

template<typename KEY >

auto & olb::LbSolver< T, PARAMETERS, LATTICES >::lattice ( KEY = KEY() )

inlineprotected

Definition at line 277 of file lbSolver.h.

                             {
    return *std::get<(LATTICES::keys_t::template index<KEY>())>(_sLattices);
  }

References olb::LbSolver< T, PARAMETERS, LATTICES >::_sLattices.

◆ lattice() [4/6]

template<typename T , typename PARAMETERS , typename LATTICES >

template<typename KEY >

auto & olb::LbSolver< T, PARAMETERS, LATTICES >::lattice ( KEY = KEY() ) const

inlineprotected

Definition at line 281 of file lbSolver.h.

                                   {
    return *std::get<(LATTICES::keys_t::template index<KEY>())>(_sLattices);
  }

References olb::LbSolver< T, PARAMETERS, LATTICES >::_sLattices.

◆ lattice() [5/6]

template<typename T , typename PARAMETERS , typename LATTICES >

template<typename KEY >

auto & olb::LbSolver< T, PARAMETERS, LATTICES >::lattice ( meta::id< KEY > )

inlineprotected

Definition at line 285 of file lbSolver.h.

                             {
    return *std::get<(LATTICES::keys_t::template index<KEY>())>(_sLattices);
  }

References olb::LbSolver< T, PARAMETERS, LATTICES >::_sLattices.

◆ lattice() [6/6]

template<typename T , typename PARAMETERS , typename LATTICES >

template<typename KEY >

auto & olb::LbSolver< T, PARAMETERS, LATTICES >::lattice ( meta::id< KEY > ) const

inlineprotected

Definition at line 289 of file lbSolver.h.

                                   {
    return *std::get<(LATTICES::keys_t::template index<KEY>())>(_sLattices);
  }

References olb::LbSolver< T, PARAMETERS, LATTICES >::_sLattices.

◆ postSimulation()

template<typename T , typename PARAMETERS , typename LATTICES >

void olb::LbSolver< T, PARAMETERS, LATTICES >::postSimulation ( )

overrideprotectedvirtual

Evaluate results.

Implements olb::BaseSolver< T, PARAMETERS >.

Definition at line 208 of file lbSolver.hh.

{
  meta::tuple_for_each(_sLattices, [](auto& lattice) {
    // TODO: dispose also communication of fields...
    lattice->communicate();
  });
 
  if ( this->parameters(names::Output()).verbose ) {
    printLog(this->_iT);
  }
  if constexpr (outputVTK) {
    if ( this->parameters(names::VisualizationVTK()).printOutput == olb::parameters::OutputPlot<T>::pO_final) {
      writeVTK(this->_iT);
    }
  }
  if constexpr (outputImages) {
    if ( this->parameters(names::VisualizationImages()).printOutput == olb::parameters::OutputPlot<T>::pO_final) {
      writeImages(this->_iT);
    }
  }
  if constexpr (outputGnuplot) {
    if ( this->parameters(names::VisualizationGnuplot()).printOutput == olb::parameters::OutputPlot<T>::pO_final) {
      writeGnuplot(this->_iT);
    }
  }
  getResults(this->_iT);
 
  _timer->stop();
  if (this->parameters(names::Output()).verbose) {
    clout << "Finished collide-and-stream loop" << std::endl;
    clout << "Start postprocessing" << std::endl;
  }
  computeResults();
 
  if (this->parameters(names::Output()).verbose) {
    _timer->printSummary();
  }
 
  // required to finish output tasks during use of gpu
  meta::tuple_for_each(_sLattices, [](auto& lattice) {
    lattice->setProcessingContext(ProcessingContext::Evaluation);
  });
 
  if (this->parameters(names::Output()).verbose) {
    clout << "Finished postprocessing" << std::endl;
  }
}

References olb::Evaluation, and olb::meta::tuple_for_each().

Here is the call graph for this function:

◆ prepareGeometry()

template<typename T , typename PARAMETERS , typename LATTICES >

virtual void olb::LbSolver< T, PARAMETERS, LATTICES >::prepareGeometry ( )

protectedpure virtual

Define the geometry.

◆ prepareLattices()

template<typename T , typename PARAMETERS , typename LATTICES >

virtual void olb::LbSolver< T, PARAMETERS, LATTICES >::prepareLattices ( )

protectedpure virtual

Choose dynamics and boundary conditions.

◆ prepareSimulation()

template<typename T , typename PARAMETERS , typename LATTICES >

void olb::LbSolver< T, PARAMETERS, LATTICES >::prepareSimulation ( )

overrideprotectedvirtual

Set up lattice and initialize fields.

Implements olb::BaseSolver< T, PARAMETERS >.

Definition at line 100 of file lbSolver.hh.

{
  if (this->parameters(names::Output()).verbose) {
    clout << "Start prepareSimulation" << std::endl;
  }
 
  this->_iT = 0;
 
  build();
 
  setInitialValues();
 
  meta::tuple_for_each(_sLattices, [](auto& lattice){
    lattice->initialize();
    lattice->getStatistics().reset();
    lattice->getStatistics().initialize();
  });
 
 
  if constexpr (outputVTK) {
    if (this->parameters(names::VisualizationVTK()).output != "off") {
      prepareVTK();
    }
  }
 
  if (this->parameters(names::Output()).verbose) {
    clout << "Finished prepareSimulation" << std::endl;
    clout << "Start collide-and-stream loop" << std::endl;
  }
  _timer->start();
}

References olb::meta::tuple_for_each().

Here is the call graph for this function:

◆ prepareVTK()

template<typename T , typename PARAMETERS , typename LATTICES >

void olb::LbSolver< T, PARAMETERS, LATTICES >::prepareVTK ( ) const

protectedvirtual

Write geometric information for vtk output The default version writes geometry, cuboid, rank and works for several lattices.

This method may be overridden in case e.g. discrete normals shall be visualized (cf. example cavity2d).

Writes the geometry, cuboid no. and rank no. as vti file for visualization

Definition at line 324 of file lbSolver.hh.

{
  // write the geometric information. Since this does not depend on the
  // lattice, we may w.l.o.g. work with the first lattice
  auto& lattice = *std::get<0>(_sLattices);
  using DESCRIPTOR = typename LATTICES::values_t::template get<0>;
 
 
  SuperVTMwriter<T,dim> vtmWriter(this->parameters(names::VisualizationVTK()).filename);
 
 
  SuperLatticeGeometry<T,DESCRIPTOR> geometry(lattice, this->geometry());
  SuperLatticeCuboid<T,DESCRIPTOR> cuboid(lattice);
  SuperLatticeRank<T,DESCRIPTOR> rank(lattice);
  vtmWriter.write( cuboid );
  vtmWriter.write( geometry );
  vtmWriter.write( rank );
  vtmWriter.createMasterFile();
}

◆ printLog()

template<typename T , typename PARAMETERS , typename LATTICES >

void olb::LbSolver< T, PARAMETERS, LATTICES >::printLog ( std::size_t iT ) const

protectedvirtual

Definition at line 306 of file lbSolver.hh.

{
  using OutputParameters_t = typename PARAMETERS::template value<names::Output>;
  OutputParameters_t::printLatticeStatistics::for_each( [&](auto type){
    lattice(type.get()).getStatistics().print(iT, converter().getPhysTime(iT));
  } );
 
  _timer->print(iT, this->parameters(names::Output()).timerPrintMode);
}

◆ setBoundaryValues()

template<typename T , typename PARAMETERS , typename LATTICES >

virtual void olb::LbSolver< T, PARAMETERS, LATTICES >::setBoundaryValues ( std::size_t iT )

protectedpure virtual

Update fields and boundary values.

◆ setInitialValues()

template<typename T , typename PARAMETERS , typename LATTICES >

virtual void olb::LbSolver< T, PARAMETERS, LATTICES >::setInitialValues ( )

protectedpure virtual

Define fields and initialize lattice populations.

◆ timeStep()

template<typename T , typename PARAMETERS , typename LATTICES >

void olb::LbSolver< T, PARAMETERS, LATTICES >::timeStep ( std::size_t iT )

overrideprotectedvirtual

Collide-and-stream + additional computations.

Implements olb::BaseSolver< T, PARAMETERS >.

Definition at line 134 of file lbSolver.hh.

{
  if (iT % _itBoundaryUpdate == 0) {
    setBoundaryValues(iT);
  }
 
  meta::tuple_for_each(_sLattices, [](auto& lattice) {
    // TODO: dispose also communication of fields
    lattice->communicate();
  });
 
 
  if constexpr (outputVTK) {
    if ( this->parameters(names::VisualizationVTK()).printOutput == olb::parameters::OutputPlot<T>::pO_intervals
      && iT % converter().getLatticeTime(this->parameters(names::VisualizationVTK()).saveTime) == 0 ) {
      writeVTK(iT);
    }
  }
  if constexpr (outputImages) {
    if ( this->parameters(names::VisualizationImages()).printOutput == olb::parameters::OutputPlot<T>::pO_intervals
      && iT % converter().getLatticeTime(this->parameters(names::VisualizationImages()).saveTime) == 0 ) {
      writeImages(iT);
    }
  }
  if constexpr (outputGnuplot) {
    if ( this->parameters(names::VisualizationGnuplot()).printOutput == olb::parameters::OutputPlot<T>::pO_intervals
      && iT % converter().getLatticeTime(this->parameters(names::VisualizationGnuplot()).saveTime) == 0 ) {
      writeGnuplot(iT);
    }
  }
  if ( this->parameters(names::Output()).verbose
    && iT % converter().getLatticeTime(this->parameters(names::Output()).logT) == 0) {
    printLog(iT);
  }
  computeResults(iT);
  getResults(iT);
 
  meta::tuple_for_each(_sLattices, [](auto& lattice){
    lattice->collideAndStream();
    lattice->executeCoupling();
  });
 
  if (this->parameters(names::Simulation()).pressureFilter) {
    // TODO: allow choosing the lattices here
    std::get<0>(_sLattices)->stripeOffDensityOffset(std::get<0>(_sLattices)->getStatistics().getAverageRho() - T(1));
  }
 
  if constexpr (isStationary){
    unsigned counter = 0;
    using parameters_t = typename PARAMETERS::template value<names::Stationarity>;
    parameters_t::stat_lattices::for_each( [&](auto Id) {
      // using Name = typename decltype(Id)::type;
      if (this->parameters(names::Stationarity()).convergenceType[counter] == parameters_t::MaxLatticeVelocity){
        _convergenceCheck[counter]->takeValue( this->lattice(Id).getStatistics().getMaxU());
      }
      else if (this->parameters(names::Stationarity()).convergenceType[counter] == parameters_t::AverageEnergy){
        _convergenceCheck[counter]->takeValue( this->lattice(Id).getStatistics().getAverageEnergy() );
      }
      else if (this->parameters(names::Stationarity()).convergenceType[counter] == parameters_t::AverageRho){
        _convergenceCheck[counter]->takeValue( this->lattice(Id).getStatistics().getAverageRho());
      }
      else {
        throw std::invalid_argument("Convergence type is not supported.\n");
      }
      counter++;
    });
  }
 
  if (iT % _itCheckStability == 0) {
    checkStability(iT);
  }
}

References olb::meta::tuple_for_each().

Here is the call graph for this function:

◆ writeGnuplot()

template<typename T , typename PARAMETERS , typename LATTICES >

virtual void olb::LbSolver< T, PARAMETERS, LATTICES >::writeGnuplot ( std::size_t iT ) const

inlineprotectedvirtual

Definition at line 251 of file lbSolver.h.

251{ };

◆ writeImages()

template<typename T , typename PARAMETERS , typename LATTICES >

virtual void olb::LbSolver< T, PARAMETERS, LATTICES >::writeImages ( std::size_t iT ) const

inlineprotectedvirtual

Definition at line 248 of file lbSolver.h.

248{ };

◆ writeLogConverter()

template<typename T , typename PARAMETERS , typename LATTICES >

void olb::LbSolver< T, PARAMETERS, LATTICES >::writeLogConverter ( ) const

protectedvirtual

Definition at line 317 of file lbSolver.hh.

{
  converter().print();
  converter().write(this->parameters(names::Output()).name);
}

◆ writeVTK()

template<typename T , typename PARAMETERS , typename LATTICES >

virtual void olb::LbSolver< T, PARAMETERS, LATTICES >::writeVTK ( std::size_t iT ) const

inlineprotectedvirtual

Definition at line 245 of file lbSolver.h.

245{ };

Member Data Documentation

◆ _boundMaxU

template<typename T , typename PARAMETERS , typename LATTICES >

BaseType<T> olb::LbSolver< T, PARAMETERS, LATTICES >::_boundMaxU {1.0}

protected

Definition at line 166 of file lbSolver.h.

166{1.0};

◆ _cGeometry

template<typename T , typename PARAMETERS , typename LATTICES >

std::shared_ptr<CuboidGeometry<T,dim> > olb::LbSolver< T, PARAMETERS, LATTICES >::_cGeometry

protected

Definition at line 142 of file lbSolver.h.

◆ _convergenceCheck

template<typename T , typename PARAMETERS , typename LATTICES >

std::array<std::unique_ptr<util::ValueTracer<T> >, getNumberStationaryLattices()> olb::LbSolver< T, PARAMETERS, LATTICES >::_convergenceCheck

protected

Definition at line 159 of file lbSolver.h.

◆ _exitMaxU

template<typename T , typename PARAMETERS , typename LATTICES >

bool olb::LbSolver< T, PARAMETERS, LATTICES >::_exitMaxU {false}

protected

Definition at line 165 of file lbSolver.h.

165{false};

◆ _itBoundaryUpdate

template<typename T , typename PARAMETERS , typename LATTICES >

std::size_t olb::LbSolver< T, PARAMETERS, LATTICES >::_itBoundaryUpdate {1}

protected

Definition at line 168 of file lbSolver.h.

168{1};

◆ _itCheckStability

template<typename T , typename PARAMETERS , typename LATTICES >

std::size_t olb::LbSolver< T, PARAMETERS, LATTICES >::_itCheckStability {1}

protected

Definition at line 167 of file lbSolver.h.

167{1};

◆ _loadBalancer

template<typename T , typename PARAMETERS , typename LATTICES >

std::shared_ptr<LoadBalancer<T> > olb::LbSolver< T, PARAMETERS, LATTICES >::_loadBalancer

protected

Definition at line 143 of file lbSolver.h.

◆ _sGeometry

template<typename T , typename PARAMETERS , typename LATTICES >

std::shared_ptr<SuperGeometry<T,dim> > olb::LbSolver< T, PARAMETERS, LATTICES >::_sGeometry

protected

Definition at line 141 of file lbSolver.h.

◆ _sLattices

template<typename T , typename PARAMETERS , typename LATTICES >

LATTICES::values_t::template decompose_into<SuperLattices> olb::LbSolver< T, PARAMETERS, LATTICES >::_sLattices

protected

Definition at line 145 of file lbSolver.h.

◆ _timer

template<typename T , typename PARAMETERS , typename LATTICES >

std::unique_ptr<util::Timer<BaseType<T> > > olb::LbSolver< T, PARAMETERS, LATTICES >::_timer

protected

Definition at line 147 of file lbSolver.h.

◆ dim

template<typename T , typename PARAMETERS , typename LATTICES >

constexpr unsigned olb::LbSolver< T, PARAMETERS, LATTICES >::dim = LATTICES::values_t::template get<0>::d

staticconstexprprotected

Definition at line 136 of file lbSolver.h.

◆ isStationary

template<typename T , typename PARAMETERS , typename LATTICES >

constexpr bool olb::LbSolver< T, PARAMETERS, LATTICES >::isStationary = PARAMETERS::keys_t::template contains<names::Stationarity>()

staticconstexprprotected

Definition at line 149 of file lbSolver.h.

◆ outputGnuplot

template<typename T , typename PARAMETERS , typename LATTICES >

constexpr bool olb::LbSolver< T, PARAMETERS, LATTICES >::outputGnuplot = PARAMETERS::keys_t::template contains<names::VisualizationGnuplot>()

staticconstexprprotected

Definition at line 161 of file lbSolver.h.

◆ outputImages

template<typename T , typename PARAMETERS , typename LATTICES >

constexpr bool olb::LbSolver< T, PARAMETERS, LATTICES >::outputImages = PARAMETERS::keys_t::template contains<names::VisualizationImages>()

staticconstexprprotected

Definition at line 162 of file lbSolver.h.

◆ outputVTK

template<typename T , typename PARAMETERS , typename LATTICES >

constexpr bool olb::LbSolver< T, PARAMETERS, LATTICES >::outputVTK = PARAMETERS::keys_t::template contains<names::VisualizationVTK>()

staticconstexprprotected

Definition at line 163 of file lbSolver.h.

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

src/solver/lbSolver.h
src/solver/lbSolver.hh

Public Member Functions

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ SuperLattices

Constructor & Destructor Documentation

◆ LbSolver()

Member Function Documentation

◆ buildAndReturn()

◆ checkStability()

◆ computeResults() [1/2]

◆ computeResults() [2/2]

◆ converter() [1/2]

◆ converter() [2/2]

◆ exitCondition()

◆ geometry() [1/2]

◆ geometry() [2/2]

◆ getNumberStationaryLattices()

◆ getResults()

◆ initialize()

◆ lattice() [1/6]

◆ lattice() [2/6]

◆ lattice() [3/6]

◆ lattice() [4/6]

◆ lattice() [5/6]

◆ lattice() [6/6]

◆ postSimulation()

◆ prepareGeometry()

◆ prepareLattices()

◆ prepareSimulation()

◆ prepareVTK()

◆ printLog()

◆ setBoundaryValues()

◆ setInitialValues()

◆ timeStep()

◆ writeGnuplot()

◆ writeImages()

◆ writeLogConverter()

◆ writeVTK()

Member Data Documentation

◆ _boundMaxU

◆ _cGeometry

◆ _convergenceCheck

◆ _exitMaxU

◆ _itBoundaryUpdate

◆ _itCheckStability

◆ _loadBalancer

◆ _sGeometry

◆ _sLattices

◆ _timer

◆ dim

◆ isStationary

◆ outputGnuplot

◆ outputImages

◆ outputVTK