DianaOEDTask.hpp

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

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

#include "DianaSolver.hpp"
//#include "DianaParameterFittingTask.hpp"


namespace Numeric {
  namespace Solvers {
    namespace NLPTasks {

      class DianaParameterFittingTask;

      namespace OED {

        // Forward declaration of interface
        class DianaOEDTask;
        class OEDOptimalityCriterion;

        typedef std::vector<DianaOEDTask*> ArrayOEDTask;

        enum OEDOptimalityCriterionType {
          DIANA_OED_A,          
          DIANA_OED_D,          
          DIANA_OED_M,          
          DIANA_OED_E,          
          DIANA_OED_EStar,      
          DIANA_OED_USER        
        };

        class DianaOEDTask : public Numeric::Solvers::NLPTasks::DianaNLPTask {
        public:
          DianaOEDTask(Numeric::Solvers::NLPTasks::DianaParameterFittingTask* pParFitTask,
                       Numeric::Solvers::Solver::ICapeNumericNLPSolver* pOptimizer,
                       const Common::Parameter::CapeArrayParameterSpec& colDesignVars)
            throw(Common::Error::ECapeUnknown);

          ~DianaOEDTask();

          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);

          void SetOptimalityCriterion(/*OEDOptimalityCriterion*/Numeric::Solvers::NLPTasks::ICapeNLPFunction* func)
            throw(Common::Error::ECapeUnknown);

          const Common::Types::CapeArrayDouble& GetParametersBiasEstimate() const
            throw(Common::Error::ECapeUnknown);

          const Diana::DianaArray& GetCovarianceMatrixEstimate() const
            throw(Common::Error::ECapeUnknown);

          Numeric::Solvers::NLPTasks::DianaParameterFittingTask* GetParameterFttingTask()
            throw(Common::Error::ECapeUnknown);

          Numeric::Solvers::Solver::ICapeNumericSolver* GetPFOptimizer()
            throw(Common::Error::ECapeUnknown);

          Numeric::Solvers::NLPTasks::ICapeNLPFunction* GetOptimalityCriterion()// const
            throw(Common::Error::ECapeUnknown);

          inline Common::Collection::ICapeCollection* GetDesignVariables()
            throw (Common::Error::ECapeUnknown, Common::Error::ECapeFailedInitialisation, Common::Error::ECapeNoImpl)
          { return &(this->collDesignVars); }

          inline Common::Collection::ICapeCollection* GetEstimatedParameters()
            throw (Common::Error::ECapeUnknown, Common::Error::ECapeFailedInitialisation, Common::Error::ECapeNoImpl)
          { return &(this->collEstimatedPars); }

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

        protected:
          Numeric::Solvers::NLPTasks::DianaParameterFittingTask* pParFitTask; 
          Numeric::Solvers::Solver::ICapeNumericNLPSolver* pParFitOptimizer;  

          OEDOptimalityCriterion* pOptCriterion;        
          OEDOptimalityCriterionType eOptimalityCriterionType;  

          Diana::DianaCollection collDesignVars;                        
          Diana::DianaCollection collEstimatedPars;                     

          Common::Types::CapeBoolean bInitialized;                      

          Diana::DianaArray daCovMatrix;                                
          Common::Types::CapeArrayDouble arrBias;                       
        };

        


        class OEDOptimalityCriterion : public Numeric::Solvers::NLPTasks::ICapeNLPFunction {
        public:
          OEDOptimalityCriterion();

          OEDOptimalityCriterion(const Numeric::Solvers::NLPTasks::ICapeNLPFunction& func);

          virtual Common::Types::CapeDouble Exec(Numeric::Solvers::NLPTasks::ICapeNLPTask& task) 
            throw (Common::Error::ECapeSolvingError) = 0;

          virtual const Common::Types::CapeString& GetComponentName() const
            throw (Common::Error::ECapeUnknown);

          virtual void SetComponentName(const Common::Types::CapeString& _name)
            throw (Common::Error::ECapeUnknown, Common::Error::ECapeInvalidArgument);

          virtual const Common::Types::CapeString& GetComponentDescription() const
            throw (Common::Error::ECapeUnknown);

          virtual void SetComponentDescription(const Common::Types::CapeString& _description)
            throw (Common::Error::ECapeUnknown, Common::Error::ECapeInvalidArgument);

        private:
          Common::Types::CapeString strName;        
          Common::Types::CapeString strDescription; 
        };



#ifndef SWIG

        typedef Common::Types::CapeDouble (*COEDOptimalityFunction)(DianaOEDTask& task);

        class CFuncOEDOptimalityCriterion : public OEDOptimalityCriterion {
        public:
          CFuncOEDOptimalityCriterion(COEDOptimalityFunction pFuncCOEDOptCriterion);

          virtual Common::Types::CapeDouble Exec(Numeric::Solvers::NLPTasks::ICapeNLPTask& task) 
            throw (Common::Error::ECapeSolvingError);

          virtual ICapeIdentification* clone()
            throw (Common::Error::ECapeUnknown, Common::Error::ECapeNoImpl);

        private:
          COEDOptimalityFunction pFuncCOEDOptCriterion; 
        };
#endif
      }
    }
  }
}

#endif