SensApplication.hpp

Go to the documentation of this file.

// Copyright 2009, 2011 Hans Pirnay
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Date   : 2009-05-06
 
#ifndef __SENSAPPLICATION_HPP__
#define __SENSAPPLICATION_HPP__
 
#include "IpReferenced.hpp"
#include "SensUtils.hpp"
#include "SensUtils.hpp"
#include "SensAlgorithm.hpp"
#include "IpRegOptions.hpp"
 
#include "IpIpoptApplication.hpp"
#include "IpPDSystemSolver.hpp"
 
#include "IpSmartPtr.hpp"
 
namespace Ipopt
{
DECLARE_STD_SIPOPT_EXCEPTION(SENS_SUFFIX_ERROR);
 
class SIPOPTLIB_EXPORT SensApplication: public ReferencedObject
{
public:
   // constructor
   SensApplication(
      SmartPtr<Journalist>        jnlst,
      SmartPtr<OptionsList>       options,
      SmartPtr<RegisteredOptions> reg_options
   );
 
   ~SensApplication();
 
   static void RegisterOptions(
      SmartPtr<RegisteredOptions> roptions
   );
 
   SensAlgorithmExitStatus Run();
 
   void Initialize();
 
   void SetIpoptAlgorithmObjects(
      SmartPtr<IpoptApplication> app_ipopt,
      ApplicationReturnStatus    ipopt_retval
   );
 
   SmartPtr<Journalist> Jnlst()
   {
      return jnlst_;
   }
 
   SmartPtr<OptionsList> Options()
   {
      return options_;
   }
 
   SmartPtr<const OptionsList> Options() const
   {
      return ConstPtr(options_);
   }
 
   void GetDirectionalDerivatives(
      Number* SX,
      Number* SL,
      Number* SZL,
      Number* SZU
   )
   {
      if( GetRawPtr(controller) != NULL && NULL != DirectionalD_X && NULL != DirectionalD_Z_L
          && NULL != DirectionalD_Z_U && NULL != DirectionalD_L )
      {
 
         for( Index i = 0; i < controller->nx(); ++i )
         {
            SX[i] = DirectionalD_X[i];
         }
         for( Index i = 0; i < controller->nzu(); ++i )
         {
            SZU[i] = DirectionalD_Z_U[i];
         }
         for( Index i = 0; i < controller->nzl(); ++i )
         {
            SZL[i] = DirectionalD_Z_L[i];
         }
         for( Index i = 0; i < controller->nl(); ++i )
         {
            SL[i] = DirectionalD_L[i];
         }
      }
   }
 
   void GetSensitivityMatrix(
      Number* SX,
      Number* SL,
      Number* SZL,
      Number* SZU
   )
   {
      if( GetRawPtr(controller) != NULL && NULL != SensitivityM_X && NULL != SensitivityM_Z_L
          && NULL != SensitivityM_Z_U && NULL != SensitivityM_L )
      {
         for( Index i = 0; i < controller->nx() * controller->np(); ++i )
         {
            SX[i] = SensitivityM_X[i];
         }
         for( Index i = 0; i < controller->nzu() * controller->np(); ++i )
         {
            SZU[i] = SensitivityM_Z_U[i];
         }
         for( Index i = 0; i < controller->nzl() * controller->np(); ++i )
         {
            SZL[i] = SensitivityM_Z_L[i];
         }
         for( Index i = 0; i < controller->nl() * controller->np(); ++i )
         {
            SL[i] = SensitivityM_L[i];
         }
 
      }
   }
 
   Index nx()
   {
      return (GetRawPtr(controller) != NULL) ? controller->nx() : -1;
   }
   Index nl()
   {
      return (GetRawPtr(controller) != NULL) ? controller->nl() : -1;
   }
   Index nzu()
   {
      return (GetRawPtr(controller) != NULL) ? controller->nzu() : -1;
   }
   Index nzl()
   {
      return (GetRawPtr(controller) != NULL) ? controller->nzl() : -1;
   }
   Index np()
   {
      return (GetRawPtr(controller) != NULL) ? controller->np() : -1;
   }
 
   /* place holders to keep the values of the directional derivatives for each type of variable */
   Number* DirectionalD_X;
   Number* DirectionalD_L;
   Number* DirectionalD_Z_L;
   Number* DirectionalD_Z_U;
 
   /* place holders to keep the values of ds/dp for each type of variable */
   Number* SensitivityM_X;
   Number* SensitivityM_L;
   Number* SensitivityM_Z_L;
   Number* SensitivityM_Z_U;
 
private:
   // standard constructor just so it can't be used
   //    SensApplication();
 
   // Pointers that are immediately passed from Ipopt and initialized by the constructor
   SmartPtr<Journalist> jnlst_;
   SmartPtr<OptionsList> options_;
   SmartPtr<IpoptData> ip_data_;
   SmartPtr<IpoptCalculatedQuantities> ip_cq_;
   SmartPtr<PDSystemSolver> pd_solver_;
   SmartPtr<IpoptNLP> ip_nlp_;
   SmartPtr<RegisteredOptions> reg_options_;
   ApplicationReturnStatus ipopt_retval_;
 
   SmartPtr<SensAlgorithm> controller;
 
   bool run_sens_;
   bool compute_red_hessian_;
   bool compute_dsdp_;
   Index n_sens_steps_;
};
 
}
 
#endif