reducedprobleminterface.h

Go to the documentation of this file.

#ifndef SOLVER_INTERFACE_H_
#define SOLVER_INTERFACE_H_

#include "dopeexceptionhandler.h"
#include "outputhandler.h"
#include "controlvector.h"
#include "constraintvector.h"
#include "dopetypes.h"
#include "dwrdatacontainer.h"

#include <assert.h>
#include <numerics/data_out.h>

#include <lac/vector.h>

namespace DOpE
{
  //Predeclaration necessary
  template<typename VECTOR>
    class DOpEOutputHandler;
  template<typename VECTOR>
    class DOpEExceptionHandler;

  template<typename VECTOR>
    class ReducedProblemInterface_Base
    {
      public:
        ReducedProblemInterface_Base()
        {
          ExceptionHandler_ = NULL;
          OutputHandler_ = NULL;
        }

        virtual
        ~ReducedProblemInterface_Base()
        {
        }
        ;
        virtual void
        StateSizeInfo(std::stringstream& out)=0;

        /******************************************************/

        virtual void
        WriteToFile(const VECTOR &v, std::string name, std::string outfile,
            std::string dof_type, std::string filetype)=0;

        /******************************************************/

        virtual void
        WriteToFileElementwise(const Vector<double> &/*v*/, std::string /*name*/,
            std::string /*outfile*/, std::string /*dof_type*/,
            std::string /*filetype*/)
        {
          throw DOpEException("NotImplemented", "WriteToFileElementwise");
        }

        /******************************************************/

        virtual void
        WriteToFile(const ControlVector<VECTOR> &v, std::string name,
                    std::string dof_type)=0;

        /******************************************************/

        virtual void
        WriteToFile(const std::vector<double> &v, std::string outfile) =0;

        void
        RegisterOutputHandler(DOpEOutputHandler<VECTOR>* OH)
        {
          OutputHandler_ = OH;
        }
        void
        RegisterExceptionHandler(DOpEExceptionHandler<VECTOR>* OH)
        {
          ExceptionHandler_ = OH;
        }

        DOpEExceptionHandler<VECTOR>*
        GetExceptionHandler()
        {
          assert(ExceptionHandler_);
          return ExceptionHandler_;
        }
        DOpEOutputHandler<VECTOR>*
        GetOutputHandler()
        {
          assert(OutputHandler_);
          return OutputHandler_;
        }

        double
        GetFunctionalValue(std::string name) const
        {
          typename std::map<std::string, unsigned int>::const_iterator it =
              GetFunctionalPosition().find(name);
          if (it == GetFunctionalPosition().end())
          {
            throw DOpEException(
                "Did not find " + name + " in the list of functionals.",
                "ReducedProblemInterface_Base::GetFunctionalValue");
          }
          unsigned int pos = it->second;

          if (GetFunctionalValues()[pos].size() != 1)
          {
            if (GetFunctionalValues()[0].size() == 0)
              throw DOpEException(
                  "Apparently the Functional in question was never evaluated!",
                  "ReducedProblemInterface_Base::GetFunctionalValue");
            else
              throw DOpEException(
                  "The Functional has been evaluated too many times! \n\tMaybe you should use GetTimeFunctionalValue.",
                  "ReducedProblemInterface_Base::GetFunctionalValue");

          }
          else
          {
            return GetFunctionalValues()[pos][0];
          }
        }

        const std::vector<double>&
        GetTimeFunctionalValue(std::string name) const
        {
          typename std::map<std::string, unsigned int>::const_iterator it =
              GetFunctionalPosition().find(name);
          if (it == GetFunctionalPosition().end())
          {
            throw DOpEException(
                "Did not find " + name + " in the list of functionals.",
                "ReducedProblemInterface_Base::GetFunctionalValue");
          }
          unsigned int pos = it->second;

          if (GetFunctionalValues()[pos].size != 1)
          {
            if (GetFunctionalValues()[0].size() == 0)
              throw DOpEException(
                  "Apparently the Functional in question was never evaluated!",
                  "ReducedProblemInterface_Base::GetTimeFunctionalValue");
            else
              throw DOpEException(
                  "The Functional has been evaluated too many times! \n\tMaybe you should use GetTimeFunctionalValue.",
                  "ReducedProblemInterface_Base::GetTimeFunctionalValue");
          }
          else
          {
            return GetFunctionalValues()[pos];
          }
        }


        void AddUserDomainData(std::string name,const VECTOR* new_data)
        {
          if (user_domain_data_.find(name) != user_domain_data_.end())
          {
            throw DOpEException(
                "Adding multiple Data with name " + name + " is prohibited!",
                "ReducedProblemInterface::AddUserDomainData");
          }
          user_domain_data_.insert(
              std::pair<std::string, const VECTOR*>(name, new_data));
        }


        void DeleteUserDomainData(
            std::string name)
        {
          typename std::map<std::string, const VECTOR *>::iterator it =
              user_domain_data_.find(name);
          if (it == user_domain_data_.end())
          {
            throw DOpEException(
                "Deleting Data " + name + " is impossible! Data not found",
                "Integrator::DeleteDomainData");
          }
          user_domain_data_.erase(it);
        }
      protected:
        void
        InitializeFunctionalValues(unsigned int N)
        {
          //Initializing Functional Values
          GetFunctionalValues().resize(N);
          for (unsigned int i = 0; i < GetFunctionalValues().size(); i++)
          {
            GetFunctionalValues()[i].resize(0);
          }
        }
        std::vector<std::vector<double> >&
        GetFunctionalValues()
        {
          return functional_values_;
        }

        const std::vector<std::vector<double> >&
        GetFunctionalValues() const
        {
          return functional_values_;
        }

        const std::map<std::string, const VECTOR*>&
        GetUserDomainData() const
        {
          return user_domain_data_;
        }

        virtual const std::map<std::string, unsigned int>&
        GetFunctionalPosition() const
        {
          throw DOpEException("Method not implemented",
              "ReducedProblemInterface_Base::GetFunctionalPosition");
        }
        ;

      private:
        DOpEExceptionHandler<VECTOR>* ExceptionHandler_;
        DOpEOutputHandler<VECTOR>* OutputHandler_;
        std::vector<std::vector<double> > functional_values_;
        std::map<std::string, const VECTOR*> user_domain_data_;
    };

  template<typename PROBLEM, typename VECTOR>
    class ReducedProblemInterface : public ReducedProblemInterface_Base<VECTOR>
    {
      public:
        ReducedProblemInterface(PROBLEM *OP, int base_priority = 0)
            : ReducedProblemInterface_Base<VECTOR>()
        {
          OP_ = OP;
          base_priority_ = base_priority;
          post_index_ = "_" + this->GetProblem()->GetName();
        }
        ~ReducedProblemInterface()
        {
        }

        /******************************************************/

        virtual void
        ReInit()
        {
          this->GetProblem()->ReInit("reduced");
        }

        /******************************************************/

        virtual bool
        ComputeReducedConstraints(const ControlVector<VECTOR>& q,
            ConstraintVector<VECTOR>& g) = 0;

        /******************************************************/

        virtual void
        GetControlBoxConstraints(ControlVector<VECTOR>& lb,
            ControlVector<VECTOR>& ub)= 0;

        /******************************************************/

        virtual void
        ComputeReducedGradient(const ControlVector<VECTOR>& q,
            ControlVector<VECTOR>& gradient,
            ControlVector<VECTOR>& gradient_transposed)=0;

        /******************************************************/

        virtual double
        ComputeReducedCostFunctional(const ControlVector<VECTOR>& q)=0;

        /******************************************************/

        virtual void
        ComputeReducedFunctionals(const ControlVector<VECTOR>& q)=0;

        /******************************************************/

        virtual void
        ComputeReducedHessianVector(const ControlVector<VECTOR>& q,
            const ControlVector<VECTOR>& direction,
            ControlVector<VECTOR>& hessian_direction,
            ControlVector<VECTOR>& hessian_direction_transposed)=0;

        virtual void
        ComputeReducedHessianInverseVector(const ControlVector<VECTOR>& /*q*/,
                                           const ControlVector<VECTOR>& /*direction*/,
                                           ControlVector<VECTOR>&       /*hessian_direction*/)
        {
          throw DOpEException("Method not implemented",
              "ReducedProblemInterface::ComputeReducedHessianInverseVector");
        }

        virtual void
        ComputeReducedGradientOfGlobalConstraints(unsigned int /*num*/,
                                                  const ControlVector<VECTOR>& /*q*/,
                                                  const ConstraintVector<VECTOR>& /*g*/,
                                                  ControlVector<VECTOR>& /*gradient*/,
                                                  ControlVector<VECTOR>& /*gradient_transposed*/)

        {
          throw DOpEException("Method not implemented",
              "ReducedProblemInterface::ComputeReducedGradientOfGlobalConstraints");
        }

        /*****************************************************/
        void
        SetProblemType(std::string type, unsigned int num = 0)
        {
          this->GetProblem()->SetType(type, num);
        }
        PROBLEM*
        GetProblem()
        {
          return OP_;
        }

        const PROBLEM*
        GetProblem() const
        {
          return OP_;
        }
        template<class DWRC>
          void
          InitializeDWRC(DWRC& dwrc)
          {
            dwrc.Initialize(GetProblem()->GetSpaceTimeHandler(),
                GetProblem()->GetControlNBlocks(),
                GetProblem()->GetControlBlockComponent(),
                GetProblem()->GetStateNBlocks(),
                GetProblem()->GetStateBlockComponent());
          }

      protected:
        virtual const std::map<std::string, unsigned int>&
        GetFunctionalPosition() const
        {
          return GetProblem()->GetFunctionalPosition();
        }
        std::string
        GetPostIndex() const
        {
          return post_index_;
        }
        int
        GetBasePriority() const
        {
          return base_priority_;
        }
      private:
        PROBLEM* OP_;
        int base_priority_;
        std::string post_index_;
    };

}
#endif