IpIpoptApplication.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2010 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13

#ifndef __IPIPOPTAPPLICATION_HPP__
#define __IPIPOPTAPPLICATION_HPP__

#include <iostream>

#include "IpJournalist.hpp"
#include "IpTNLP.hpp"
#include "IpNLP.hpp"
#include "IpReturnCodes.hpp"

namespace Ipopt
{
DECLARE_STD_EXCEPTION(IPOPT_APPLICATION_ERROR);

/* forward declarations */
class IpoptAlgorithm;
class IpoptNLP;
class IpoptData;
class IpoptCalculatedQuantities;
class AlgorithmBuilder;
class RegisteredOptions;
class OptionsList;
class SolveStatistics;

class IPOPTLIB_EXPORT IpoptApplication: public ReferencedObject
{
public:
   IpoptApplication(
      bool create_console_out = true,
      bool create_empty = false
   );

   IpoptApplication(
      SmartPtr<RegisteredOptions> reg_options,
      SmartPtr<OptionsList>       options,
      SmartPtr<Journalist>        jnlst
   );

   virtual ~IpoptApplication();

   virtual SmartPtr<IpoptApplication> clone();

   virtual ApplicationReturnStatus Initialize(
      std::istream& is,
      bool          allow_clobber = false
   );

   virtual ApplicationReturnStatus Initialize(
      std::string params_file,
      bool        allow_clobber = false
   );

   virtual ApplicationReturnStatus Initialize(
      const char* params_file,
      bool        allow_clobber = false
   )
   {
      return Initialize(std::string(params_file), allow_clobber);
   }

   virtual ApplicationReturnStatus Initialize(
      bool allow_clobber = false
   );


   virtual ApplicationReturnStatus OptimizeTNLP(
      const SmartPtr<TNLP>& tnlp
   );

   virtual ApplicationReturnStatus OptimizeNLP(
      const SmartPtr<NLP>& nlp
   );

   virtual ApplicationReturnStatus OptimizeNLP(
      const SmartPtr<NLP>&        nlp,
      SmartPtr<AlgorithmBuilder>& alg_builder
   );

   virtual ApplicationReturnStatus ReOptimizeTNLP(
      const SmartPtr<TNLP>& tnlp
   );

   virtual ApplicationReturnStatus ReOptimizeNLP(
      const SmartPtr<NLP>& nlp
   );

   virtual bool OpenOutputFile(
      std::string   file_name,             
      EJournalLevel print_level,           
      bool          file_append = false    
   );


   virtual SmartPtr<Journalist> Jnlst()
   {
      return jnlst_;
   }

   virtual SmartPtr<RegisteredOptions> RegOptions()
   {
      return reg_options_;
   }

   virtual SmartPtr<OptionsList> Options()
   {
      return options_;
   }

   virtual SmartPtr<const OptionsList> Options() const
   {
      return ConstPtr(options_);
   }

   virtual SmartPtr<SolveStatistics> Statistics();

   virtual SmartPtr<IpoptNLP> IpoptNLPObject();

   SmartPtr<IpoptData> IpoptDataObject();

   virtual SmartPtr<IpoptCalculatedQuantities> IpoptCQObject();

   SmartPtr<IpoptAlgorithm> AlgorithmObject();

   void PrintCopyrightMessage();

   bool RethrowNonIpoptException(
      bool dorethrow
   )
   {
      bool oldval = rethrow_nonipoptexception_;
      rethrow_nonipoptexception_ = dorethrow;
      return oldval;
   }

   static void RegisterOptions(
      SmartPtr<RegisteredOptions> roptions
   );

   static void RegisterAllIpoptOptions(
      const SmartPtr<RegisteredOptions>& roptions
   );

   static void Version(
      int& major,   
      int& minor,   
      int& release  
   );

private:

   IpoptApplication(
      const IpoptApplication&
   );

   void operator=(
      const IpoptApplication&
   );

   ApplicationReturnStatus call_optimize();


   bool read_params_dat_;

   bool rethrow_nonipoptexception_;

   SmartPtr<Journalist> jnlst_;

   SmartPtr<RegisteredOptions> reg_options_;

   SmartPtr<OptionsList> options_;

   SmartPtr<SolveStatistics> statistics_;

   SmartPtr<IpoptAlgorithm> alg_;

   SmartPtr<IpoptNLP> ip_nlp_;

   SmartPtr<IpoptData> ip_data_;

   SmartPtr<IpoptCalculatedQuantities> ip_cq_;

   SmartPtr<NLP> nlp_adapter_;


   bool inexact_algorithm_;

   bool replace_bounds_;
};

} // namespace Ipopt

extern "C" IPOPTLIB_EXPORT class Ipopt::IpoptApplication* IPOPT_CALLCONV IpoptApplicationFactory();

#endif