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