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 ()

	LbSolver (utilities::TypeIndexedSharedPtrTuple< PARAMETERS > params)

void	initialize () override
	Set up geometry.

void	buildAndReturn ()
	Build geometry, lattice.

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

Public Member Functions inherited from olb::BaseSolver< T, PARAMETERS >
	BaseSolver ()=default

	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

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

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

Protected Member Functions inherited from olb::BaseSolver< T, PARAMETERS >

Static Protected Member Functions
static constexpr unsigned	getNumberStationaryLattices ()

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

std::shared_ptr< CuboidDecomposition< 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

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 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 132 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 142 of file lbSolver.h.

Constructor & Destructor Documentation

◆ LbSolver() [1/2]

template<typename T , typename PARAMETERS , typename LATTICES >

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

inline

Definition at line 172 of file lbSolver.h.

172 : LbSolver::BaseSolver()

173 { }

olb::BaseSolver::BaseSolver

BaseSolver()=default

◆ LbSolver() [2/2]

template<typename T , typename PARAMETERS , typename LATTICES >

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

inline

Definition at line 175 of file lbSolver.h.

175 : LbSolver::BaseSolver(params)

176 { }

Member Function Documentation

◆ buildAndReturn()

template<typename T , typename PARAMETERS , typename LATTICES >

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

Build geometry, lattice.

Definition at line 60 of file lbSolver.hh.

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

References olb::initialize().

Here is the call graph for this function:

◆ 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 277 of file lbSolver.hh.

{
  bool result = true;
  meta::tuple_for_each(_sLattices, [&](auto& lattice){
    if (lattice->getStatistics().getMaxU() > this->parameters(names::Simulation()).boundMaxU) {
      clout << "PROBLEM uMax=" << lattice->getStatistics().getMaxU() << std::endl;
      lattice->getStatistics().print(iT, converter().getPhysTime(iT));
      if (this->parameters(names::Simulation()).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

Reimplemented in olb::opti::AdjointLbSolver< T, PARAMETERS, LATTICES, MODE >.

Definition at line 221 of file lbSolver.h.

221{ };

◆ 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 219 of file lbSolver.h.

219{ };

◆ converter() [1/2]

template<typename T , typename PARAMETERS , typename LATTICES >

template<typename... ARGS>

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

inline

Definition at line 260 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

inline

Definition at line 271 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 256 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 ( )

inline

Definition at line 305 of file lbSolver.h.

                   {
    return *_sGeometry;
  }

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

◆ geometry() [2/2]

template<typename T , typename PARAMETERS , typename LATTICES >

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

inline

Definition at line 308 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 153 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 214 of file lbSolver.h.

214{ };

◆ 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 ( )

inline

Definition at line 297 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

inline

Definition at line 301 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() )

inline

Definition at line 282 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

inline

Definition at line 286 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 > )

inline

Definition at line 290 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

inline

Definition at line 294 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 207 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, olb::meta::tuple_for_each(), and olb::writeVTK().

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 323 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);
 
  SuperLatticeCuboid<T,DESCRIPTOR> cuboid(lattice);
  SuperLatticeRank<T,DESCRIPTOR> rank(lattice);
  vtmWriter.write( cuboid );
  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 305 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();
  });
 
  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(), and olb::writeVTK().

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 255 of file lbSolver.h.

255{ };

◆ 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 252 of file lbSolver.h.

252{ };

◆ writeLogConverter()

template<typename T , typename PARAMETERS , typename LATTICES >

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

protectedvirtual

Definition at line 316 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 249 of file lbSolver.h.

249{ };

Member Data Documentation

◆ _cGeometry

template<typename T , typename PARAMETERS , typename LATTICES >

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

protected

Definition at line 145 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 162 of file lbSolver.h.

◆ _itBoundaryUpdate

template<typename T , typename PARAMETERS , typename LATTICES >

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

protected

Definition at line 169 of file lbSolver.h.

169{1};

◆ _itCheckStability

template<typename T , typename PARAMETERS , typename LATTICES >

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

protected

Definition at line 168 of file lbSolver.h.

168{1};

◆ _loadBalancer

template<typename T , typename PARAMETERS , typename LATTICES >

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

protected

Definition at line 146 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 144 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 148 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 150 of file lbSolver.h.

◆ dim

template<typename T , typename PARAMETERS , typename LATTICES >

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

staticconstexpr

Definition at line 138 of file lbSolver.h.

◆ isStationary

template<typename T , typename PARAMETERS , typename LATTICES >

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

staticconstexprprotected

Definition at line 152 of file lbSolver.h.

◆ outputGnuplot

template<typename T , typename PARAMETERS , typename LATTICES >

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

staticconstexprprotected

Definition at line 164 of file lbSolver.h.

◆ outputImages

template<typename T , typename PARAMETERS , typename LATTICES >

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

staticconstexprprotected

Definition at line 165 of file lbSolver.h.

◆ outputVTK

template<typename T , typename PARAMETERS , typename LATTICES >

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

staticconstexprprotected

Definition at line 166 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

Static Public Attributes

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() [1/2]

◆ LbSolver() [2/2]

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

◆ _cGeometry

◆ _convergenceCheck

◆ _itBoundaryUpdate

◆ _itCheckStability

◆ _loadBalancer

◆ _sGeometry

◆ _sLattices

◆ _timer

◆ dim

◆ isStationary

◆ outputGnuplot

◆ outputImages

◆ outputVTK