CapeSolver.hpp

/* -----------------------------------------------------------------------------
 *  Diana process modelling, simulation and analysis software
 *  Copyright (c) 2005, Michael Krasnyk
 *  All rights reserved.
 *
 *  This file is a part of Diana process modelling, simulation and analysis software
 *
 *  Diana is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published
 *  by the Free Software Foundation (see accompanying file LICENSE)
 * -----------------------------------------------------------------------------
 *  $Id: CapeSolver.hpp 9446 2011-08-09 13:01:04Z miroshkin $
 * -----------------------------------------------------------------------------
 *  Description:
 */

#ifndef CAPE_SOLVER_HPP
#define CAPE_SOLVER_HPP

#include "CapeTypes.hpp"
#include "CapeException.hpp"
#include "CapeMatrix.hpp"
#include "CapeModel.hpp"
#include "CapeNLPTask.hpp"

namespace Numeric{

  namespace  Solvers {

    namespace NLPTasks {
      class ICapeNLPTask;
    }

    namespace Solver{

      enum CapeSolverType{
        CAPE_LA,
        CAPE_NLA,
        CAPE_DAE,
        CAPE_PDAE,
        CAPE_CONTI,
        CAPE_NLP,
        CAPE_IC
      };

      enum SolveReturn{
        SolveSuccess,
        SolveIntermediate,
        SolveError,
        SolveException,
        SolveTooManyIterations,
        SolveNaNNorm,
      };

      typedef std::vector<CapeSolverType> CapeArraySolverType; 

      // Foward declaration of interfaces
      class ICapeNumericSolverFactory;
      class ICapeNumericSolver;
      class ICapeNumericLASolver;
      class ICapeNumericNLASolver;
      class ICapeNumericDAESolver;
      class ICapeNumericPDAESolver;
      class ICapeNumericNLPSolver;

      // Interface sequence
      typedef std::vector<ICapeNumericDAESolver*> CapeArrayNumericDAESolver;          
      typedef std::vector<ICapeNumericSolverFactory*> CapeArrayNumericSolverFactory;  
      typedef std::vector<ICapeNumericSolver*> CapeArrayNumericSolver;                
      typedef std::vector<ICapeNumericLASolver*> CapeArrayNumericLASolver;            
      typedef std::vector<ICapeNumericNLASolver*> CapeArrayNumericNLASolver;          
      typedef std::vector<ICapeNumericPDAESolver*> CapeArrayNumericPDAESolver;        
      typedef std::vector<ICapeNumericNLPSolver*> CapeArrayNumericNLPSolver;          

      class ICapeNumericSolverFactory {
      public:
        virtual ICapeNumericSolver* CreateSolver(CapeSolverType type,
                                                 Model::ICapeNumericModel* theModel,
                                                 Common::Types::CapeString strLibraryName)
          throw (Common::Error::ECapeUnknown, Common::Error::ECapeInvalidArgument,
                 Common::Error::ECapeOutOfBounds, Common::Error::ECapeOutOfResources,
                 Common::Error::ECapeFailedInitialisation, Common::Error::ECapeUser) = 0;

        virtual void Shutdown()
          throw (Common::Error::ECapeUnknown, Common::Error::ECapeNoImpl) = 0;
      };

      class ICapeNumericSolver : public Common::Identification::ICapeIdentification,
                                 public Common::Utilities:: ICapeUtilities {
#ifndef SWIG

        friend std::ostream& operator<<(std::ostream& out_file, const ICapeNumericSolver& solver);
#endif
      public:
        virtual SolveReturn Solve()
          throw (Common::Error::ECapeUnknown, Common::Error::ECapeBadInvOrder,
                 Common::Error::ECapeSolvingError, Common::Error::ECapeOutOfResources) = 0;

        virtual Common::Types::CapeArrayDouble GetSolution()
          throw (Common::Error::ECapeUnknown, Common::Error::ECapeBadInvOrder) = 0;

        virtual void Destroy()
          throw (Common::Error::ECapeUnknown) = 0;
      };

      class ICapeNumericLASolver : virtual public ICapeNumericSolver {
#ifndef SWIG

        friend std::ostream& operator<<(std::ostream& out_file, const ICapeNumericLASolver& solver);
#endif
      };

      class ICapeNumericNLASolver : virtual public ICapeNumericSolver {
#ifndef SWIG

        friend std::ostream& operator<<(std::ostream& out_file, const ICapeNumericNLASolver& solver);
#endif
      public:
        virtual void SetCvgTolerance(Common::Types::CapeDouble cvgValue)
          throw (Common::Error::ECapeUnknown, Common::Error::ECapeInvalidArgument,
                 Common::Error::ECapeOutOfBounds) = 0;

        virtual Common::Types::CapeDouble GetCvgTolerance()
          throw (Common::Error::ECapeUnknown, Common::Error::ECapeBadInvOrder) = 0;

        virtual void SetMaxIterations(Common::Types::CapeLong maxIteration)
          throw (Common::Error::ECapeUnknown, Common::Error::ECapeInvalidArgument,
                 Common::Error::ECapeOutOfBounds) = 0;

        virtual Common::Types::CapeLong GetMaxIterations()
          throw (Common::Error::ECapeUnknown, Common::Error::ECapeBadInvOrder) = 0;

        virtual Common::Types::CapeLong DoNIteration(Common::Types::CapeLong nbIterations)
          throw (Common::Error::ECapeUnknown, Common::Error::ECapeInvalidArgument,
                 Common::Error::ECapeOutOfBounds, Common::Error::ECapeBadInvOrder,
                 Common::Error::ECapeSolvingError, Common::Error::ECapeOutOfResources) = 0;
      };

      class ICapeNumericDAESolver : virtual public ICapeNumericSolver {
#ifndef SWIG

        friend std::ostream& operator<<(std::ostream& out_file, const ICapeNumericDAESolver& solver);
#endif
      public:
        virtual void SetRelTolerance(const Common::Types::CapeArrayDouble& relTolValue)
          throw (Common::Error::ECapeUnknown, Common::Error::ECapeInvalidArgument,
                 Common::Error::ECapeOutOfBounds) = 0;

        virtual Common::Types::CapeArrayDouble GetRelTolerance()
          throw (Common::Error::ECapeUnknown, Common::Error::ECapeBadInvOrder) = 0;

        virtual void SetAbsTolerance(const Common::Types::CapeArrayDouble& absTolValues)
          throw (Common::Error::ECapeUnknown, Common::Error::ECapeInvalidArgument,
                 Common::Error::ECapeOutOfBounds) = 0;

        virtual Common::Types::CapeArrayDouble GetAbsTolerance()
          throw (Common::Error::ECapeUnknown, Common::Error::ECapeBadInvOrder) = 0;

        virtual Model::CapeArrayNumericEventInfo*
        AdvanceToNextEvent(Model::CapeArrayNumericEventInfo endConditions,
                           Common::Types::CapeDouble& timeBefore,
                           Common::Types::CapeDouble& timeAfter)
          throw (Common::Error::ECapeUnknown, Common::Error::ECapeInvalidArgument,
                 Common::Error::ECapeOutOfBounds, Common::Error::ECapeBadInvOrder,
                 Common::Error::ECapeSolvingError, Common::Error::ECapeOutOfResources,
                 Common::Error::ECapeNoImpl) = 0;
      };
      class ICapeNumericNLPSolver : virtual public ICapeNumericSolver {
      public:

        virtual void SetNLPTask(Numeric::Solvers::NLPTasks::ICapeNLPTask *task) = 0;

      };

    };
  };
};

#ifndef SWIG

std::ostream& operator<<(std::ostream& out_file, const Numeric::Solvers::Solver::ICapeNumericSolver& solver);
std::ostream& operator<<(std::ostream& out_file, const Numeric::Solvers::Solver::ICapeNumericLASolver& solver);
std::ostream& operator<<(std::ostream& out_file, const Numeric::Solvers::Solver::ICapeNumericNLASolver& solver);
std::ostream& operator<<(std::ostream& out_file, const Numeric::Solvers::Solver::ICapeNumericDAESolver& solver);
std::ostream& operator<<(std::ostream& out_file, const Numeric::Solvers::Solver::ICapeNumericNLPSolver& solver);
#endif

#endif // CAPE_SOLVER_HPP