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.
//
// $Id: IpIpoptApplication.hpp 2690 2017-06-12 10:28:36Z stefan $
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13

#ifndef __IPIPOPTAPPLICATION_HPP__
#define __IPIPOPTAPPLICATION_HPP__

#ifndef IPOPT_EXPORT
#ifdef _MSC_VER
#ifdef IPOPT_DLL
#define IPOPT_EXPORT(type) __declspec(dllexport) type __cdecl
#else
#define IPOPT_EXPORT(type) type __cdecl
#endif
#else
#define IPOPT_EXPORT(type) type
#endif
#endif

#include <iostream>

#include "IpJournalist.hpp"
#include "IpTNLP.hpp"
#include "IpNLP.hpp"
/* Return codes for the Optimize call for an application */
#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 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);

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

    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" IPOPT_EXPORT(class Ipopt::IpoptApplication *) IpoptApplicationFactory();

#endif