Homec4science
Diffusion SpecMiCP / ReactMiCP (kinetics) Browse

specmicp/src/specmicp/reduced_system_solver.hpp
fbc3b1f9f7c0kinetics

Last Change
Raw File

reduced_system_solver.hpp
View Options

/*-------------------------------------------------------
- Module : specmicp
- File : reduced_system_solver.hpp
- Author : Fabien Georget
Copyright (c) 2014, Fabien Georget, Princeton University
---------------------------------------------------------*/
#ifndef SPECMICP_SPECMICP_REDUCEDSYSTEMSOLVER_HPP
#define SPECMICP_SPECMICP_REDUCEDSYSTEMSOLVER_HPP
#include "database/data_container.hpp"
#include "reduced_system.hpp"
#include "micpsolver/micpsolver_structs.hpp"
//! \file reduced_system_solver.hpp Solve a reduced system
namespace specmicp {
// forward declaration
class EquilibriumState;
struct ReducedSystemSolverOptions
{
micpsolver::NCPfunction ncp_function;
micpsolver::MiCPSolverOptions solver_options;
bool allow_restart;
ReducedSystemSolverOptions():
ncp_function(micpsolver::NCPfunction::penalizedFB),
solver_options(),
allow_restart(true)
{}
};
//! \brief Solver a reduced system
//!
//! Take care of possibly non-existing component in the system
class ReducedSystemSolver
{
public:
//! Default constructor - you need to use another method to initialize it correctly
ReducedSystemSolver() {}
ReducedSystemSolver(std::shared_ptr<database::DataContainer> data,
Eigen::VectorXd& totconc,
const SimulationBox& simulbox);
ReducedSystemSolver(std::shared_ptr<database::DataContainer> data,
Eigen::VectorXd& totconc);
ReducedSystemSolver(std::shared_ptr<database::DataContainer> data,
Eigen::VectorXd& totconc,
const EquilibriumState& previous_solution);
//! \brief solve the problem using initial guess x
//!
//! \param[in,out] x in -> initial guess, out -> solution
//! \param init if true, the algorithm guess a starting point
micpsolver::MiCPPerformance solve(Eigen::VectorXd& x, bool init=false);
//! \brief Return the system used for the computation
std::shared_ptr<ReducedSystem> get_system() {return m_system;}
//! \brief Return the solution in a manageable form
EquilibriumState get_solution(const Eigen::VectorXd& x);
//! \brief Return a const reference to the options
const ReducedSystemSolverOptions& get_options() const {return m_options;}
//! \brief Return a reference to the options
ReducedSystemSolverOptions& get_options() {return m_options;}
private:
//! \brief set up the true variable vector
void set_true_variable_vector(const Eigen::VectorXd& x);
//! \brief set up the true solution vector
//!
//! add zero components
void set_return_vector(Eigen::VectorXd& x);
//! \brief solve the problem
micpsolver::MiCPPerformance solve();
ReducedSystemSolverOptions m_options; //! The options
std::shared_ptr<database::DataContainer> m_data; //! The raw database
std::shared_ptr<ReducedSystem> m_system; //! The system to solve
Eigen::VectorXd m_var; //! Copy of the solution vector
};
//! \brief Solve a reduced system, function provided for convenience
inline micpsolver::MiCPPerformance solve_reduced_system(std::shared_ptr<database::DataContainer> data,
Eigen::VectorXd& totconc,
Eigen::VectorXd& x)
{
return ReducedSystemSolver(data, totconc).solve(x);
}
} // end namespace specmicp
#endif // SPECMICP_SPECMICP_REDUCEDSYSTEMSOLVER_HPP
c4science · Help