Xped::iPEPSSolverAD< Scalar, Symmetry, CPOpts, TRank > Struct Template Reference

#include <CeresSolve.hpp>

Collaboration diagram for Xped::iPEPSSolverAD< Scalar, Symmetry, CPOpts, TRank >:

Classes
struct	CustomCallback
struct	GetStateCallback
struct	LoggingCallback
struct	ObsCallback
struct	SaveCallback
struct	SolverState

Public Types
template<typename Sym >
using	Hamiltonian = TwoSiteObservable< double, Sym, true >
using	EnergyFunctor = Energy< Scalar, Symmetry, CPOpts, TRank >

Public Member Functions
	iPEPSSolverAD ()=delete
	iPEPSSolverAD (Opts::Optim optim_opts, Opts::CTM ctm_opts, std::shared_ptr< iPEPS< Scalar, Symmetry > > Psi_in, Hamiltonian< Symmetry > &H_in)
template<typename HamScalar >
void	solve ()
CTMSolver< Scalar, Symmetry, CPOpts, TRank > *	getCTMSolver ()
const CTMSolver< Scalar, Symmetry, CPOpts, TRank > *	getCTMSolver () const
template<typename Ar >
void	serialize (Ar &ar) const
template<typename Ar >
void	serialize (Ar &ar)

Public Attributes
Opts::Optim	optim_opts
std::function< void(XPED_CONST CTM< Scalar, Symmetry, TRank > &ctm, std::size_t)>	callback
SolverState	state
ceres::GradientProblemSolver::Options	options
Hamiltonian< Symmetry > &	H
std::shared_ptr< iPEPS< Scalar, Symmetry > >	Psi
std::unique_ptr< ceres::GradientProblem >	problem

Member Typedef Documentation

EnergyFunctor

template<typename Scalar , typename Symmetry , Opts::CTMCheckpoint CPOpts = Opts::CTMCheckpoint{}, std::size_t TRank = 2>

using Xped::iPEPSSolverAD< Scalar, Symmetry, CPOpts, TRank >::EnergyFunctor = Energy<Scalar, Symmetry, CPOpts, TRank>

Hamiltonian

template<typename Scalar , typename Symmetry , Opts::CTMCheckpoint CPOpts = Opts::CTMCheckpoint{}, std::size_t TRank = 2>

template<typename Sym >

using Xped::iPEPSSolverAD< Scalar, Symmetry, CPOpts, TRank >::Hamiltonian = TwoSiteObservable<double, Sym, true>

Constructor & Destructor Documentation

iPEPSSolverAD() [1/2]

template<typename Scalar , typename Symmetry , Opts::CTMCheckpoint CPOpts = Opts::CTMCheckpoint{}, std::size_t TRank = 2>

Xped::iPEPSSolverAD< Scalar, Symmetry, CPOpts, TRank >::iPEPSSolverAD ( )

delete

iPEPSSolverAD() [2/2]

template<typename Scalar , typename Symmetry , Opts::CTMCheckpoint CPOpts = Opts::CTMCheckpoint{}, std::size_t TRank = 2>

Xped::iPEPSSolverAD< Scalar, Symmetry, CPOpts, TRank >::iPEPSSolverAD ( Opts::Optim  optim_opts, Opts::CTM  ctm_opts, std::shared_ptr< iPEPS< Scalar, Symmetry > >  Psi_in, Hamiltonian< Symmetry > &  H_in  )

inline

Member Function Documentation

getCTMSolver() [1/2]

template<typename Scalar , typename Symmetry , Opts::CTMCheckpoint CPOpts = Opts::CTMCheckpoint{}, std::size_t TRank = 2>

CTMSolver< Scalar, Symmetry, CPOpts, TRank > * Xped::iPEPSSolverAD< Scalar, Symmetry, CPOpts, TRank >::getCTMSolver ( )

inline

Here is the caller graph for this function:

getCTMSolver() [2/2]

template<typename Scalar , typename Symmetry , Opts::CTMCheckpoint CPOpts = Opts::CTMCheckpoint{}, std::size_t TRank = 2>

const CTMSolver< Scalar, Symmetry, CPOpts, TRank > * Xped::iPEPSSolverAD< Scalar, Symmetry, CPOpts, TRank >::getCTMSolver ( ) const

inline

serialize() [1/2]

template<typename Scalar , typename Symmetry , Opts::CTMCheckpoint CPOpts = Opts::CTMCheckpoint{}, std::size_t TRank = 2>

template<typename Ar >

void Xped::iPEPSSolverAD< Scalar, Symmetry, CPOpts, TRank >::serialize ( Ar &  ar )

inline

serialize() [2/2]

template<typename Scalar , typename Symmetry , Opts::CTMCheckpoint CPOpts = Opts::CTMCheckpoint{}, std::size_t TRank = 2>

template<typename Ar >

void Xped::iPEPSSolverAD< Scalar, Symmetry, CPOpts, TRank >::serialize ( Ar &  ar ) const

inline

solve()

template<typename Scalar , typename Symmetry , Opts::CTMCheckpoint CPOpts = Opts::CTMCheckpoint{}, std::size_t TRank = 2>

template<typename HamScalar >

void Xped::iPEPSSolverAD< Scalar, Symmetry, CPOpts, TRank >::solve ( )

inline

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

callback

template<typename Scalar , typename Symmetry , Opts::CTMCheckpoint CPOpts = Opts::CTMCheckpoint{}, std::size_t TRank = 2>

std::function<void(XPED_CONST CTM<Scalar, Symmetry, TRank>& ctm, std::size_t)> Xped::iPEPSSolverAD< Scalar, Symmetry, CPOpts, TRank >::callback

Initial value:

= [](XPED_CONST CTM<Scalar, Symmetry, TRank>&,
                                                                                                 std::size_t) {}

H

template<typename Scalar , typename Symmetry , Opts::CTMCheckpoint CPOpts = Opts::CTMCheckpoint{}, std::size_t TRank = 2>

Hamiltonian<Symmetry>& Xped::iPEPSSolverAD< Scalar, Symmetry, CPOpts, TRank >::H

optim_opts

template<typename Scalar , typename Symmetry , Opts::CTMCheckpoint CPOpts = Opts::CTMCheckpoint{}, std::size_t TRank = 2>

Opts::Optim Xped::iPEPSSolverAD< Scalar, Symmetry, CPOpts, TRank >::optim_opts

options

template<typename Scalar , typename Symmetry , Opts::CTMCheckpoint CPOpts = Opts::CTMCheckpoint{}, std::size_t TRank = 2>

ceres::GradientProblemSolver::Options Xped::iPEPSSolverAD< Scalar, Symmetry, CPOpts, TRank >::options

problem

template<typename Scalar , typename Symmetry , Opts::CTMCheckpoint CPOpts = Opts::CTMCheckpoint{}, std::size_t TRank = 2>

std::unique_ptr<ceres::GradientProblem> Xped::iPEPSSolverAD< Scalar, Symmetry, CPOpts, TRank >::problem

Psi

template<typename Scalar , typename Symmetry , Opts::CTMCheckpoint CPOpts = Opts::CTMCheckpoint{}, std::size_t TRank = 2>

std::shared_ptr<iPEPS<Scalar, Symmetry> > Xped::iPEPSSolverAD< Scalar, Symmetry, CPOpts, TRank >::Psi

state

template<typename Scalar , typename Symmetry , Opts::CTMCheckpoint CPOpts = Opts::CTMCheckpoint{}, std::size_t TRank = 2>

SolverState Xped::iPEPSSolverAD< Scalar, Symmetry, CPOpts, TRank >::state

---

The documentation for this struct was generated from the following file:

• include/Xped/NLO/CeresSolve.hpp