Interface for the use of various optimization algorithms. More...

#include <optimizer.h>

Inheritance diagram for olb::opti::Optimizer< S, C >:

Collaboration diagram for olb::opti::Optimizer< S, C >:

Public Member Functions
	Optimizer (int dimCtrl, S eps, int maxIt, bool verboseOn=true, const std::string fname="", const std::string logFileName="", bool withUpperBound=false, S upperBound=S(), bool withLowerBound=false, S lowerBound=S(), bool vectorBounds=false, S controlEps=S(std::numeric_limits< double >::epsilon()), bool failOnMaxIter=true, std::vector< OptimizerLogType > gplotAnalysis={})

virtual	~Optimizer ()

virtual void	optimizationStep ()=0

void	maxIterationReached ()

virtual void	optimize ()

virtual void	optimize (OptiCase< S, C > &optiCase)

void	simulate ()

void	simulate (OptiCase< S, C > &optiCase)

void	evaluateObjective (const C &control, S &result)

void	computeDerivatives (const C &control, C &derivatives)

void	print (int it)
	Prints information of the current optimization step it.

void	setControl (C &control)

const C &	getControl () const

const C &	getDerivative () const

const S &	getObjective () const

int	getIteration () const

void	writeControlToFile (const std::string fname="control.dat")
	Writes the current control variables linewise into file fname.

void	readControlFromFile (const std::string fname="control.dat")
	Reads the latest control variables from file fname.

void	setStartValue (S startValue)

void	setStartValue (C startValues, S factor=S(1))

OptiCase< S, C > *	getOptiCase ()

void	setOptiCase (OptiCase< S, C > *optiCase)

void	setGnuplotData ()

void	setReferenceControl (C result)
	set the reference value for the control vector (exact solution)

Public Attributes
Gnuplot< S >	gplot

std::vector< OptimizerLogType >	_gplotAnalysis
	For defining what kind of gnuplot analysis is wanted, if empty vector - no analysis, value, control and derivative are the possible options.

Protected Attributes
int	_dimCtrl
	Number of controlled variables.

C	_control
	Vector of controlled variables (size _dimCtrl)

S	_value
	Value of the objective functional evaluated for controlled variables saved in _control.

C	_derivative
	Vector of derivatives of the object functional with respect to the controlled variables.

int	_it
	Current iteration no.

int	_maxIt
	Maximal number of iteration.

bool	_failOnMaxIter
	Fail when max number of iteration reached.

S	_eps
	Optimizer stops if \|_derivatives\| < _eps.

bool	_verboseOn
	Verbose.

bool	_withUpperBound
	Bounded versions.

bool	_withLowerBound

bool	_vectorBounds

C	_boundedControl

C	_upperBound

C	_lowerBound

bool	_controlsConverged
	For setting tolerance of controls.

S	_controlEps

OptiCase< S, C > *	_optiCase
	Provides the Optimizer with methods to evaluate the value of an object functional and compute derivatives.

C	_referenceControl
	control vector to compare with (for numerical evaluation)

Detailed Description

template<typename S, typename C>
class olb::opti::Optimizer< S, C >

Interface for the use of various optimization algorithms.

This class is intended to be derived from. S is the underlying arithmetic data type C is the container type that is used to store the vectors (e.g. std::vector<S>) C is expected to allow construction via ContainerCreator class

Definition at line 56 of file optimizer.h.

Constructor & Destructor Documentation

◆ Optimizer()

template<typename S , typename C >

olb::opti::Optimizer< S, C >::Optimizer	(	int	dimCtrl,
		S	eps,
		int	maxIt,
		bool	verboseOn = true,
		const std::string	fname = "",
		const std::string	logFileName = "",
		bool	withUpperBound = false,
		S	upperBound = S(),
		bool	withLowerBound = false,
		S	lowerBound = S(),
		bool	vectorBounds = false,
		S	controlEps = S(std::numeric_limits<double>::epsilon() ),
		bool	failOnMaxIter = true,
		std::vector< OptimizerLogType >	gplotAnalysis = {} )

Definition at line 41 of file optimizer.hh.

: clout(std::cout,"Optimizer"), _dimCtrl(dimCtrl),
    _it(0), _maxIt(maxIt), _failOnMaxIter(failOnMaxIter), _eps(eps),
    _verboseOn(verboseOn),
    _withUpperBound(withUpperBound), _withLowerBound(withLowerBound),
    _vectorBounds(vectorBounds), _controlEps(controlEps),
    gplot(logFileName, Gnuplot<S>::LINEAR, Gnuplot<S>::OFF),
    _gplotAnalysis(gplotAnalysis)
{
  _controlsConverged = false;
 
  _control = util::ContainerCreator<C>::create(_dimCtrl);
  _derivative = util::ContainerCreator<C>::create(_dimCtrl);
 
  if (_withUpperBound||_withLowerBound) {
    _boundedControl = util::ContainerCreator<C>::create(_dimCtrl);
    if (_withLowerBound) {
      _lowerBound = util::ContainerCreator<C>::create(_dimCtrl);
      if (! _vectorBounds) {
        _lowerBound[0] = lowerBound;  // only first component is used...
      }
    }
    if (_withUpperBound) {
      _upperBound = util::ContainerCreator<C>::create(_dimCtrl);
      if (! _vectorBounds) {
        _upperBound[0] = upperBound;  // only first component is used...
      }
    }
  }
 
  readControlFromFile(fname);
}

Here is the call graph for this function:

◆ ~Optimizer()

template<typename S , typename C >

virtual olb::opti::Optimizer< S, C >::~Optimizer ( )

inlinevirtual

Definition at line 118 of file optimizer.h.

118{ };

Member Function Documentation

◆ computeDerivatives()

template<typename S , typename C >

void olb::opti::Optimizer< S, C >::computeDerivatives	(	const C &	control,
		C &	derivatives )

inline

Definition at line 144 of file optimizer.h.

                                                            {
 
    _optiCase->computeDerivatives(control, derivatives, _it);
  }

References olb::opti::Optimizer< S, C >::_it, olb::opti::Optimizer< S, C >::_optiCase, olb::opti::OptiCase< typename, typename >::computeDerivatives(), and olb::opti::control.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ evaluateObjective()

template<typename S , typename C >

void olb::opti::Optimizer< S, C >::evaluateObjective	(	const C &	control,
		S &	result )

inline

Definition at line 140 of file optimizer.h.

                                                      {
    result = _optiCase->evaluateObjective(control, _it);
  }

References olb::opti::Optimizer< S, C >::_it, olb::opti::Optimizer< S, C >::_optiCase, olb::opti::control, and olb::opti::OptiCase< typename, typename >::evaluateObjective().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getControl()

template<typename S , typename C >

const C & olb::opti::Optimizer< S, C >::getControl ( ) const

inline

Definition at line 156 of file optimizer.h.

                              {
    return _control;
  }

References olb::opti::Optimizer< S, C >::_control.

◆ getDerivative()

template<typename S , typename C >

const C & olb::opti::Optimizer< S, C >::getDerivative ( ) const

inline

Definition at line 160 of file optimizer.h.

                                 {
    return _derivative;
  }

References olb::opti::Optimizer< S, C >::_derivative.

◆ getIteration()

template<typename S , typename C >

int olb::opti::Optimizer< S, C >::getIteration ( ) const

inline

Definition at line 168 of file optimizer.h.

                           {
    return _it;
  }

References olb::opti::Optimizer< S, C >::_it.

◆ getObjective()

template<typename S , typename C >

const S & olb::opti::Optimizer< S, C >::getObjective ( ) const

inline

Definition at line 164 of file optimizer.h.

                                {
    return _value;
  }

References olb::opti::Optimizer< S, C >::_value.

◆ getOptiCase()

template<typename S , typename C >

OptiCase< S, C > * olb::opti::Optimizer< S, C >::getOptiCase ( )

inline

Definition at line 182 of file optimizer.h.

182{ return _optiCase; }

References olb::opti::Optimizer< S, C >::_optiCase.

◆ maxIterationReached()

template<typename S , typename C >

void olb::opti::Optimizer< S, C >::maxIterationReached ( )

Definition at line 83 of file optimizer.hh.

{
  if (_failOnMaxIter) {
    clout << "Warning: Optimization problem failed to converge within specified iteration limit of "
          << _maxIt << " iterations with tolerance of " << _eps << ".\nProgram terminated" << std::endl;
    exit(1);
  }
  else {
    clout << "Maximum iteration reached." << std::endl;
  }
}

◆ optimizationStep()

template<typename S , typename C >

virtual void olb::opti::Optimizer< S, C >::optimizationStep ( )

pure virtual

Implemented in olb::opti::OptimizerLineSearch< S, C >.

◆ optimize() [1/2]

template<typename S , typename C >

void olb::opti::Optimizer< S, C >::optimize ( )

virtual

Definition at line 96 of file optimizer.hh.

{
  // Evaluate objective function
  evaluateObjective(_control, _value);
  _optiCase->postEvaluation();
 
  // Optimization step (update of _control, _value, _derivatives and _it)
  do {
    if (_it >= _maxIt) {
      maxIterationReached();
      return;
    }
 
    // Call optimisation algorithm: evaluate objective function and compute derivatives
    optimizationStep();
 
    // Print info
    _optiCase->postEvaluation();
    if (_verboseOn) {
      print(_it);
    }
    if (_gplotAnalysis.size() > 0) {
      setGnuplotData();
    }
 
    // Optimize as long as |derivative| > eps or a maximum of iterations is reached
  }
  while (util::euklidN2(_derivative) > (_eps*_eps) && !_controlsConverged);
 
  if(_gplotAnalysis.size() > 0){
    gplot.writePNG();
  }
}

References olb::util::euklidN2().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ optimize() [2/2]

template<typename S , typename C >

virtual void olb::opti::Optimizer< S, C >::optimize ( OptiCase< S, C > & optiCase )

inlinevirtual

Definition at line 126 of file optimizer.h.

                                                 {
    _optiCase = &optiCase;
    optimize();
  }

References olb::opti::Optimizer< S, C >::_optiCase, and olb::opti::Optimizer< S, C >::optimize().

Here is the call graph for this function:

◆ print()

template<typename S , typename C >

void olb::opti::Optimizer< S, C >::print ( int it )

Prints information of the current optimization step it.

Definition at line 131 of file optimizer.hh.

{
  clout << "=======================================" << std::endl;
  clout << ">>>>>>>>>> Optimizer: step " << it << " <<<<<<<<<<" << std::endl;
  clout << "   Value objective = " << std::setprecision(12) << _value << std::endl;
  clout << "   Norm derivative = " << std::setprecision(12) << util::euklidN(&_derivative[0], _dimCtrl) << std::endl;
  clout << "=======================================" << std::endl;
}

References olb::util::euklidN().

Here is the call graph for this function:

◆ readControlFromFile()

template<typename S , typename C >

void olb::opti::Optimizer< S, C >::readControlFromFile ( const std::string fname = "control.dat" )

Reads the latest control variables from file fname.

Definition at line 155 of file optimizer.hh.

{
  std::ifstream file(fname.c_str());
  if ( file.is_open() ) {
    int dimCtrl;
    file >> dimCtrl;
    if (dimCtrl!=_dimCtrl) {
      clout << "Error: dimensions do not match! dim_controller=" << _dimCtrl << "; dim_file=" << dimCtrl << std::endl;
      assert(false);
    }
    else {
      for (int i=0; i<_dimCtrl; i++) {
        double tmpVal;
        file >> tmpVal;
        _control[i]  = tmpVal;
      }
      if (_withLowerBound && _vectorBounds) {
        for (int i=0; i<_dimCtrl; i++) {
          double tmpVal;
          file >> tmpVal;
          _lowerBound[i]  = tmpVal;
        }
      }
      if (_withUpperBound && _vectorBounds) {
        for (int i=0; i<_dimCtrl; i++) {
          double tmpVal;
          file >> tmpVal;
          _upperBound[i]  = tmpVal;
        }
      }
    }
    file.close();
  }
}

Here is the caller graph for this function:

◆ setControl()

template<typename S , typename C >

void olb::opti::Optimizer< S, C >::setControl ( C & control )

inline

Definition at line 152 of file optimizer.h.

                              {
    _control = std::move(control);
  }

References olb::opti::Optimizer< S, C >::_control, and olb::opti::control.

◆ setGnuplotData()

template<typename S , typename C >

void olb::opti::Optimizer< S, C >::setGnuplotData ( )

Definition at line 206 of file optimizer.hh.

{
  std::vector<S> yValues;
  std::vector<std::string> labels;
  std::vector<char> plotTypes;
 
  for(unsigned i = 0; i < _gplotAnalysis.size(); i++){
    if(_gplotAnalysis[i] == value){
      yValues.push_back(_value);
      labels.push_back("value");
      plotTypes.push_back('p');
    } else if(_gplotAnalysis[i] == control){
        // get all entries of control
      for(unsigned j = 0; j< _control.size(); j++){
        yValues.push_back(_control[j]);
        labels.push_back("control[" + std::to_string(j) + "]");
        plotTypes.push_back('p');
      }
    } else if(_gplotAnalysis[i] == derivative){
 
      for(unsigned j = 0; j< _derivative.size(); j++){
        yValues.push_back(_derivative[j]);
        labels.push_back("derivative[" + std::to_string(j) + "]");
        plotTypes.push_back('p');
      }
    } else if(_gplotAnalysis[i] == error){
      yValues.push_back(util::euklidDistance(_control, _referenceControl));
      labels.push_back("control_error");
      plotTypes.push_back('p');
    } else if(_gplotAnalysis[i] == norm_derivative){
      yValues.push_back(util::euklidN(&_derivative[0], _dimCtrl));
      labels.push_back("derivative_norm");
      plotTypes.push_back('p');
    }
  }
  gplot.setData(S(_it), yValues, labels, "top right", plotTypes); // _it is the iterationstep
}

References olb::opti::control, olb::opti::derivative, olb::opti::error, olb::util::euklidDistance(), olb::util::euklidN(), olb::opti::norm_derivative, and olb::opti::value.

Here is the call graph for this function:

◆ setOptiCase()

template<typename S , typename C >

void olb::opti::Optimizer< S, C >::setOptiCase ( OptiCase< S, C > * optiCase )

inline

Definition at line 184 of file optimizer.h.

184{ _optiCase = optiCase; }

References olb::opti::Optimizer< S, C >::_optiCase.

◆ setReferenceControl()

template<typename S , typename C >

void olb::opti::Optimizer< S, C >::setReferenceControl ( C result )

inline

set the reference value for the control vector (exact solution)

Definition at line 189 of file optimizer.h.

                                     {
    _referenceControl = result;
  }

References olb::opti::Optimizer< S, C >::_referenceControl.

◆ setStartValue() [1/2]

template<typename S , typename C >

void olb::opti::Optimizer< S, C >::setStartValue	(	C	startValues,
		S	factor = S(1) )

Definition at line 198 of file optimizer.hh.

{
  std::transform(startValues.begin(), startValues.end(), _control.begin(), [factor](auto s){
    return factor*s;
  });
}

◆ setStartValue() [2/2]

template<typename S , typename C >

void olb::opti::Optimizer< S, C >::setStartValue ( S startValue )

Definition at line 191 of file optimizer.hh.

{
  // update control variables
  std::fill(_control.begin(), _control.end(), startValue);
}

◆ simulate() [1/2]

template<typename S , typename C >

void olb::opti::Optimizer< S, C >::simulate ( )

inline

Definition at line 131 of file optimizer.h.

                  {
    evaluateObjective(_control, _value);
  }

References olb::opti::Optimizer< S, C >::_control, olb::opti::Optimizer< S, C >::_value, and olb::opti::Optimizer< S, C >::evaluateObjective().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ simulate() [2/2]

template<typename S , typename C >

void olb::opti::Optimizer< S, C >::simulate ( OptiCase< S, C > & optiCase )

inline

Definition at line 135 of file optimizer.h.

                                         {
    _optiCase = &optiCase;
    simulate();
  }

References olb::opti::Optimizer< S, C >::_optiCase, and olb::opti::Optimizer< S, C >::simulate().

Here is the call graph for this function:

◆ writeControlToFile()

template<typename S , typename C >

void olb::opti::Optimizer< S, C >::writeControlToFile ( const std::string fname = "control.dat" )

Writes the current control variables linewise into file fname.

Definition at line 141 of file optimizer.hh.

{
  if (singleton::mpi().isMainProcessor() ) {
    std::stringstream stream;
    stream << _dimCtrl << std::endl;
    std::for_each(_control.begin(), _control.end(), [&stream](auto c){ stream << c << '\n'; });
    std::ofstream file;
    file.open(singleton::directories().getLogOutDir() + fname.c_str());
    file << stream.str();
    file.close();
  }
}

References olb::singleton::directories(), and olb::singleton::mpi().

Here is the call graph for this function:

Member Data Documentation

◆ _boundedControl

template<typename S , typename C >

C olb::opti::Optimizer< S, C >::_boundedControl

protected

Definition at line 87 of file optimizer.h.

◆ _control

template<typename S , typename C >

C olb::opti::Optimizer< S, C >::_control

protected

Vector of controlled variables (size _dimCtrl)

Definition at line 65 of file optimizer.h.

◆ _controlEps

template<typename S , typename C >

S olb::opti::Optimizer< S, C >::_controlEps

protected

Definition at line 93 of file optimizer.h.

◆ _controlsConverged

template<typename S , typename C >

bool olb::opti::Optimizer< S, C >::_controlsConverged

protected

For setting tolerance of controls.

Definition at line 92 of file optimizer.h.

◆ _derivative

template<typename S , typename C >

C olb::opti::Optimizer< S, C >::_derivative

protected

Vector of derivatives of the object functional with respect to the controlled variables.

Definition at line 71 of file optimizer.h.

◆ _dimCtrl

template<typename S , typename C >

int olb::opti::Optimizer< S, C >::_dimCtrl

protected

Number of controlled variables.

Definition at line 63 of file optimizer.h.

◆ _eps

template<typename S , typename C >

S olb::opti::Optimizer< S, C >::_eps

protected

Optimizer stops if |_derivatives| < _eps.

Definition at line 79 of file optimizer.h.

◆ _failOnMaxIter

template<typename S , typename C >

bool olb::opti::Optimizer< S, C >::_failOnMaxIter

protected

Fail when max number of iteration reached.

Definition at line 77 of file optimizer.h.

◆ _gplotAnalysis

template<typename S , typename C >

std::vector<OptimizerLogType> olb::opti::Optimizer< S, C >::_gplotAnalysis

For defining what kind of gnuplot analysis is wanted, if empty vector - no analysis, value, control and derivative are the possible options.

Definition at line 106 of file optimizer.h.

◆ _it

template<typename S , typename C >

int olb::opti::Optimizer< S, C >::_it

protected

Current iteration no.

Definition at line 73 of file optimizer.h.

◆ _lowerBound

template<typename S , typename C >

C olb::opti::Optimizer< S, C >::_lowerBound

protected

Definition at line 89 of file optimizer.h.

◆ _maxIt

template<typename S , typename C >

int olb::opti::Optimizer< S, C >::_maxIt

protected

Maximal number of iteration.

Definition at line 75 of file optimizer.h.

◆ _optiCase

template<typename S , typename C >

OptiCase<S,C>* olb::opti::Optimizer< S, C >::_optiCase

protected

Provides the Optimizer with methods to evaluate the value of an object functional and compute derivatives.

Definition at line 97 of file optimizer.h.

◆ _referenceControl

template<typename S , typename C >

C olb::opti::Optimizer< S, C >::_referenceControl

protected

control vector to compare with (for numerical evaluation)

Definition at line 100 of file optimizer.h.

◆ _upperBound

template<typename S , typename C >

C olb::opti::Optimizer< S, C >::_upperBound

protected

Definition at line 88 of file optimizer.h.

◆ _value

template<typename S , typename C >

S olb::opti::Optimizer< S, C >::_value

protected

Value of the objective functional evaluated for controlled variables saved in _control.

Definition at line 68 of file optimizer.h.

◆ _vectorBounds

template<typename S , typename C >

bool olb::opti::Optimizer< S, C >::_vectorBounds

protected

Definition at line 86 of file optimizer.h.

◆ _verboseOn

template<typename S , typename C >

bool olb::opti::Optimizer< S, C >::_verboseOn

protected

Verbose.

Definition at line 81 of file optimizer.h.

◆ _withLowerBound

template<typename S , typename C >

bool olb::opti::Optimizer< S, C >::_withLowerBound

protected

Definition at line 85 of file optimizer.h.

◆ _withUpperBound

template<typename S , typename C >

bool olb::opti::Optimizer< S, C >::_withUpperBound

protected

Bounded versions.

Definition at line 84 of file optimizer.h.

◆ gplot

template<typename S , typename C >

Gnuplot<S> olb::opti::Optimizer< S, C >::gplot

Definition at line 103 of file optimizer.h.

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

src/optimization/core/optimizer.h
src/optimization/core/optimizer.hh

Public Member Functions

Public Attributes

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Optimizer()

◆ ~Optimizer()

Member Function Documentation

◆ computeDerivatives()

◆ evaluateObjective()

◆ getControl()

◆ getDerivative()

◆ getIteration()

◆ getObjective()

◆ getOptiCase()

◆ maxIterationReached()

◆ optimizationStep()

◆ optimize() [1/2]

◆ optimize() [2/2]

◆ print()

◆ readControlFromFile()

◆ setControl()

◆ setGnuplotData()

◆ setOptiCase()

◆ setReferenceControl()

◆ setStartValue() [1/2]

◆ setStartValue() [2/2]

◆ simulate() [1/2]

◆ simulate() [2/2]

◆ writeControlToFile()

Member Data Documentation

◆ _boundedControl

◆ _control

◆ _controlEps

◆ _controlsConverged

◆ _derivative

◆ _dimCtrl

◆ _eps

◆ _failOnMaxIter

◆ _gplotAnalysis

◆ _it

◆ _lowerBound

◆ _maxIt

◆ _optiCase

◆ _referenceControl

◆ _upperBound

◆ _value

◆ _vectorBounds

◆ _verboseOn

◆ _withLowerBound

◆ _withUpperBound

◆ gplot