MoochoPack_MoochoSolver.hpp

// @HEADER
// ***********************************************************************
// 
// Moocho: Multi-functional Object-Oriented arCHitecture for Optimization
//                  Copyright (2003) Sandia Corporation
// 
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
// 
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//  
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//  
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact Roscoe A. Bartlett (rabartl@sandia.gov) 
// 
// ***********************************************************************
// @HEADER

#ifndef MOOCHOPACK_MOOCHO_SOLVER_HPP
#define MOOCHOPACK_MOOCHO_SOLVER_HPP

#include "MoochoPack_Types.hpp"
#include "MoochoPack_NLPAlgoContainer.hpp"
#include "OptionsFromStreamPack_CommandLineOptionsFromStreamProcessor.hpp"

namespace MoochoPack {

class MoochoSolver {
public:


  typedef Teuchos::RCP<
    NLPInterfacePack::NLP>                                       nlp_ptr_t; // full path needed by doxygen
  typedef Teuchos::RCP<
    IterationPack::AlgorithmTracker>                        track_ptr_t; // full path needed by doxygen
  typedef Teuchos::RCP<NLPAlgoConfig>    config_ptr_t;
  typedef Teuchos::RCP<
    OptionsFromStreamPack::OptionsFromStream>                    options_ptr_t;
  typedef Teuchos::RCP<std::ostream>       ostream_ptr_t;
  enum EOutputToBlackHole {
    OUTPUT_TO_BLACK_HOLE_DEFAULT
    ,OUTPUT_TO_BLACK_HOLE_TRUE
    ,OUTPUT_TO_BLACK_HOLE_FALSE
  };
  enum EConfigOptions {
    MAMA_JAMA
    ,INTERIOR_POINT
  };
  enum ESolutionStatus {
    SOLVE_RETURN_SOLVED            =  0
    ,SOLVE_RETURN_NLP_TEST_FAILED  =  1
    ,SOLVE_RETURN_MAX_ITER         =  2
    ,SOLVE_RETURN_MAX_RUN_TIME     =  3
    ,SOLVE_RETURN_EXCEPTION        =  4
  };



  MoochoSolver(
    const std::string &options_file_name = "Moocho.opt"
    ,const std::string &extra_options_str = ""
    );

  OptionsFromStreamPack::CommandLineOptionsFromStreamProcessor&
  commandLineOptionsFromStreamProcessor();

  const OptionsFromStreamPack::CommandLineOptionsFromStreamProcessor&
  commandLineOptionsFromStreamProcessor() const;

  void setup_commandline_processor(
    Teuchos::CommandLineProcessor *clp
    );

  void set_nlp(const nlp_ptr_t& nlp);
  
  const nlp_ptr_t& get_nlp() const;
  
  void set_track(const track_ptr_t& track);
  
  const track_ptr_t& get_track() const;

  void set_config( const config_ptr_t& config );

  const config_ptr_t& get_config() const;

  void set_options( const options_ptr_t& options );

  const options_ptr_t& get_options() const;



  void set_error_handling(
    bool                    throw_exceptions
    ,const ostream_ptr_t&   error_out
    );

  bool throw_exceptions() const;

  const ostream_ptr_t& error_out() const;



  void set_output_context(
    const std::string    &file_context_postfix
    ,EOutputToBlackHole  output_to_black_hole  = OUTPUT_TO_BLACK_HOLE_DEFAULT
    ,const int           procRank              = -1           
    ,const int           numProcs              = -1
    );
  


  void set_output_file_tag(const std::string&);

  void do_console_outputting(bool);

  bool do_console_outputting() const;

  void set_console_out( const ostream_ptr_t& console_out );

  const ostream_ptr_t& get_console_out() const;
  
  void do_summary_outputting(bool);

  bool do_summary_outputting() const;

  void set_summary_out( const ostream_ptr_t& summary_out );
  
  const ostream_ptr_t& get_summary_out() const;

  void do_journal_outputting(bool);

  bool do_journal_outputting() const;

  void set_journal_out( const ostream_ptr_t& journal_out );
  
  const ostream_ptr_t& get_journal_out() const;

  void do_algo_outputting(bool);

  bool do_algo_outputting() const;

  void generate_stats_file(bool);

  bool generate_stats_file() const;

  void set_algo_out( const ostream_ptr_t& algo_out );
  
  const ostream_ptr_t& get_algo_out() const;

  Teuchos::RCP<std::ostream>
  generate_output_file(const std::string &fileNameBase) const;



  void update_solver() const;


  ESolutionStatus solve_nlp() const;



  NLPSolverClientInterface& get_solver();

  const NLPSolverClientInterface& get_solver() const;
  

private:

  // //////////////////////////////////////
  // Private types

  typedef Teuchos::RCP<NLPSolverClientInterface>    solver_ptr_t;
    
  // ////////////////////////////////////
  // Private data members

  mutable OptionsFromStreamPack::CommandLineOptionsFromStreamProcessor commandLineOptionsFromStreamProcessor_;
#ifndef DOXYGEN_COMPILE
  mutable NLPAlgoContainer solver_;          // Solver object.
#else
  mutable NLPAlgoContainer solver;
#endif
  mutable bool              reconfig_solver_; // If true then we must reconfigure the solver!
  mutable value_type        workspace_MB_;
  mutable value_type        obj_scale_;
  mutable bool              test_nlp_;
  mutable bool              print_algo_;
  mutable bool              algo_timing_;
  mutable bool              generate_stats_file_;
  mutable bool              print_opt_grp_not_accessed_;
  mutable bool              throw_exceptions_;
  mutable std::string       output_file_tag_;
  mutable bool              do_console_outputting_;
  mutable bool              do_summary_outputting_;
  mutable bool              do_journal_outputting_;
  mutable bool              do_algo_outputting_;
  mutable int               configuration_;
#ifndef DOXYGEN_COMPILE
  nlp_ptr_t                 nlp_;
  track_ptr_t               track_;
  config_ptr_t              config_;
  options_ptr_t             options_;          // set by client
  ostream_ptr_t             error_out_;        // set by client
  mutable ostream_ptr_t     algo_out_;         // set by client
  mutable ostream_ptr_t     console_out_;      // set by client
  mutable ostream_ptr_t     summary_out_;      // set by client
  mutable ostream_ptr_t     journal_out_;      // set by client
  mutable options_ptr_t     options_used_;     // actually used (can be NULL)
  mutable ostream_ptr_t     error_out_used_;   // actually used (can't be NULL)
  mutable ostream_ptr_t     console_out_used_; // actually used (can be NULL if do_console_outputting == false)
  mutable ostream_ptr_t     summary_out_used_; // actually used (can be NULL if do_summary_outputting == false)
  mutable ostream_ptr_t     journal_out_used_; // actually used (can be NULL if do_journal_outputting == false)
  mutable ostream_ptr_t     algo_out_used_;    // actually used (can be NULL if do_algo_outputting == false)
  mutable ostream_ptr_t     stats_out_used_;   // actually used
  EOutputToBlackHole        output_to_black_hole_;
  std::string               file_context_postfix_;
  std::string               file_proc_postfix_;
#endif

  // ////////////////////////////////////
  // Private member functions

  void generate_output_streams() const;

}; // end class MoochoSolver

// /////////////////////////////////////////
// Inline members

inline
void MoochoSolver::set_output_file_tag(const std::string& output_file_tag)
{
  output_file_tag_ = output_file_tag;
}

inline
void MoochoSolver::do_console_outputting(bool do_console_outputting)
{
  do_console_outputting_ = do_console_outputting;
}

inline
bool MoochoSolver::do_console_outputting() const
{
  return do_console_outputting_;
}

inline
void MoochoSolver::do_summary_outputting(bool do_summary_outputting)
{
  do_summary_outputting_ = do_summary_outputting;
}

inline
bool MoochoSolver::do_summary_outputting() const
{
  return do_summary_outputting_;
}

inline
void MoochoSolver::do_journal_outputting(bool do_journal_outputting)
{
  do_journal_outputting_ = do_journal_outputting;
}

inline
bool MoochoSolver::do_journal_outputting() const
{
  return do_journal_outputting_;
}

inline
void MoochoSolver::do_algo_outputting(bool do_algo_outputting)
{
  do_algo_outputting_ = do_algo_outputting;
}

inline
bool MoochoSolver::do_algo_outputting() const
{
  return do_algo_outputting_;
}

inline
void MoochoSolver::generate_stats_file(bool generate_stats_file)
{
  generate_stats_file_ = generate_stats_file;
}

inline
bool MoochoSolver::generate_stats_file() const
{
  return generate_stats_file_;
}

} // end namespace MoochoPack

#endif // MOOCHOPACK_MOOCHO_SOLVER_HPP

---