olb::opti Namespace Reference

All optimization code is contained in this namespace. More...

Namespaces
namespace	projection

Classes
class	AdjointLbSolver
	Base class for solvers that solve both primal and dual problems. More...
class	BlockDdifferenceObjectiveDf3D
	functor to compute 0.5*(f-f_wanted)^2 on a lattice More...
class	BlockDrelativeDifferenceObjectiveComponentDf3D
	functor to compute 0.5*(f[extractDim]-f_wanted[0])^2/f_wanted^2 on a lattice More...
class	BlockDrelativeDifferenceObjectiveDf3D
	functor to compute 0.5(f-f_wanted)^2/f_wanted^2 on a lattice More...
class	BlockLatticeDphysDissipationDf
	functor to get the pointwise dual dissipation density on local lattices, if globIC is not on the local processor, the returned vector is empty More...
class	BlockLatticeDphysVelocityDf3D
	functor to get pointwise dual velocity density on local lattices, if globIC is not on the local processor, the returned vector is empty More...
class	BlockLatticeSerialDataF
class	Controller
struct	DCDALPHA
	Collision operator derivative regarding optimization controls. More...
class	DdifferenceObjectiveDf3D
	functor to compute 0.5*(f-f_wanted)^2 on a lattice More...
class	DifferenceObjective3D
	functor to compute 0.5*L2Norm(f-f_wanted)^2 on a lattice More...
class	DistributedObjective
	Objective in optimization with adjoint LBM. More...
struct	DJDALPHA
	Objective functional derivative regarding optimization controls. More...
struct	DJDF
	Derivative of Objective functional regarding populations. More...
struct	DPROJECTIONDALPHA
	Derivative of control projection regarding control variable. More...
class	DrelativeDifferenceObjectiveComponentDf3D
	functor to compute 0.5*(f[extractDim]-f_wanted[0])^2/f_wanted^2 on a lattice More...
class	DrelativeDifferenceObjectiveDf3D
	functor to compute 0.5(f-f_wanted)^2/f_wanted^2 on a lattice More...
class	DualController
class	DualForcedMRTdynamics
	Implementation of the dual MRT collision step with external force. More...
struct	dualLbHelpers
	This structure forwards the calls to the appropriate helper class. More...
struct	dualLbMomentaHelpers
struct	F
	Stores populations of the primal problems for adjoint simulations. More...
class	GenericObjective
	Objective in optimization with adjoint LBM. More...
class	GeometrySerializer
	This class serializes the cells inside the geometry. More...
struct	J
	Objective functional results, always scalar. More...
class	OptiCase
	Abstract base class for optimization tasks. More...
class	OptiCaseAD
	Derivatives are computed with automatic differentiation. More...
class	OptiCaseAdForSolver
	Interface for OptiCaseAD that performs Lattice-Boltzmann-Solver construction itself (from xml file) More...
class	OptiCaseAnalytical
	Gradient is just passed as a function (and not computed by an own routine) More...
class	OptiCaseCDQ
	Gradient computation with central difference quotients. More...
class	OptiCaseDQ
class	OptiCaseDual
	This class implements the evaluation of the goal functional and its derivatives by using adjoint LBM. More...
class	OptiCaseFDQ
	Gradient computation with forward difference quotients. More...
class	Optimizer
	Interface for the use of various optimization algorithms. More...
class	OptimizerBarzilaiBorwein
	Optimization algorithm: BarzilaiBorwein. More...
class	OptimizerLBFGS
	Optimization algorithm: LBFGS. More...
class	OptimizerLineSearch
	Optimization algorithm: LineSearch. More...
class	OptimizerSteepestDescent
	Optimization algorithm: SteepestDescent. More...
class	RelativeDifferenceObjective3D
	functor to compute 0.5*L2Norm(f-f_wanted)^2/L2Norm(f_wanted)^2 on a lattice More...
struct	SENSITIVITY
	Total derivative of the objective functional regarding controls. More...
class	SimpleGeometrySerializer
	This class serializes the cells inside the geometry. More...
class	SparseGeometrySerializer
	This class serializes the cells which are marked by indicator. More...
class	SuperLatticeDphysDissipationDf
	functor to get pointwise dual dissipation density on local lattices, if globIC is not on the local processor, the returned vector is empty More...
class	SuperLatticeDphysVelocityDf3D
	functor to get pointwise dual velocity density on local lattices, if globIC is not on the local processor, the returned vector is empty More...
class	SuperLatticeSerialDataF
	A data field whose values are managed by a controller. More...

Enumerations
enum	OptimizerLogType {   control , derivative , value , error ,   norm_derivative }
enum	StartValueType { Control , ProjectedControl , Porosity , Permeability }
enum class	SolverMode : int { Reference , Primal , Dual }
	Tags different simulation modes: compute either reference simulation or perform primal or dual (adjoint) simulation. More...

Functions
template<typename S , typename C >
	OptiCaseAnalytical (std::function< S(const C &)>, std::function< void(const C &, C &)>) -> OptiCaseAnalytical< S, C >
template<typename S , typename C >
	OptiCaseAnalytical (std::function< S(const C &)>, std::function< void(const C &, C &)>, std::function< void(void)>) -> OptiCaseAnalytical< S, C >
template<typename S , typename C >
	OptiCaseFDQ (std::function< S(const C &)>, std::function< void(void)>) -> OptiCaseFDQ< S, C >
template<typename S , typename C >
	OptiCaseFDQ (std::function< S(const C &)>, S, std::function< void(void)>) -> OptiCaseFDQ< S, C >
template<typename S , typename C >
	OptiCaseFDQ (std::function< S(const C &, unsigned)>, std::function< void(void)>) -> OptiCaseFDQ< S, C >
template<typename S , typename C >
	OptiCaseFDQ (std::function< S(const C &, unsigned)>, S, std::function< void(void)>) -> OptiCaseFDQ< S, C >
template<typename S , typename C >
	OptiCaseFDQ (std::function< S(const C &)>) -> OptiCaseFDQ< S, C >
template<typename S , typename C >
	OptiCaseFDQ (std::function< S(const C &)>, S) -> OptiCaseFDQ< S, C >
template<typename S , typename C >
	OptiCaseFDQ (std::function< S(const C &, unsigned)>) -> OptiCaseFDQ< S, C >
template<typename S , typename C >
	OptiCaseFDQ (std::function< S(const C &, unsigned)>, S) -> OptiCaseFDQ< S, C >
template<typename S , typename C >
	OptiCaseCDQ (std::function< S(const C &)>, std::function< void(void)>) -> OptiCaseCDQ< S, C >
template<typename S , typename C >
	OptiCaseCDQ (std::function< S(const C &)>, S, std::function< void(void)>) -> OptiCaseCDQ< S, C >
template<typename S , typename C >
	OptiCaseCDQ (std::function< S(const C &, unsigned)>, std::function< void(void)>) -> OptiCaseCDQ< S, C >
template<typename S , typename C >
	OptiCaseCDQ (std::function< S(const C &, unsigned)>, S, std::function< void(void)>) -> OptiCaseCDQ< S, C >
template<typename S , typename C >
	OptiCaseCDQ (std::function< S(const C &)>) -> OptiCaseCDQ< S, C >
template<typename S , typename C >
	OptiCaseCDQ (std::function< S(const C &)>, S) -> OptiCaseCDQ< S, C >
template<typename S , typename C >
	OptiCaseCDQ (std::function< S(const C &, unsigned)>) -> OptiCaseCDQ< S, C >
template<typename S , typename C >
	OptiCaseCDQ (std::function< S(const C &, unsigned)>, S) -> OptiCaseCDQ< S, C >
template<typename S , typename T , template< typename > typename SOLVER>
	OptiCaseAdForSolver (std::shared_ptr< SOLVER< S > >, std::shared_ptr< SOLVER< T > >) -> OptiCaseAdForSolver< S, T::dim, SOLVER, util::StdVector >
void	getGnuplotTagsFromString (std::string gplotAnalysisString, std::vector< OptimizerLogType > &gplotAnalysis)
	the gplotAnalysisString is gained from the xml file and the function than separates and prepares it to be used in the constructor
template<typename S , typename C = std::vector<S>>
OptimizerBarzilaiBorwein< S, C > *	createOptimizerBarzilaiBorwein (XMLreader const &params, std::size_t dimCtrl)
	Creator Function for Barzilai-Borwein.
template<typename S , typename C = std::vector<S>>
OptimizerLBFGS< S, C > *	createOptimizerLBFGS (XMLreader const &params, std::size_t dimCtrl)
	Creator Function for LBFGS.
template<typename S , typename C = std::vector<S>>
OptimizerSteepestDescent< S, C > *	createOptimizerSteepestDescent (XMLreader const &params, std::size_t dimCtrl)
	Creator Function for Steepest Decent.
template<typename PROJECTION , typename T >
std::vector< T >	applyProjection (const std::vector< T > &vector)
template<typename PROJECTION , typename T , typename ARG >
std::vector< T >	applyProjection (const std::vector< T > &vector, ARG arg)
template<typename S , unsigned dim>
int	getMaterialGlobally (SuperGeometry< S, dim > &sGeometry, LatticeR< dim+1 > latticeR)
	Helper that gives global access to material numbers.
template<unsigned D, typename T >
bool	evaluateSuperIndicatorFglobally (SuperIndicatorF< T, D > &f, const int input[])
	Helper that gives global access to the values of an indicator.
template<unsigned D, typename T , typename U = T>
bool	evaluateSuperFglobally (SuperF< D, T, U > &f, U *output, const int input[])
	Helper that gives global access to the values of a functor.
template<typename FIELD , typename T , typename DESCRIPTOR , typename C = std::vector<T>>
C	serialDataFromField (SuperLattice< T, DESCRIPTOR > &sLattice, const GeometrySerializer< T, DESCRIPTOR::d > &serializer, SuperIndicatorF< T, DESCRIPTOR::d > &indicator, unsigned controlDim)
	Take values of a field and put them into a long vector Idea: FIELD[cartesianCoordinates] = result[serialIndex] -> we want to get the vector ''result''.
template<typename T , template< typename, SolverMode > typename SOLVER, concepts::Field CONTROLLED_FIELD, template< typename... > typename PRIMAL_DYNAMICS, typename C = std::vector<T>>
C	serialDataFromField (OptiCaseDual< T, SOLVER, CONTROLLED_FIELD, PRIMAL_DYNAMICS, C > &optiCase, std::shared_ptr< SOLVER< T, SolverMode::Reference > > solver)
	Take values of FIELD and put them into a long vector Idea: FIELD[cartesianCoordinates] = result[serialIndex] -> we want to get the vector ''result''.
template<typename T , template< typename, SolverMode > typename SOLVER, concepts::Field CONTROLLED_FIELD, template< typename... > typename PRIMAL_DYNAMICS, typename C = std::vector<T>>
C	getControl (OptiCaseDual< T, SOLVER, CONTROLLED_FIELD, PRIMAL_DYNAMICS, C > &optiCase, std::shared_ptr< SOLVER< T, SolverMode::Reference > > solver)
	Get control values of some simulation in the context of adjoint optimization Take values of FIELD, apply inverse projection and put them into a long vector Idea: FIELD[cartesianCoordinates] = projection(result[serialIndex]) -> we want to get the vector ''result''.

Detailed Description

All optimization code is contained in this namespace.

Enumeration Type Documentation

OptimizerLogType

enum olb::opti::OptimizerLogType

Enumerator
control
derivative
value
error
norm_derivative

Definition at line 46 of file optimizer.h.

{control, derivative, value, error, norm_derivative};

SolverMode

enum class olb::opti::SolverMode : int

strong

Tags different simulation modes: compute either reference simulation or perform primal or dual (adjoint) simulation.

Enumerator
Reference
Primal
Dual

Definition at line 39 of file adjointLbSolver.h.

: int {Reference, Primal, Dual};

StartValueType

enum olb::opti::StartValueType

Enumerator
Control
ProjectedControl
Porosity
Permeability

Definition at line 42 of file projection.h.

{Control, ProjectedControl, Porosity, Permeability};

Function Documentation

applyProjection() [1/2]

template<typename PROJECTION , typename T >

std::vector< T > olb::opti::applyProjection

(

const std::vector< T > &

vector

)

Definition at line 394 of file projection.h.

                                                         {
  std::vector<T> projected;
  for (auto& e : vector) {
    projected.push_back(PROJECTION().project(e));
  }
  return projected;
}

applyProjection() [2/2]

template<typename PROJECTION , typename T , typename ARG >

std::vector< T > olb::opti::applyProjection	(	const std::vector< T > &	vector,
		ARG	arg )

Definition at line 403 of file projection.h.

                                                                  {
  std::vector<T> projected;
  for (auto& e : vector) {
    projected.push_back(PROJECTION(arg).project(e));
  }
  return projected;
}

createOptimizerBarzilaiBorwein()

template<typename S , typename C = std::vector<S>>

OptimizerBarzilaiBorwein< S, C > * olb::opti::createOptimizerBarzilaiBorwein	(	XMLreader const &	params,
		std::size_t	dimCtrl )

Creator Function for Barzilai-Borwein.

Definition at line 181 of file optimizerBarzilaiBorwein.h.

{
  OstreamManager clout(std::cout,"createOptimizerBarzilaiBorwein");
 
  // create variables with default values
  int maxIt = 100;
 
  S controlEps = S(0);
  S eps = S(1.e-10);
 
  S lambda = 1.; //starting lambda for steepest descent step (it==0)
  int maxStepAttempts  = 100;
  std::string stepCondition = "None";
 
  bool verboseOn=true;
  std::string fname = "control.dat";
  std::string logFileName = "log.txt";
 
  bool vectorBounds = false;
  bool withUpperBound = false;
  S upperBound = S();
  bool withLowerBound = false;
  S lowerBound = S();
 
  std::vector<OptimizerLogType> gplotAnalysis  = {};
  std::string gplotAnalysisString = "";
 
  // Read Values from XML File
  params.readOrWarn<int>("Optimization", "MaxIter", "", maxIt);
 
  params.readOrWarn<S>("Optimization", "Tolerance", "", eps);
  params.readOrWarn<S>("Optimization", "ControlTolerance", "", controlEps);
  params.readOrWarn<S>("Optimization", "Lambda", "", lambda);
  params.readOrWarn<int>("Optimization", "MaxStepAttempts", "", maxStepAttempts);
  params.readOrWarn<std::string>("Optimization", "StepCondition", "", stepCondition);
 
  params.readOrWarn<bool>("Optimization", "Verbose", "", verboseOn);
  params.readOrWarn<std::string>("Optimization", "InputFileName", "", fname);
  params.readOrWarn<std::string>("Optimization", "LogFileName", "", logFileName);
 
  params.readOrWarn<bool>("Optimization", "VectorBounds", "", vectorBounds);
  if ( params.readOrWarn<S>("Optimization", "UpperBound", "", upperBound, false, false) ) {
    withUpperBound = true;
  }
  if ( params.readOrWarn<S>("Optimization", "LowerBound", "", lowerBound, false, false) ) {
    withLowerBound = true;
  }
 
  // get the parameters for the gnuplot Analysis from the xml file from the VisualizationGnuplot area
  params.readOrWarn<std::string>("Optimization", "VisualizationGnuplot", "VisualizedParameters", "", gplotAnalysisString, false, false);
  // transform the data from the xml file to the enums needed for continueing
  getGnuplotTagsFromString(gplotAnalysisString, gplotAnalysis);
 
  // Create Optimizer Object
  return new OptimizerBarzilaiBorwein<S,C>(dimCtrl, eps, maxIt, lambda, maxStepAttempts, stepCondition,
                                         verboseOn, fname, logFileName, withUpperBound, upperBound, withLowerBound, lowerBound,
                                         vectorBounds, controlEps, gplotAnalysis);
}

References getGnuplotTagsFromString(), and olb::XMLreader::readOrWarn().

Here is the call graph for this function:

createOptimizerLBFGS()

template<typename S , typename C = std::vector<S>>

OptimizerLBFGS< S, C > * olb::opti::createOptimizerLBFGS	(	XMLreader const &	params,
		std::size_t	dimCtrl )

Creator Function for LBFGS.

Definition at line 263 of file optimizerLBFGS.h.

{
  OstreamManager clout(std::cout, "createOptimizerLBFGS");
 
  // create variables with default values
  int maxIt = 100;
  int l = 20;
  S lambda = 1.; //starting lambda for steepest descent step (it==0)
  int maxStepAttempts = 100;
  std::string stepCondition = "StrongWolfe";
 
  //S controlEps = S(std::numeric_limits<double>::epsilon() );
  S controlEps = S(0);
  S eps = S(1.e-10);
  S startCoefH = S(1e-4);
 
  bool verboseOn=true;
  std::string fname = "control.dat";
  std::string logFileName = "log.txt";
  bool vectorBounds = false;
  bool withUpperBound = false;
  S upperBound = S();
  bool withLowerBound = false;
  S lowerBound = S();
  bool failOnMaxIter = true;
 
  std::vector<OptimizerLogType> gplotAnalysis  = {};
  std::string gplotAnalysisString = "";
 
  // Read Values from XML File from area "Optimization"
  params.readOrWarn<int>("Optimization", "MaxIter", "", maxIt);
  params.readOrWarn<int>("Optimization", "L", "", l);
  params.readOrWarn<S>("Optimization", "Lambda", "", lambda);
  params.readOrWarn<int>("Optimization", "MaxStepAttempts", "", maxStepAttempts);
  params.readOrWarn<std::string>("Optimization", "StepCondition", "", stepCondition);
 
  params.readOrWarn<S>("Optimization", "Tolerance", "", eps);
  params.readOrWarn<S>("Optimization", "ControlTolerance", "", controlEps);
  params.readOrWarn<S>("Optimization", "StartCoefH", "", startCoefH);
  params.readOrWarn<bool>("Optimization", "FailOnMaxIter", "", failOnMaxIter);
  params.readOrWarn<bool>("Optimization", "Verbose", "", verboseOn);
  params.readOrWarn<std::string>("Optimization", "InputFileName", "", fname);
  params.readOrWarn<std::string>("Optimization", "LogFileName", "", logFileName);
 
  params.readOrWarn<bool>("Optimization", "VectorBounds", "", vectorBounds);
  if ( params.readOrWarn<S>("Optimization", "UpperBound", "", upperBound, false, false) ) {
    withUpperBound = true;
  }
 
  if ( params.readOrWarn<S>("Optimization", "LowerBound", "", lowerBound, false, false) ) {
    withLowerBound = true;
  }
 
  // get the parameters for the gnuplot Analysis from the xml file from the VisualizationGnuplot area
  params.readOrWarn<std::string>("Optimization",
                                        "VisualizationGnuplot",
                                        "VisualizedParameters", gplotAnalysisString, false, false);
  // transform the data from the xml file to the enums needed for continueing
  getGnuplotTagsFromString(gplotAnalysisString, gplotAnalysis);
 
  clout << "Creating optimizer ..." << std::endl;
  // Create Optimizer Object
  return new OptimizerLBFGS<S,C>(dimCtrl, eps, maxIt, lambda, maxStepAttempts, stepCondition, l, startCoefH,
                               verboseOn, fname, logFileName, withUpperBound, upperBound, withLowerBound, lowerBound, vectorBounds,
                               controlEps, failOnMaxIter, gplotAnalysis);
}

References getGnuplotTagsFromString(), and olb::XMLreader::readOrWarn().

Here is the call graph for this function:

createOptimizerSteepestDescent()

template<typename S , typename C = std::vector<S>>

OptimizerSteepestDescent< S, C > * olb::opti::createOptimizerSteepestDescent	(	XMLreader const &	params,
		std::size_t	dimCtrl )

Creator Function for Steepest Decent.

Definition at line 93 of file optimizerSteepestDecent.h.

{
  OstreamManager clout(std::cout,"createOptimizerSteepestDescent");
 
  // create variables with default values
  int maxIt = 100;
 
  //S controlEps = S(std::numeric_limits<double>::epsilon() );
  S controlEps = S(0);
  S eps = S(1.e-10);
 
  S lambda = 1.;
  int maxStepAttempts = 100;
  std::string stepCondition = "Armijo";
 
  bool vectorBounds = false;
  bool verboseOn=true;
  std::string fname = "control.dat";
  std::string logFileName = "log.txt";
 
  bool withUpperBound = false;
  S upperBound = S();
  bool withLowerBound = false;
  S lowerBound = S();
 
  std::vector<OptimizerLogType> gplotAnalysis  = {};
  std::string gplotAnalysisString = "";
 
  // Read Values from XML File from area "Optimization"
  params.readOrWarn<int>("Optimization", "MaxIter", "", maxIt);
 
  params.readOrWarn<S>("Optimization", "Tolerance", "", eps);
  params.readOrWarn<S>("Optimization", "ControlTolerance", "", controlEps);
  params.readOrWarn<S>("Optimization", "Lambda", "", lambda);
  params.readOrWarn<int>("Optimization", "MaxStepAttempts", "", maxStepAttempts);
  params.readOrWarn<std::string>("Optimization", "StepCondition", "", stepCondition);
 
  params.readOrWarn<bool>("Optimization", "Verbose", "", verboseOn);
  params.readOrWarn<std::string>("Optimization", "InputFileName", "", fname);
  params.readOrWarn<std::string>("Optimization", "LogFileName", "", logFileName);
 
  params.readOrWarn<bool>("Optimization", "VectorBounds", "", vectorBounds);
  if ( params.readOrWarn<S>("Optimization", "UpperBound", "", upperBound, false, false) ) {
    withUpperBound = true;
  }
 
  if ( params.readOrWarn<S>("Optimization", "LowerBound", "", lowerBound, false, false) ) {
    withLowerBound = true;
  }
 
  // get the parameters for the gnuplot Analysis from the xml file from the VisualizationGnuplot area
  params.readOrWarn<std::string>("Optimization", "VisualizationGnuplot", "VisualizedParameters", "", gplotAnalysisString, false, false);
  // transform the data from the xml file to the enums needed for continueing
  getGnuplotTagsFromString(gplotAnalysisString, gplotAnalysis);
 
  // Create Optimizer Object
  return new OptimizerSteepestDescent<S,C>(dimCtrl, eps, maxIt, lambda, maxStepAttempts, stepCondition,
                                         verboseOn, fname, logFileName, withUpperBound, upperBound, withLowerBound, lowerBound,
                                         vectorBounds, controlEps, gplotAnalysis);
}

References getGnuplotTagsFromString(), and olb::XMLreader::readOrWarn().

Here is the call graph for this function:

evaluateSuperFglobally()

template<unsigned D, typename T , typename U = T>

bool olb::opti::evaluateSuperFglobally	(	SuperF< D, T, U > &	f,
		U *	output,
		const int	input[] )

Helper that gives global access to the values of a functor.

Definition at line 435 of file serialization.h.

{
  const auto loadBalancer = f.getSuperStructure().getLoadBalancer();
  if ( loadBalancer.rank(input[0]) == singleton::mpi().getRank() ) {
    f(output, input);
  }
#ifdef PARALLEL_MODE_MPI
  singleton::mpi().bCast(output, f.getTargetDim(), loadBalancer.rank(input[0]));
#endif
  return true;
}

References olb::singleton::MpiManager::bCast(), olb::singleton::MpiManager::getRank(), and olb::singleton::mpi().

Here is the call graph for this function:

evaluateSuperIndicatorFglobally()

template<unsigned D, typename T >

bool olb::opti::evaluateSuperIndicatorFglobally	(	SuperIndicatorF< T, D > &	f,
		const int	input[] )

Helper that gives global access to the values of an indicator.

Definition at line 418 of file serialization.h.

{
  bool result = false;
  const auto loadBalancer = f.getSuperGeometry().getLoadBalancer();
  if ( loadBalancer.rank(input[0]) == singleton::mpi().getRank() ) {
    result = f(input);
  }
#ifdef PARALLEL_MODE_MPI
  singleton::mpi().bCast(&result, 1, loadBalancer.rank(input[0]));
#endif
  return result;
}

References olb::singleton::MpiManager::bCast(), olb::singleton::MpiManager::getRank(), and olb::singleton::mpi().

Here is the call graph for this function:

Here is the caller graph for this function:

getControl()

template<typename T , template< typename, SolverMode > typename SOLVER, concepts::Field CONTROLLED_FIELD, template< typename... > typename PRIMAL_DYNAMICS, typename C = std::vector<T>>

C olb::opti::getControl	(	OptiCaseDual< T, SOLVER, CONTROLLED_FIELD, PRIMAL_DYNAMICS, C > &	optiCase,
		std::shared_ptr< SOLVER< T, SolverMode::Reference > >	solver )

Get control values of some simulation in the context of adjoint optimization Take values of FIELD, apply inverse projection and put them into a long vector Idea: FIELD[cartesianCoordinates] = projection(result[serialIndex]) -> we want to get the vector ''result''.

Template Parameters

T	floating point type
C	container type, where result is written
FIELD	name of the field

Parameters

optiCase	dual opti case, provides the information on serialization etc.
solver	the solver, whose FIELD data is taken

Returns

vector with the field data

Definition at line 570 of file serialization.h.

{
  C result = serialDataFromField<T,SOLVER,CONTROLLED_FIELD,PRIMAL_DYNAMICS,C>(optiCase, solver);
  std::transform(result.begin(), result.end(), result.begin(), [&](auto r){
    return optiCase._projection->inverse(r);
  });
  return result;
}

References serialDataFromField().

Here is the call graph for this function:

getGnuplotTagsFromString()

void olb::opti::getGnuplotTagsFromString	(	std::string	gplotAnalysisString,
		std::vector< OptimizerLogType > &	gplotAnalysis )

the gplotAnalysisString is gained from the xml file and the function than separates and prepares it to be used in the constructor

Definition at line 244 of file optimizer.hh.

                                                                          {
  // part the string to get the enum vector
  std::vector<std::string> gplotAnalysisStringVector;
  std::istringstream iss(gplotAnalysisString);
  std::copy(std::istream_iterator<std::string>(iss),
        std::istream_iterator<std::string>(),
       std::back_inserter(gplotAnalysisStringVector));
 
  for(unsigned i = 0; i < gplotAnalysisStringVector.size(); i++){
    if(gplotAnalysisStringVector[i] == "VALUE"){
      gplotAnalysis.push_back(OptimizerLogType::value);
    } else if(gplotAnalysisStringVector[i] == "CONTROL"){
      gplotAnalysis.push_back(OptimizerLogType::control);
    } else if(gplotAnalysisStringVector[i] == "DERIVATIVE"){
      gplotAnalysis.push_back(OptimizerLogType::derivative);
    } else if(gplotAnalysisStringVector[i] == "ERROR"){
      gplotAnalysis.push_back(OptimizerLogType::error);
    } else if(gplotAnalysisStringVector[i] == "NORM_DERIVATIVE"){
      gplotAnalysis.push_back(OptimizerLogType::norm_derivative);
    }
  }
}

References control, derivative, error, norm_derivative, and value.

Here is the caller graph for this function:

getMaterialGlobally()

template<typename S , unsigned dim>

int olb::opti::getMaterialGlobally	(	SuperGeometry< S, dim > &	sGeometry,
		LatticeR< dim+1 >	latticeR )

Helper that gives global access to material numbers.

Definition at line 402 of file serialization.h.

{
  int material = 0;
  if ( sGeometry.getLoadBalancer().rank(latticeR[0]) == singleton::mpi().getRank() ) {
    material = sGeometry.get(latticeR);
  }
#ifdef PARALLEL_MODE_MPI
  singleton::mpi().bCast(&material, 1, sGeometry.getLoadBalancer().rank(latticeR[0]));
#endif
  return material;
}

References olb::singleton::MpiManager::bCast(), olb::SuperGeometry< T, D >::get(), olb::SuperStructure< T, D >::getLoadBalancer(), olb::singleton::MpiManager::getRank(), and olb::singleton::mpi().

Here is the call graph for this function:

OptiCaseAdForSolver()

template<typename S , typename T , template< typename > typename SOLVER>

olb::opti::OptiCaseAdForSolver	(	std::shared_ptr< SOLVER< S > >	,
		std::shared_ptr< SOLVER< T > >	) -> OptiCaseAdForSolver< S, T::dim, SOLVER, util::StdVector >

OptiCaseAnalytical() [1/2]

template<typename S , typename C >

olb::opti::OptiCaseAnalytical	(	std::function< S(const C &)>	,
		std::function< void(const C &, C &)>	) -> OptiCaseAnalytical< S, C >

OptiCaseAnalytical() [2/2]

template<typename S , typename C >

olb::opti::OptiCaseAnalytical	(	std::function< S(const C &)>	,
		std::function< void(const C &, C &)>	,
		std::function< void(void)>	) -> OptiCaseAnalytical< S, C >

OptiCaseCDQ() [1/8]

template<typename S , typename C >

olb::opti::OptiCaseCDQ

(

std::function< S(const C &)>

)

-> OptiCaseCDQ< S, C >

OptiCaseCDQ() [2/8]

template<typename S , typename C >

olb::opti::OptiCaseCDQ	(	std::function< S(const C &)>	,
		S	) -> OptiCaseCDQ< S, C >

OptiCaseCDQ() [3/8]

template<typename S , typename C >

olb::opti::OptiCaseCDQ	(	std::function< S(const C &)>	,
		S	,
		std::function< void(void)>	) -> OptiCaseCDQ< S, C >

OptiCaseCDQ() [4/8]

template<typename S , typename C >

olb::opti::OptiCaseCDQ	(	std::function< S(const C &)>	,
		std::function< void(void)>	) -> OptiCaseCDQ< S, C >

OptiCaseCDQ() [5/8]

template<typename S , typename C >

olb::opti::OptiCaseCDQ

(

std::function< S(const C &, unsigned)>

)

-> OptiCaseCDQ< S, C >

OptiCaseCDQ() [6/8]

template<typename S , typename C >

olb::opti::OptiCaseCDQ	(	std::function< S(const C &, unsigned)>	,
		S	) -> OptiCaseCDQ< S, C >

OptiCaseCDQ() [7/8]

template<typename S , typename C >

olb::opti::OptiCaseCDQ	(	std::function< S(const C &, unsigned)>	,
		S	,
		std::function< void(void)>	) -> OptiCaseCDQ< S, C >

OptiCaseCDQ() [8/8]

template<typename S , typename C >

olb::opti::OptiCaseCDQ	(	std::function< S(const C &, unsigned)>	,
		std::function< void(void)>	) -> OptiCaseCDQ< S, C >

OptiCaseFDQ() [1/8]

template<typename S , typename C >

olb::opti::OptiCaseFDQ

(

std::function< S(const C &)>

)

-> OptiCaseFDQ< S, C >

OptiCaseFDQ() [2/8]

template<typename S , typename C >

olb::opti::OptiCaseFDQ	(	std::function< S(const C &)>	,
		S	) -> OptiCaseFDQ< S, C >

OptiCaseFDQ() [3/8]

template<typename S , typename C >

olb::opti::OptiCaseFDQ	(	std::function< S(const C &)>	,
		S	,
		std::function< void(void)>	) -> OptiCaseFDQ< S, C >

OptiCaseFDQ() [4/8]

template<typename S , typename C >

olb::opti::OptiCaseFDQ	(	std::function< S(const C &)>	,
		std::function< void(void)>	) -> OptiCaseFDQ< S, C >

OptiCaseFDQ() [5/8]

template<typename S , typename C >

olb::opti::OptiCaseFDQ

(

std::function< S(const C &, unsigned)>

)

-> OptiCaseFDQ< S, C >

OptiCaseFDQ() [6/8]

template<typename S , typename C >

olb::opti::OptiCaseFDQ	(	std::function< S(const C &, unsigned)>	,
		S	) -> OptiCaseFDQ< S, C >

OptiCaseFDQ() [7/8]

template<typename S , typename C >

olb::opti::OptiCaseFDQ	(	std::function< S(const C &, unsigned)>	,
		S	,
		std::function< void(void)>	) -> OptiCaseFDQ< S, C >

OptiCaseFDQ() [8/8]

template<typename S , typename C >

olb::opti::OptiCaseFDQ	(	std::function< S(const C &, unsigned)>	,
		std::function< void(void)>	) -> OptiCaseFDQ< S, C >

serialDataFromField() [1/2]

template<typename T , template< typename, SolverMode > typename SOLVER, concepts::Field CONTROLLED_FIELD, template< typename... > typename PRIMAL_DYNAMICS, typename C = std::vector<T>>

C olb::opti::serialDataFromField	(	OptiCaseDual< T, SOLVER, CONTROLLED_FIELD, PRIMAL_DYNAMICS, C > &	optiCase,
		std::shared_ptr< SOLVER< T, SolverMode::Reference > >	solver )

Take values of FIELD and put them into a long vector Idea: FIELD[cartesianCoordinates] = result[serialIndex] -> we want to get the vector ''result''.

Template Parameters

T	floating point type
C	container type, where result is written
FIELD	name of the field

Parameters

optiCase	dual opti case, provides the information on serialization etc.
solver	the solver, whose FIELD data is taken

Returns

vector with the field data

Definition at line 540 of file serialization.h.

{
  using descriptor = typename SOLVER<T,SolverMode::Reference>::AdjointLbSolver::DESCRIPTOR;
  return serialDataFromField<
    CONTROLLED_FIELD, T, descriptor, C>(
    solver->lattice(),
    *(optiCase._serializer),
    *(optiCase._controlIndicator),
    optiCase._dimCtrl
  );
}

References olb::opti::OptiCaseDual< S, SOLVER, CONTROLLED_FIELD, PRIMAL_DYNAMICS, C >::_controlIndicator, olb::opti::OptiCaseDual< S, SOLVER, CONTROLLED_FIELD, PRIMAL_DYNAMICS, C >::_dimCtrl, olb::opti::OptiCaseDual< S, SOLVER, CONTROLLED_FIELD, PRIMAL_DYNAMICS, C >::_serializer, and serialDataFromField().

Here is the call graph for this function:

serialDataFromField() [2/2]

template<typename FIELD , typename T , typename DESCRIPTOR , typename C = std::vector<T>>

C olb::opti::serialDataFromField	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		const GeometrySerializer< T, DESCRIPTOR::d > &	serializer,
		SuperIndicatorF< T, DESCRIPTOR::d > &	indicator,
		unsigned	controlDim )

Take values of a field and put them into a long vector Idea: FIELD[cartesianCoordinates] = result[serialIndex] -> we want to get the vector ''result''.

Template Parameters

T	floating point type
DESCRIPTOR	lattice descriptor, must provide the field FIELD
C	container type, where result is written
FIELD	name of the field

Parameters

sLattice	super lattice
serializer	implements the transformation from cartesian to serial data
indicator	describes, at which positions FIELD is evaluated (at other positions, the default value of C remains)
controlDim	length of result vector

Returns

vector with the field data

Definition at line 466 of file serialization.h.

{
  constexpr unsigned dim = DESCRIPTOR::d;
  constexpr unsigned fieldDim = DESCRIPTOR::template size<FIELD>();
  auto result = util::ContainerCreator<C>::create(controlDim);
  const auto& cGeometry = sLattice.getCuboidDecomposition();
  const auto& loadBalancer = sLattice.getLoadBalancer();
 
  LatticeR<dim+1> latticeR;
  for (int iC=0; iC<cGeometry.size(); iC++) {
    latticeR[0] = iC;
    const int nX = cGeometry.get(iC).getNx();
    const int nY = cGeometry.get(iC).getNy();
    const int nZ = cGeometry.get(iC).getNz();
    for (int iX=0; iX<nX; iX++) {
      latticeR[1] = iX;
      for (int iY=0; iY<nY; iY++) {
        latticeR[2] = iY;
        for (int iZ=0; iZ<nZ; iZ++) {
          latticeR[3] = iZ;
 
          if (evaluateSuperIndicatorFglobally<dim,T>(indicator, latticeR.data())) {
            Vector<T,fieldDim> dataHelp;
            if (loadBalancer.rank(iC) == singleton::mpi().getRank()) {
              for (unsigned iDim=0; iDim<fieldDim; iDim++) {
                const auto cell = sLattice.get(latticeR);
                dataHelp[iDim]
                  = cell.template getFieldComponent<FIELD>(iDim);
              }
            }
#ifdef PARALLEL_MODE_MPI
            singleton::mpi().bCast(&dataHelp[0], fieldDim, loadBalancer.rank(iC));
#endif
            for (unsigned iDim=0; iDim<fieldDim; iDim++) {
              const auto index = serializer.getSerializedComponentIndex(latticeR, iDim, fieldDim);
              result[index] = dataHelp[iDim];
            }
          }
        }
      }
    }
  }
  return result;
}

References olb::singleton::MpiManager::bCast(), olb::Vector< T, Size >::data(), evaluateSuperIndicatorFglobally(), olb::SuperLattice< T, DESCRIPTOR >::get(), olb::SuperStructure< T, D >::getCuboidDecomposition(), olb::SuperStructure< T, D >::getLoadBalancer(), olb::singleton::MpiManager::getRank(), olb::opti::GeometrySerializer< S, dim >::getSerializedComponentIndex(), and olb::singleton::mpi().

Here is the call graph for this function:

Here is the caller graph for this function: