molpro::linalg::itsolv::SolverFactory< R, Q, P > Class Template Reference

Factory for creating instances of specific solver implementations from the corresponding Options object. More...

#include <SolverFactory.h>

Detailed Description

template<class R, class Q = R, class P = std::map<size_t, typename R::value_type>>
class molpro::linalg::itsolv::SolverFactory< R, Q, P >

Factory for creating instances of specific solver implementations from the corresponding Options object.

Note

The factory has to be instantiated for specific R,Q and P vector types

Instantiating the factory

Assuming user defined containers are declared in UserDefinedVectors.h than the user can include the following explicit instantiation for the factory in a .cpp file,

// "solver_factory_instantiation.cpp"
#include <molpro/linalg/itsolv/SolverFactory-implementation.h>
#include "UserDefinedVectors.h"
 
namespace molpro::linalg::itsolv {
template class SolverFactory<UserDefinedRvector, UserDefinedQvector, UserDefinedPvector>;
}

Using the factory

#include <molpro/linalg/itsolv/SolverFactory.h>
#include "UserDefinedVectors.h"
#include "read_user_options.h"
using molpro::linalg::itsolv;
using R = UserDefinedRVector;
using Q = UserDefinedQVector;
using P = UserDefinedPVector;
 
int main(int argn, char** argv){
     std::shared_ptr<Options> options = read_user_options_general(argn, argv);
     auto handlers = std::make_shared<ArrayHandlers<R, Q, P>>();
     auto factory = SolverFactory<R, Q, P>{};
 
     std::unique_ptr<IterativeSolver> solver = factory.create(*options, handlers);
     solver->solve();
 
     // Or, if a specific solver type is needed
     std::shared_ptr<ILinearEigensystemOptions> eigen_options = read_user_options_eigen(argn, argv);
     std::shared_ptr<ILinearEigensystem> eigen_solver = factory.create(*eigen_options, handlers);
     eigen_solver.solve();
     user_defined_print(eigen_solver.eigenvalues());
 
     // Or with options provided as a key1=value1,key2=value2,.. string, and using a free-function factory call, and
using default handlers where these support the given R, Q, P: auto eigen_solver = create_LinearEigensystem<R, Q,
P>("max_size_qspace=6, nroots=3, convergence_threshold=1e-4"); eigen_solver.solve();
 
     // The factory functions for non-linear equations and optimisation take
     // an additional argument specifying the method:
     auto minimiser = create_Optimize<R, Q, P>("BFGS","convergence_threshold=1e-5");
}

Examples

LinearEigensystemDistrArrayExample.cpp, LinearEigensystemExample.cpp, LinearEigensystemMultirootExample.cpp, LinearEquationsExample.cpp, NonLinearEquationsExample.cpp, OptimizeDistrArrayExample.cpp, and OptimizeExample.cpp.

Public Member Functions
virtual	~SolverFactory ()=default
virtual std::unique_ptr< IterativeSolver< R, Q, P > >	create (const Options &options, const std::shared_ptr< ArrayHandlers< R, Q, P > > &handlers)
virtual std::unique_ptr< LinearEigensystem< R, Q, P > >	create (const LinearEigensystemOptions &options, const std::shared_ptr< ArrayHandlers< R, Q, P > > &handlers=std::make_shared< molpro::linalg::itsolv::ArrayHandlers< R, Q, P > >())
virtual std::unique_ptr< LinearEquations< R, Q, P > >	create (const LinearEquationsOptions &options, const std::shared_ptr< ArrayHandlers< R, Q, P > > &handlers=std::make_shared< molpro::linalg::itsolv::ArrayHandlers< R, Q, P > >())
virtual std::unique_ptr< NonLinearEquations< R, Q, P > >	create (const NonLinearEquationsOptions &options=NonLinearEquationsOptions{}, const std::shared_ptr< ArrayHandlers< R, Q, P > > &handlers=std::make_shared< molpro::linalg::itsolv::ArrayHandlers< R, Q, P > >())
virtual std::unique_ptr< Optimize< R, Q, P > >	create (const OptimizeOptions &options=OptimizeOptions{}, const std::shared_ptr< ArrayHandlers< R, Q, P > > &handlers=std::make_shared< molpro::linalg::itsolv::ArrayHandlers< R, Q, P > >())
virtual std::unique_ptr< IterativeSolver< R, Q, P > >	create (const std::string &method, const options_map &options, const std::shared_ptr< ArrayHandlers< R, Q, P > > &handlers=std::make_shared< molpro::linalg::itsolv::ArrayHandlers< R, Q, P > >())

Constructor & Destructor Documentation

~SolverFactory()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

virtual molpro::linalg::itsolv::SolverFactory< R, Q, P >::~SolverFactory ( )

virtualdefault

Member Function Documentation

create() [1/6]

template<class R , class Q , class P >

std::unique_ptr< LinearEigensystem< R, Q, P > > molpro::linalg::itsolv::SolverFactory< R, Q, P >::create ( const LinearEigensystemOptions &  options, const std::shared_ptr< ArrayHandlers< R, Q, P > > &  handlers = std::make_shared<molpro::linalg::itsolv::ArrayHandlers<R, Q, P>>()  )

virtual

create() [2/6]

template<class R , class Q , class P >

std::unique_ptr< LinearEquations< R, Q, P > > molpro::linalg::itsolv::SolverFactory< R, Q, P >::create ( const LinearEquationsOptions &  options, const std::shared_ptr< ArrayHandlers< R, Q, P > > &  handlers = std::make_shared<molpro::linalg::itsolv::ArrayHandlers<R, Q, P>>()  )

virtual

create() [3/6]

template<class R , class Q , class P >

std::unique_ptr< NonLinearEquations< R, Q, P > > molpro::linalg::itsolv::SolverFactory< R, Q, P >::create ( const NonLinearEquationsOptions &  options = NonLinearEquationsOptions{}, const std::shared_ptr< ArrayHandlers< R, Q, P > > &  handlers = std::make_shared<molpro::linalg::itsolv::ArrayHandlers<R, Q, P>>()  )

virtual

create() [4/6]

template<class R , class Q , class P >

std::unique_ptr< Optimize< R, Q, P > > molpro::linalg::itsolv::SolverFactory< R, Q, P >::create ( const OptimizeOptions &  options = OptimizeOptions{}, const std::shared_ptr< ArrayHandlers< R, Q, P > > &  handlers = std::make_shared<molpro::linalg::itsolv::ArrayHandlers<R, Q, P>>()  )

virtual

create() [5/6]

template<class R , class Q , class P >

std::unique_ptr< IterativeSolver< R, Q, P > > molpro::linalg::itsolv::SolverFactory< R, Q, P >::create ( const Options &  options, const std::shared_ptr< ArrayHandlers< R, Q, P > > &  handlers  )

virtual

create() [6/6]

template<class R , class Q , class P >

std::unique_ptr< IterativeSolver< R, Q, P > > molpro::linalg::itsolv::SolverFactory< R, Q, P >::create ( const std::string &  method, const options_map &  options, const std::shared_ptr< ArrayHandlers< R, Q, P > > &  handlers = std::make_shared<molpro::linalg::itsolv::ArrayHandlers<R, Q, P>>()  )

virtual

Create a solver of the given kind, using its default algorithm (Davidson, Davidson, DIIS or BFGS respectively).

Parameters

method

one of "LinearEigensystem", "LinearEquations", "NonLinearEquations" or "Optimize"

Exceptions

std::runtime_error

for any other method