IpAlgBuilder.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2007 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// $Id: IpAlgBuilder.hpp 2666 2016-07-20 16:02:55Z stefan $
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-09-29

#ifndef __IPALGBUILDER_HPP__
#define __IPALGBUILDER_HPP__

#include "IpIpoptAlg.hpp"
#include "IpReferenced.hpp"
#include "IpAugSystemSolver.hpp"
#include "IpPDSystemSolver.hpp"

namespace Ipopt
{

  // forward declarations
  class IterationOutput;
  class HessianUpdater;
  class ConvergenceCheck;
  class SearchDirectionCalculator;
  class EqMultiplierCalculator;
  class IterateInitializer;
  class LineSearch;
  class MuUpdate;

  class AlgorithmBuilder : public ReferencedObject
  {
  public:
    AlgorithmBuilder(SmartPtr<AugSystemSolver> custom_solver=NULL);

    virtual ~AlgorithmBuilder()
    {}


    static void RegisterOptions(SmartPtr<RegisteredOptions> roptions);


    virtual SmartPtr<SymLinearSolver>
        SymLinearSolverFactory(const Journalist& jnlst,
                               const OptionsList& options,
                               const std::string& prefix);

    SmartPtr<SymLinearSolver> GetSymLinearSolver(const Journalist& jnlst,
                                                 const OptionsList& options,
                                                 const std::string& prefix);

    virtual SmartPtr<AugSystemSolver>
        AugSystemSolverFactory(const Journalist& jnlst,
                               const OptionsList& options,
                               const std::string& prefix);

    SmartPtr<AugSystemSolver> GetAugSystemSolver(const Journalist& jnlst,
                                                 const OptionsList& options,
                                                 const std::string& prefix);

    virtual SmartPtr<PDSystemSolver>
        PDSystemSolverFactory(const Journalist& jnlst,
                              const OptionsList& options,
                              const std::string& prefix);

    SmartPtr<PDSystemSolver> GetPDSystemSolver(const Journalist& jnlst,
                                               const OptionsList& options,
                                               const std::string& prefix);

    virtual void BuildIpoptObjects(const Journalist& jnlst,
                                   const OptionsList& options,
                                   const std::string& prefix,
                                   const SmartPtr<NLP>& nlp,
                                   SmartPtr<IpoptNLP>& ip_nlp,
                                   SmartPtr<IpoptData>& ip_data,
                                   SmartPtr<IpoptCalculatedQuantities>& ip_cq);

    virtual SmartPtr<IpoptAlgorithm> BuildBasicAlgorithm(const Journalist& jnlst,
        const OptionsList& options,
        const std::string& prefix);

    virtual SmartPtr<IterationOutput>
        BuildIterationOutput(const Journalist& jnlst,
                             const OptionsList& options,
                             const std::string& prefix);

    virtual SmartPtr<HessianUpdater>
        BuildHessianUpdater(const Journalist& jnlst,
                            const OptionsList& options,
                            const std::string& prefix);

    virtual SmartPtr<ConvergenceCheck>
        BuildConvergenceCheck(const Journalist& jnlst,
                              const OptionsList& options,
                              const std::string& prefix);

     virtual SmartPtr<SearchDirectionCalculator>
        BuildSearchDirectionCalculator(const Journalist& jnlst,
                                       const OptionsList& options,
                                       const std::string& prefix);

    virtual SmartPtr<EqMultiplierCalculator>
        BuildEqMultiplierCalculator(const Journalist& jnlst,
                                    const OptionsList& options,
                                    const std::string& prefix);

    virtual SmartPtr<IterateInitializer>
        BuildIterateInitializer(const Journalist& jnlst,
                                const OptionsList& options,
                                const std::string& prefix);

    virtual SmartPtr<LineSearch> BuildLineSearch(const Journalist& jnlst,
                                                 const OptionsList& options,
                                                 const std::string& prefix);

    virtual SmartPtr<MuUpdate> BuildMuUpdate(const Journalist& jnlst,
                                             const OptionsList& options,
                                             const std::string& prefix);

  private:
    //AlgorithmBuilder();

    AlgorithmBuilder(const AlgorithmBuilder&);

    void operator=(const AlgorithmBuilder&);

    SmartPtr<IterationOutput> IterOutput_;
    SmartPtr<HessianUpdater> HessUpdater_;
    SmartPtr<ConvergenceCheck> ConvCheck_;
    SmartPtr<SearchDirectionCalculator> SearchDirCalc_;
    SmartPtr<EqMultiplierCalculator> EqMultCalculator_;
    SmartPtr<IterateInitializer> IterInitializer_;
    SmartPtr<LineSearch> LineSearch_;
    SmartPtr<MuUpdate> MuUpdate_;

    SmartPtr<SymLinearSolver> SymSolver_;
    SmartPtr<AugSystemSolver> AugSolver_;
    SmartPtr<PDSystemSolver> PDSolver_;

    SmartPtr<AugSystemSolver> custom_solver_;

  };
} // namespace Ipopt

#endif