optiCaseDual.h

Go to the documentation of this file.

/*  This file is part of the OpenLB library
*
*  Copyright (C) 2012-2021 Mathias J. Krause, Benjamin Förster, Julius Jeßberger
*  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 OPTI_CASE_DUAL_H
#define OPTI_CASE_DUAL_H
 
#include "io/xmlReader.h"
 
#include "adjointLbSolver.h"
#include "controller.h"
#include "optiCase.h"
#include "projection.h"
#include "serialization.h"
 
namespace olb {
 
namespace opti {
 
enum ControlType {ForceControl, PorosityControl};
 
template<
  typename S,
  template<typename,SolverMode> typename SOLVER,
  typename C = std::vector<S>>
class OptiCaseDual : public OptiCase<S,C> {
 
private:
  mutable OstreamManager                           clout {std::cout, "OptiCaseDual"};
  using descriptor = typename SOLVER<S,SolverMode::Reference>::AdjointLbSolverBase::DESCRIPTOR;
  static constexpr int dim = descriptor::d;
 
public:
  bool                                             _verbose {true};
  std::size_t                                      _dimCtrl;
 
  ControlType                                      _controlType;
  StartValueType                                   _startValueType {Control};
  std::string                                      _projectionName;
 
  int                                              _fieldDim;
  int                                              _controlMaterial;
  S                                                _regAlpha {0};
 
  Controller<S>*                                   _controller {nullptr};
  UnitConverter<S,descriptor>*                     _converter {nullptr};
  std::shared_ptr<SOLVER<S,SolverMode::Primal>>    _primalSolver;
  std::shared_ptr<SOLVER<S,SolverMode::Dual>>      _dualSolver;
  std::shared_ptr<SOLVER<S,SolverMode::Reference>> _referenceSolver;
 
  bool                                             _computeReference {false};
  std::shared_ptr<SuperGeometry<S,dim>>            _referenceGeometry;
  std::shared_ptr<SuperLattice<S,descriptor>>      _referenceLattice;
 
  std::shared_ptr<GeometrySerializer<S,dim>>       _serializer;
  std::shared_ptr<projection::Base<S>>             _projection;
  std::shared_ptr<SuperLatticeF<S,descriptor>>     _projectedControl;
  std::shared_ptr<SuperLatticeF<S,descriptor>>     _dProjectionDcontrol;
 
  OptiCaseDual(XMLreader const& xml) {
    readFromXML(xml);
    initialize(xml);
    initializeFields();
  }
 
  ~OptiCaseDual() {
    free();
  }
 
  void free() {
    delete _converter;
    _converter = nullptr;
    delete _controller;
    _controller = nullptr;
  }
 
  S evaluateObjective(const C& control, unsigned optiStep=0) override;
 
  void computeDerivatives(
    const C& control, C& derivatives, unsigned optiStep=0) override;
 
  // get the control values as they were computed in the reference solution
  // only ForceControl & without projection is implemented so far
  C getReferenceControl() const;
 
private:
  void readFromXML(XMLreader const& xml);
 
  void initialize(XMLreader const& xml);
 
  void initializeFields();
 
  void derivativesFromDualSolution(C& derivatives);
 
};
 
 
}
 
}
 
#endif