DianaDynamicNLPTask.hpp

/* -----------------------------------------------------------------------------
 *  Diana process modelling, simulation and analysis software
 *  Copyright (c) 2006, Sergiy Gogolenko
 *  e-mail: gogolenk@mpi-magdeburg.mpg.de
 *  All rights reserved.
 * -----------------------------------------------------------------------------
 *  $Id: DianaDynamicNLPTask.hpp Mon Oct  9 14:49:07 2006 gogolenk $
 * -----------------------------------------------------------------------------
 *  Written under: i586-suse-linux 
 * -----------------------------------------------------------------------------
 *  Last update: Mon Oct  9 14:49:07 2006 
 * -----------------------------------------------------------------------------
 *  Description:
 */
#ifndef DIANADYNAMICNLPTASK_HPP
#define DIANADYNAMICNLPTASK_HPP

#include <CapeOpen.hpp>
#include "DianaNLPTask.hpp"
#include "DianaBasicNLPTask.hpp"

namespace Numeric {
  namespace Solvers {
    namespace NLPTasks {

      enum eEstimatedParameterType {
        DIANA_PARAMETER = 0,
        DIANA_INITSTATE = 1,
        DIANA_FREEPAR   = 2
      };

      // Forward declaration of interface
      class DianaDynamicNLPTask;
      class BasicDynamicNLPTask;

      typedef std::vector<DianaDynamicNLPTask*> ArrayDynamicNLPTask;

      class DianaDynamicNLPTask : virtual public DianaNLPTask, virtual public Numeric::Solvers::NLPTasks::ICapeDynamicOptimizationTask {
      public:
        DianaDynamicNLPTask(Numeric::Solvers::Solver::ICapeNumericSolver* _solver = NULL,
                            Numeric::Solvers::Model::ICapeNumericContinuousModel* _model = NULL);

        virtual ~DianaDynamicNLPTask();

        inline Numeric::Solvers::Model::ICapeNumericContinuousModel* GetModel() 
          throw(Common::Error::ECapeUnknown) { 
          return this->pModel; 
        }

        inline Numeric::Solvers::Solver::ICapeNumericSolver* GetIntegrator() 
          throw(Common::Error::ECapeUnknown) { 
          return this->pSolver; 
        }

      protected:
        virtual void ExtractParams(const Numeric::Solvers::NLPTasks::Parameters::ICapeOptimizationPoint& _parVals)
          throw(Common::Error::ECapeUnknown);

        Common::Types::CapeString makeVarName(Common::Types::CapeString name, int idxAmount, ...) 
          throw (Common::Error::ECapeUnknown);

      protected:
        Numeric::Solvers::Solver::ICapeNumericSolver* pSolver;  
        ICapeNumericContinuousModel* pModel;                    
        Numeric::Solvers::Eso::ICapeNumericESO* pESO;           

        CapeArrayDouble arrDefaultStateVars;                    

        Common::Types::CapeBoolean bUsedExternalModelAndSolver; 
      };

      class BasicDynamicNLPTask : public DianaDynamicNLPTask, public BasicNLPTask {
      public:
        BasicDynamicNLPTask(Numeric::Solvers::Solver::ICapeNumericSolver* _solver, 
                            Numeric::Solvers::Model::ICapeNumericContinuousModel* _model);

        BasicDynamicNLPTask(Diana::IDianaMain* _dianaMain, Common::Types::CapeString _solverName, 
                            Numeric::Solvers::Model::ICapeNumericContinuousModel* _model);

        virtual ~BasicDynamicNLPTask();


        virtual void AddEstimatedParameter(const Common::Parameter::ICapeParameterSpec* pSpecValue, 
                                           eEstimatedParameterType eptTypeOfUnknown = DIANA_PARAMETER)
          throw(Common::Error::ECapeUnknown, Common::Error::ECapeInvalidArgument);

        virtual void AddEstimatedParameter(const Common::Types::CapeString strName, 
                                           eEstimatedParameterType eptTypeOfUnknown = DIANA_PARAMETER)
          throw(Common::Error::ECapeUnknown, Common::Error::ECapeInvalidArgument);

        virtual void AddEstimatedParameter(const Common::Types::CapeLong nIndex, 
                                           eEstimatedParameterType eptTypeOfUnknown = DIANA_PARAMETER)
          throw(Common::Error::ECapeUnknown, Common::Error::ECapeInvalidArgument);

        virtual Common::Types::CapeDouble CalcObjFunction() 
          throw(Common::Error::ECapeUnknown, Common::Error::ECapeSolvingError);

        virtual void Initialize()
          throw (Common::Error::ECapeUnknown, Common::Error::ECapeFailedInitialisation,
                 Common::Error::ECapeOutOfResources, Common::Error::ECapeLicenceError,
                 Common::Error::ECapeBadInvOrder);

        virtual Common::Types::CapeArrayDouble GetObjFunctionGradient() 
          throw(Common::Error::ECapeUnknown);

        Common::Types::CapeLong GetModelParametersCount() const;

        Common::Types::CapeLong GetModelStateVarsCount() const;

        Common::Types::CapeLong GetFreeParametersCount() const;

      protected:
        virtual Common::Types::CapeDouble EvaluateObjFunction() 
          throw(Common::Error::ECapeUnknown, Common::Error::ECapeSolvingError);

        void Init(Diana::IDianaMain* _dianaMain, Common::Types::CapeString _solverName, 
                  Numeric::Solvers::Model::ICapeNumericContinuousModel* _model);

        void Init(Numeric::Solvers::Solver::ICapeNumericSolver* _solver, 
                  Numeric::Solvers::Model::ICapeNumericContinuousModel* _model);

        virtual void ExtractParams(const Numeric::Solvers::NLPTasks::Parameters::ICapeOptimizationPoint& _parVals)
          throw(Common::Error::ECapeUnknown);

      protected:
        /* Lists of unknowns */
        Common::Parameter::CapeArrayParameter arrEstimatedInitStates;   
        Common::Parameter::CapeArrayParameter arrEstimatedParameters;   
        Common::Parameter::CapeArrayParameter arrEstimatedFreeParams;   

        Common::Types::CapeBoolean bInitialized;                        
      };
      
    }
  }
}

#endif