optimizer.h

Go to the documentation of this file.

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2012-2016 Mathias J. Krause, Benjamin Förster
 *  E-mail contact: info@openlb.net
 *  The most recent release of OpenLB can be downloaded at
 *  <http://www.openlb.net/>
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public
 *  License along with this program; if not, write to the Free
 *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *  Boston, MA  02110-1301, USA.
*/
 
#ifndef OPTIMIZER_H
#define OPTIMIZER_H
 
#include "optiCase.h"
#include "communication/mpiManager.h"
#include "io/gnuplotWriter.h"
#include "io/xmlReader.h"
#include "core/singleton.h"
 
namespace olb {
 
namespace opti {
 
 
template<typename, typename> class OptiCase;
 
enum OptimizerLogType {control, derivative, value, error, norm_derivative};
 
 
template<typename S, typename C>
class Optimizer {
 
private:
  mutable OstreamManager clout;
 
protected:
  int                                 _dimCtrl;
  C                                   _control;
  S                                   _value;
  C                                   _derivative;
  int                                 _it;
  int                                 _maxIt;
  bool                                _failOnMaxIter;
  S                                   _eps;
  bool                                _verboseOn;
 
  bool                                _withUpperBound;
  bool                                _withLowerBound;
  bool                                _vectorBounds;
  C                                   _boundedControl;
  C                                   _upperBound;
  C                                   _lowerBound;
 
  bool _controlsConverged;
  S _controlEps;
 
  OptiCase<S,C>*                      _optiCase;
 
  C                                   _referenceControl;
 
public:
  Gnuplot<S>                          gplot;
  std::vector<OptimizerLogType>       _gplotAnalysis;
 
  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) {
    _optiCase = &optiCase;
    optimize();
  }
 
  void simulate() {
    evaluateObjective(_control, _value);
  }
 
  void simulate(OptiCase<S,C>& optiCase) {
    _optiCase = &optiCase;
    simulate();
  }
 
  void evaluateObjective(const C& control, S& result) {
    result = _optiCase->evaluateObjective(control, _it);
  }
 
  void computeDerivatives(const C& control, C& derivatives) {
 
    _optiCase->computeDerivatives(control, derivatives, _it);
  }
 
  void print(int it);
 
  void setControl(C& control) {
    _control = std::move(control);
  }
 
  const C& getControl() const {
    return _control;
  }
 
  const C& getDerivative() const {
    return _derivative;
  }
 
  const S& getObjective() const {
    return _value;
  }
 
  int getIteration() const {
    return _it;
  }
 
  void writeControlToFile(const std::string fname="control.dat");
 
  void readControlFromFile(const std::string fname="control.dat");
 
  void setStartValue(S startValue);
 
  OptiCase<S,C>* getOptiCase() { return _optiCase; }
 
  void setOptiCase(OptiCase<S,C>* optiCase) { _optiCase = optiCase; }
 
  void setGnuplotData();
 
  void setReferenceControl(C result) {
    _referenceControl = result;
  }
};
 
void getGnuplotTagsFromString(std::string gplotAnalysisString, std::vector<OptimizerLogType>& gplotAnalysis );
 
 
 
 
 
// Work in progress: Attempt to refactor the optimizer classes in the
// style of the solver architecture: separate parameter structs and algorithms.
/*
template <typename S>
struct OptimizationParameters
{
 private:
  OstreamManager                      clout {std::cout, "OptimizationParameters"};
 
 public:
  int                                 _maxIt;
  bool                                _failOnMaxIter {true};
  S                                   _eps;
  bool                                _verboseOn;
 
  bool                                _withUpperBound;
  bool                                _withLowerBound;
  bool                                _vectorBounds;
  S*                                  _boundedControl;
  S*                                  _upperBound;
  S*                                  _lowerBound;
 
  S                                   _controlEps;
 
  explicit OptimizationParameters(XMLreader *xml);
};
 
template <typename S>
OptimizationParameters<S>::OptimizationParameters(XMLreader *xml)
{
 
}
 
 
template<typename T>
class OptimizerBase
{
 private:
  mutable OstreamManager clout;
 
 protected:
  OptimizationParameters<T>              _optiParam;
 
  std::shared_ptr<Controller<T>>      _controller;
 
  std::unique_ptr<OptiCase<T>>        _optiCase;
 
  T                                   objectiveValue;
  std::vector<T>                      _derivativeObjective;
 
  int                                 _it {0};
 
  bool                                _controlsConverged {false};
 
 
  OptiCase<T>*                        _optiCase;
 
public:
  NewOptimizer();
 
  virtual void optimizationStep() = 0;
 
  void maxIterationReached();
 
  virtual void optimize(OptiCase<T>* optiCase);
 
  void evaluate(OptiCase<T>* optiCase)
  {
    optiCase->evaluateObjective(_control);
  }
};
*/
 
 
} // namespace opti
 
} // namespace olb
 
#endif