Inheritance diagram for RotatedSPOs:

Collaboration diagram for RotatedSPOs:

Public Types
using	RotationIndices = std::vector< std::pair< int, int > >

Public Types inherited from SPOSet
using	ValueVector = OrbitalSetTraits< ValueType >::ValueVector

using	ValueMatrix = OrbitalSetTraits< ValueType >::ValueMatrix

using	GradVector = OrbitalSetTraits< ValueType >::GradVector

using	GradMatrix = OrbitalSetTraits< ValueType >::GradMatrix

using	HessVector = OrbitalSetTraits< ValueType >::HessVector

using	HessMatrix = OrbitalSetTraits< ValueType >::HessMatrix

using	GGGVector = OrbitalSetTraits< ValueType >::GradHessVector

using	GGGMatrix = OrbitalSetTraits< ValueType >::GradHessMatrix

using	SPOMap = std::map< std::string, const std::unique_ptr< const SPOSet > >

using	OffloadMWVGLArray = Array< ValueType, 3, OffloadPinnedAllocator< ValueType > >

using	OffloadMWVArray = Array< ValueType, 2, OffloadPinnedAllocator< ValueType > >

template<typename DT >
using	OffloadMatrix = Matrix< DT, OffloadPinnedAllocator< DT > >

Public Types inherited from QMCTraits
enum	{ DIM = OHMMS_DIM, DIM_VGL = OHMMS_DIM + 2 }

using	QTBase = QMCTypes< OHMMS_PRECISION, DIM >

using	QTFull = QMCTypes< OHMMS_PRECISION_FULL, DIM >

using	RealType = QTBase::RealType

using	ComplexType = QTBase::ComplexType

using	ValueType = QTBase::ValueType

using	PosType = QTBase::PosType

using	GradType = QTBase::GradType

using	TensorType = QTBase::TensorType

using	IndexType = OHMMS_INDEXTYPE
	define other types More...

using	FullPrecRealType = QTFull::RealType

using	FullPrecValueType = QTFull::ValueType

using	PropertySetType = RecordNamedProperty< FullPrecRealType >
	define PropertyList_t More...

using	PtclGrpIndexes = std::vector< std::pair< int, int > >

Public Member Functions
	RotatedSPOs (const std::string &my_name, std::unique_ptr< SPOSet > &&spos)

	~RotatedSPOs () override

std::string	getClassName () const override
	return class name More...

bool	isOptimizable () const override
	Query if this SPOSet is optimizable. More...

bool	isOMPoffload () const override
	Query if this SPOSet uses OpenMP offload. More...

bool	hasIonDerivs () const override
	Query if this SPOSet has an explicit ion dependence. More...

void	apply_rotation (const std::vector< ValueType > &param, bool use_stored_copy)

void	applyDeltaRotation (const std::vector< ValueType > &delta_param, const std::vector< ValueType > &old_param, std::vector< ValueType > &new_param)

void	applyRotationHistory ()

void	applyFullRotation (const std::vector< ValueType > &full_param, bool use_stored_copy)

void	setRotationParameters (const std::vector< RealType > &param_list)
	For now, this takes the real optimizable parameters (real rotation coefficients) and converts them to ValueType parameter lists for internal consumption by the real and complex orb-opt code. More...

std::unique_ptr< SPOSet >	makeClone () const override
	make a clone of itself every derived class must implement this to have threading working correctly. More...

void	buildOptVariables (size_t nel)

void	buildOptVariables (const RotationIndices &rotations, const RotationIndices &full_rotations)

void	evaluateDerivatives (ParticleSet &P, const opt_variables_type &optvars, Vector< ValueType > &dlogpsi, Vector< ValueType > &dhpsioverpsi, const int &FirstIndex, const int &LastIndex) override
	Parameter derivatives of the wavefunction and the Laplacian of the wavefunction. More...

void	evaluateDerivativesWF (ParticleSet &P, const opt_variables_type &optvars, Vector< ValueType > &dlogpsi, int FirstIndex, int LastIndex) override
	Parameter derivatives of the wavefunction. More...

void	evaluateDerivatives (ParticleSet &P, const opt_variables_type &optvars, Vector< ValueType > &dlogpsi, Vector< ValueType > &dhpsioverpsi, const ValueType &psiCurrent, const std::vector< ValueType > &Coeff, const std::vector< size_t > &C2node_up, const std::vector< size_t > &C2node_dn, const ValueVector &detValues_up, const ValueVector &detValues_dn, const GradMatrix &grads_up, const GradMatrix &grads_dn, const ValueMatrix &lapls_up, const ValueMatrix &lapls_dn, const ValueMatrix &M_up, const ValueMatrix &M_dn, const ValueMatrix &Minv_up, const ValueMatrix &Minv_dn, const GradMatrix &B_grad, const ValueMatrix &B_lapl, const std::vector< int > &detData_up, const size_t N1, const size_t N2, const size_t NP1, const size_t NP2, const std::vector< std::vector< int >> &lookup_tbl) override
	Evaluate the derivative of the optimized orbitals with respect to the parameters this is used only for MSD, to be refined for better serving both single and multi SD. More...

void	evaluateDerivativesWF (ParticleSet &P, const opt_variables_type &optvars, Vector< ValueType > &dlogpsi, const QTFull::ValueType &psiCurrent, const std::vector< ValueType > &Coeff, const std::vector< size_t > &C2node_up, const std::vector< size_t > &C2node_dn, const ValueVector &detValues_up, const ValueVector &detValues_dn, const ValueMatrix &M_up, const ValueMatrix &M_dn, const ValueMatrix &Minv_up, const ValueMatrix &Minv_dn, const std::vector< int > &detData_up, const std::vector< std::vector< int >> &lookup_tbl) override
	Evaluate the derivative of the optimized orbitals with respect to the parameters this is used only for MSD, to be refined for better serving both single and multi SD. More...

void	table_method_eval (Vector< ValueType > &dlogpsi, Vector< ValueType > &dhpsioverpsi, const ParticleSet::ParticleLaplacian &myL_J, const ParticleSet::ParticleGradient &myG_J, const size_t nel, const size_t nmo, const ValueType &psiCurrent, const std::vector< RealType > &Coeff, const std::vector< size_t > &C2node_up, const std::vector< size_t > &C2node_dn, const ValueVector &detValues_up, const ValueVector &detValues_dn, const GradMatrix &grads_up, const GradMatrix &grads_dn, const ValueMatrix &lapls_up, const ValueMatrix &lapls_dn, const ValueMatrix &M_up, const ValueMatrix &M_dn, const ValueMatrix &Minv_up, const ValueMatrix &Minv_dn, const GradMatrix &B_grad, const ValueMatrix &B_lapl, const std::vector< int > &detData_up, const size_t N1, const size_t N2, const size_t NP1, const size_t NP2, const std::vector< std::vector< int >> &lookup_tbl)

void	table_method_evalWF (Vector< ValueType > &dlogpsi, const size_t nel, const size_t nmo, const ValueType &psiCurrent, const std::vector< RealType > &Coeff, const std::vector< size_t > &C2node_up, const std::vector< size_t > &C2node_dn, const ValueVector &detValues_up, const ValueVector &detValues_dn, const ValueMatrix &M_up, const ValueMatrix &M_dn, const ValueMatrix &Minv_up, const ValueMatrix &Minv_dn, const std::vector< int > &detData_up, const std::vector< std::vector< int >> &lookup_tbl)

void	extractOptimizableObjectRefs (UniqueOptObjRefs &opt_obj_refs) override
	extract underlying OptimizableObject references More...

void	checkInVariablesExclusive (opt_variables_type &active) override
	check in variational parameters to the global list of parameters used by the optimizer. More...

void	checkOutVariables (const opt_variables_type &active) override
	check out variational optimizable variables More...

void	resetParametersExclusive (const opt_variables_type &active) override
	reset More...

void	writeVariationalParameters (hdf_archive &hout) override
	Write the variational parameters for this object to the VP HDF file. More...

void	readVariationalParameters (hdf_archive &hin) override
	Read the variational parameters for this object from the VP HDF file. More...

void	setOrbitalSetSize (int norbs) override
	set the OrbitalSetSize More...

void	checkObject () const override
	check a few key parameters before putting the SPO into a determinant More...

void	evaluateValue (const ParticleSet &P, int iat, ValueVector &psi) override
	evaluate the values of this single-particle orbital set More...

void	evaluateVGL (const ParticleSet &P, int iat, ValueVector &psi, GradVector &dpsi, ValueVector &d2psi) override
	evaluate the values, gradients and laplacians of this single-particle orbital set More...

void	evaluateVGL_spin (const ParticleSet &P, int iat, ValueVector &psi, GradVector &dpsi, ValueVector &d2psi, ValueVector &dspin_psi) override
	evaluate the values, gradients and laplacians and spin gradient of this single-particle orbital set More...

void	evaluateDetRatios (const VirtualParticleSet &VP, ValueVector &psi, const ValueVector &psiinv, std::vector< ValueType > &ratios) override
	evaluate determinant ratios for virtual moves, e.g., sphere move for nonlocalPP More...

void	evaluateDerivRatios (const VirtualParticleSet &VP, const opt_variables_type &optvars, ValueVector &psi, const ValueVector &psiinv, std::vector< ValueType > &ratios, Matrix< ValueType > &dratios, int FirstIndex, int LastIndex) override
	Determinant ratios and parameter derivatives of the wavefunction for virtual moves. More...

void	evaluateVGH (const ParticleSet &P, int iat, ValueVector &psi, GradVector &dpsi, HessVector &grad_grad_psi) override
	evaluate the values, gradients and hessians of this single-particle orbital set More...

void	evaluateVGHGH (const ParticleSet &P, int iat, ValueVector &psi, GradVector &dpsi, HessVector &grad_grad_psi, GGGVector &grad_grad_grad_psi) override
	evaluate the values, gradients, hessians, and grad hessians of this single-particle orbital set More...

void	evaluate_notranspose (const ParticleSet &P, int first, int last, ValueMatrix &logdet, GradMatrix &dlogdet, ValueMatrix &d2logdet) override
	evaluate the values, gradients and laplacians of this single-particle orbital for [first,last) particles More...

void	evaluate_spin (const ParticleSet &P, int iat, ValueVector &psi, ValueVector &dspin_psi) override
	evaluate the values of this single-particle orbital set More...

void	evaluate_notranspose (const ParticleSet &P, int first, int last, ValueMatrix &logdet, GradMatrix &dlogdet, HessMatrix &grad_grad_logdet) override
	evaluate the values, gradients and hessians of this single-particle orbital for [first,last) particles More...

void	evaluate_notranspose (const ParticleSet &P, int first, int last, ValueMatrix &logdet, GradMatrix &dlogdet, HessMatrix &grad_grad_logdet, GGGMatrix &grad_grad_grad_logdet) override
	evaluate the values, gradients, hessians and third derivatives of this single-particle orbital for [first,last) particles More...

void	evaluateGradSource (const ParticleSet &P, int first, int last, const ParticleSet &source, int iat_src, GradMatrix &grad_phi) override
	evaluate the gradients of this single-particle orbital for [first,last) target particles with respect to the given source particle More...

void	evaluateGradSource (const ParticleSet &P, int first, int last, const ParticleSet &source, int iat_src, GradMatrix &grad_phi, HessMatrix &grad_grad_phi, GradMatrix &grad_lapl_phi) override
	evaluate the gradients of values, gradients, laplacians of this single-particle orbital for [first,last) target particles with respect to the given source particle More...

void	set_use_global_rotation (bool use_global_rotation)
	Use history list (false) or global rotation (true) More...

void	mw_evaluateDetRatios (const RefVectorWithLeader< SPOSet > &spo_list, const RefVectorWithLeader< const VirtualParticleSet > &vp_list, const RefVector< ValueVector > &psi_list, const std::vector< const ValueType *> &invRow_ptr_list, std::vector< std::vector< ValueType >> &ratios_list) const override
	evaluate determinant ratios for virtual moves, e.g., sphere move for nonlocalPP, of multiple walkers More...

void	mw_evaluateValue (const RefVectorWithLeader< SPOSet > &spo_list, const RefVectorWithLeader< ParticleSet > &P_list, int iat, const RefVector< ValueVector > &psi_v_list) const override
	evaluate the values this single-particle orbital sets of multiple walkers More...

void	mw_evaluateVGL (const RefVectorWithLeader< SPOSet > &spo_list, const RefVectorWithLeader< ParticleSet > &P_list, int iat, const RefVector< ValueVector > &psi_v_list, const RefVector< GradVector > &dpsi_v_list, const RefVector< ValueVector > &d2psi_v_list) const override
	evaluate the values, gradients and laplacians of this single-particle orbital sets of multiple walkers More...

void	mw_evaluateVGLWithSpin (const RefVectorWithLeader< SPOSet > &spo_list, const RefVectorWithLeader< ParticleSet > &P_list, int iat, const RefVector< ValueVector > &psi_v_list, const RefVector< GradVector > &dpsi_v_list, const RefVector< ValueVector > &d2psi_v_list, OffloadMatrix< ComplexType > &mw_dspin) const override
	evaluate the values, gradients and laplacians and spin gradient of this single-particle orbital sets of multiple walkers More...

void	mw_evaluateVGLandDetRatioGrads (const RefVectorWithLeader< SPOSet > &spo_list, const RefVectorWithLeader< ParticleSet > &P_list, int iat, const std::vector< const ValueType *> &invRow_ptr_list, OffloadMWVGLArray &phi_vgl_v, std::vector< ValueType > &ratios, std::vector< GradType > &grads) const override
	evaluate the values, gradients and laplacians of this single-particle orbital sets and determinant ratio and grads of multiple walkers. More...

void	mw_evaluateVGLandDetRatioGradsWithSpin (const RefVectorWithLeader< SPOSet > &spo_list, const RefVectorWithLeader< ParticleSet > &P_list, int iat, const std::vector< const ValueType *> &invRow_ptr_list, OffloadMWVGLArray &phi_vgl_v, std::vector< ValueType > &ratios, std::vector< GradType > &grads, std::vector< ValueType > &spingrads) const override
	evaluate the values, gradients and laplacians of this single-particle orbital sets and determinant ratio and grads of multiple walkers. More...

void	mw_evaluate_notranspose (const RefVectorWithLeader< SPOSet > &spo_list, const RefVectorWithLeader< ParticleSet > &P_list, int first, int last, const RefVector< ValueMatrix > &logdet_list, const RefVector< GradMatrix > &dlogdet_list, const RefVector< ValueMatrix > &d2logdet_list) const override

void	createResource (ResourceCollection &collection) const override
	initialize a shared resource and hand it to collection More...

void	acquireResource (ResourceCollection &collection, const RefVectorWithLeader< SPOSet > &spo_list) const override
	acquire a shared resource from collection More...

void	releaseResource (ResourceCollection &collection, const RefVectorWithLeader< SPOSet > &spo_list) const override
	return a shared resource to collection More...

Public Member Functions inherited from SPOSet
	SPOSet (const std::string &my_name)
	constructor More...

virtual	~SPOSet ()=default
	destructor More...

int	size () const
	return the size of the orbital set Ye: this needs to be replaced by getOrbitalSetSize(); More...

void	basic_report (const std::string &pad="") const
	print basic SPOSet information More...

virtual void	report (const std::string &pad="") const
	print SPOSet information More...

int	getOrbitalSetSize () const
	return the size of the orbitals More...

virtual bool	isRotationSupported () const
	return true if this SPOSet can be wrappered by RotatedSPO More...

virtual void	storeParamsBeforeRotation ()
	store parameters before getting destroyed by rotation. More...

virtual void	applyRotation (const ValueMatrix &rot_mat, bool use_stored_copy=false)
	apply rotation to all the orbitals More...

virtual void	evaluateDetSpinorRatios (const VirtualParticleSet &VP, ValueVector &psi, const std::pair< ValueVector, ValueVector > &spinor_multiplier, const ValueVector &invrow, std::vector< ValueType > &ratios)
	evaluate determinant ratios for virtual moves, specifically for Spinor SPOSets More...

virtual void	evaluateThirdDeriv (const ParticleSet &P, int first, int last, GGGMatrix &grad_grad_grad_logdet)
	evaluate the third derivatives of this single-particle orbital set More...

virtual void	evaluate_notranspose_spin (const ParticleSet &P, int first, int last, ValueMatrix &logdet, GradMatrix &dlogdet, ValueMatrix &d2logdet, ValueMatrix &dspinlogdet)
	evaluate the values, gradients and laplacians of this single-particle orbital for [first,last) particles, including the spin gradient More...

virtual void	evaluateGradSourceRow (const ParticleSet &P, int iel, const ParticleSet &source, int iat_src, GradVector &gradphi)
	Returns a row of d/dR_iat phi_j(r) evaluated at position r. More...

virtual PosType	get_k (int orb)
	access the k point related to the given orbital More...

virtual bool	transformSPOSet ()
	Used only by cusp correction in AOS LCAO. More...

virtual void	finalizeConstruction ()
	finalize the construction of SPOSet More...

const std::string &	getName () const
	return object name More...

Public Member Functions inherited from OptimizableObject
	OptimizableObject (const std::string &name)

const std::string &	getName () const

bool	isOptimized () const

virtual void	reportStatus (std::ostream &os)
	print the state, e.g., optimizables More...

void	setOptimization (bool state)

Static Public Member Functions
static void	createRotationIndices (int nel, int nmo, RotationIndices &rot_indices)

static void	createRotationIndicesFull (int nel, int nmo, RotationIndices &rot_indices)

static void	constructAntiSymmetricMatrix (const RotationIndices &rot_indices, const std::vector< ValueType > &param, ValueMatrix &rot_mat)

static void	extractParamsFromAntiSymmetricMatrix (const RotationIndices &rot_indices, const ValueMatrix &rot_mat, std::vector< ValueType > &param)

static void	constructDeltaRotation (const std::vector< ValueType > &delta_param, const std::vector< ValueType > &old_param, const RotationIndices &act_rot_inds, const RotationIndices &full_rot_inds, std::vector< ValueType > &new_param, ValueMatrix &new_rot_mat)

static void	exponentiate_antisym_matrix (ValueMatrix &mat)

static void	log_antisym_matrix (const ValueMatrix &mat, ValueMatrix &output)

Public Attributes
RotationIndices	m_act_rot_inds_

RotationIndices	m_full_rot_inds_

std::unique_ptr< SPOSet >	Phi_

size_t	nel_major_
	the number of electrons of the majority spin More...

ParticleSet::ParticleGradient	myG_temp

ParticleSet::ParticleGradient	myG_J

ParticleSet::ParticleLaplacian	myL_temp

ParticleSet::ParticleLaplacian	myL_J

ValueMatrix	Bbar

ValueMatrix	psiM_inv

ValueMatrix	psiM_all

GradMatrix	dpsiM_all

ValueMatrix	d2psiM_all

Static Private Member Functions
static RefVectorWithLeader< SPOSet >	extractPhiRefList (const RefVectorWithLeader< SPOSet > &spo_list)

Private Attributes
bool	params_supplied_
	true if SPO parameters (orbital rotation parameters) have been supplied by input More...

std::vector< ValueType >	params_
	list of supplied orbital rotation parameters. More...

std::vector< ValueType >	myVarsFull_
	Full set of rotation matrix parameters for use in global rotation method. More...

NewTimer &	apply_rotation_timer_
	timer for apply_rotation More...

std::vector< std::vector< ValueType > >	history_params_
	List of previously applied parameters. More...

bool	use_global_rot_ = true
	Use global rotation or history list. More...

Friends
std::vector< ValueType > &	testing::getMyVarsFull (RotatedSPOs &rot)

std::vector< std::vector< ValueType > > &	testing::getHistoryParams (RotatedSPOs &rot)

Additional Inherited Members
Protected Attributes inherited from SPOSet
const std::string	my_name_
	name of the object, unique identifier More...

IndexType	OrbitalSetSize
	number of Single-particle orbitals More...

opt_variables_type	myVars
	Optimizable variables. More...

Detailed Description

Definition at line 28 of file RotatedSPOs.h.

Member Typedef Documentation

◆ RotationIndices

using RotationIndices = std::vector<std::pair<int, int> >

Definition at line 42 of file RotatedSPOs.h.

Constructor & Destructor Documentation

◆ RotatedSPOs()

RotatedSPOs	(	const std::string &	my_name,
		std::unique_ptr< SPOSet > &&	spos
	)

Definition at line 22 of file RotatedSPOs.cpp.

References SPOSet::OrbitalSetSize, and RotatedSPOs::Phi_.

     : SPOSet(my_name),
       OptimizableObject(my_name),
       Phi_(std::move(spos)),
       nel_major_(0),
       params_supplied_(false),
       apply_rotation_timer_(createGlobalTimer("RotatedSPOs::apply_rotation", timer_level_fine))
 {
   OrbitalSetSize = Phi_->getOrbitalSetSize();
 }

◆ ~RotatedSPOs()

~RotatedSPOs ( )

override

Definition at line 33 of file RotatedSPOs.cpp.

33 {}

Member Function Documentation

◆ acquireResource()

void acquireResource	(	ResourceCollection &	collection,
		const RefVectorWithLeader< SPOSet > &	spo_list
	)		const

overridevirtual

acquire a shared resource from collection

Reimplemented from SPOSet.

Definition at line 1729 of file RotatedSPOs.cpp.

References RotatedSPOs::extractPhiRefList().

 {
   auto phi_list = extractPhiRefList(spo_list);
   auto& leader  = phi_list.getLeader();
   leader.acquireResource(collection, phi_list);
 }

◆ apply_rotation()

void apply_rotation	(	const std::vector< ValueType > &	param,
		bool	use_stored_copy
	)

Definition at line 380 of file RotatedSPOs.cpp.

References RotatedSPOs::apply_rotation_timer_, RotatedSPOs::constructAntiSymmetricMatrix(), RotatedSPOs::exponentiate_antisym_matrix(), RotatedSPOs::m_act_rot_inds_, and RotatedSPOs::Phi_.

Referenced by RotatedSPOs::applyRotationHistory(), RotatedSPOs::buildOptVariables(), RotatedSPOs::resetParametersExclusive(), and qmcplusplus::TEST_CASE().

 {
   assert(param.size() == m_act_rot_inds_.size());
 
   const size_t nmo = Phi_->getOrbitalSetSize();
   ValueMatrix rot_mat(nmo, nmo);
 
   constructAntiSymmetricMatrix(m_act_rot_inds_, param, rot_mat);
 
   /*
     rot_mat is now an anti-hermitian matrix. Now we convert
     it into a unitary matrix via rot_mat = exp(-rot_mat). 
     Finally, apply unitary matrix to orbs.
   */
   exponentiate_antisym_matrix(rot_mat);
   {
     ScopedTimer local(apply_rotation_timer_);
     Phi_->applyRotation(rot_mat, use_stored_copy);
   }
 }

◆ applyDeltaRotation()

void applyDeltaRotation	(	const std::vector< ValueType > &	delta_param,
		const std::vector< ValueType > &	old_param,
		std::vector< ValueType > &	new_param
	)

Definition at line 401 of file RotatedSPOs.cpp.

References RotatedSPOs::apply_rotation_timer_, RotatedSPOs::constructDeltaRotation(), RotatedSPOs::m_act_rot_inds_, RotatedSPOs::m_full_rot_inds_, and RotatedSPOs::Phi_.

Referenced by RotatedSPOs::resetParametersExclusive(), and qmcplusplus::TEST_CASE().

 {
   const size_t nmo = Phi_->getOrbitalSetSize();
   ValueMatrix new_rot_mat(nmo, nmo);
   constructDeltaRotation(delta_param, old_param, m_act_rot_inds_, m_full_rot_inds_, new_param, new_rot_mat);
 
   {
     ScopedTimer local(apply_rotation_timer_);
     Phi_->applyRotation(new_rot_mat, true);
   }
 }

◆ applyFullRotation()

void applyFullRotation	(	const std::vector< ValueType > &	full_param,
		bool	use_stored_copy
	)

Definition at line 448 of file RotatedSPOs.cpp.

References RotatedSPOs::constructAntiSymmetricMatrix(), RotatedSPOs::exponentiate_antisym_matrix(), RotatedSPOs::m_full_rot_inds_, and RotatedSPOs::Phi_.

Referenced by RotatedSPOs::readVariationalParameters().

 {
   assert(full_param.size() == m_full_rot_inds_.size());
 
   const size_t nmo = Phi_->getOrbitalSetSize();
   ValueMatrix rot_mat(nmo, nmo);
   rot_mat = ValueType(0);
 
   constructAntiSymmetricMatrix(m_full_rot_inds_, full_param, rot_mat);
 
   /*
     rot_mat is now an anti-hermitian matrix. Now we convert
     it into a unitary matrix via rot_mat = exp(-rot_mat).
     Finally, apply unitary matrix to orbs.
   */
   exponentiate_antisym_matrix(rot_mat);
   Phi_->applyRotation(rot_mat, use_stored_copy);
 }

◆ applyRotationHistory()

void applyRotationHistory ( )

Definition at line 467 of file RotatedSPOs.cpp.

References RotatedSPOs::apply_rotation(), and RotatedSPOs::history_params_.

Referenced by RotatedSPOs::readVariationalParameters().

 {
   for (auto delta_param : history_params_)
   {
     apply_rotation(delta_param, false);
   }
 }

◆ buildOptVariables() [1/2]

void buildOptVariables ( size_t nel )

Definition at line 274 of file RotatedSPOs.cpp.

References RotatedSPOs::createRotationIndices(), RotatedSPOs::createRotationIndicesFull(), SPOSet::myVars, RotatedSPOs::nel_major_, RotatedSPOs::Phi_, VariableSet::size(), and RotatedSPOs::use_global_rot_.

Referenced by MultiDiracDeterminant::buildOptVariables(), DiracDeterminant< DU_TYPE >::DiracDeterminant(), DiracDeterminantBatched< PL, VT, FPVT >::DiracDeterminantBatched(), and qmcplusplus::TEST_CASE().

 {
   /* Only rebuild optimized variables if more after-rotation orbitals are needed
    * Consider ROHF, there is only one set of SPO for both spin up and down Nup > Ndown.
    * nel_major_ will be set Nup.
    *
    * Use the size of myVars as a flag to avoid building the rotation parameters again
    * when a clone is made (the DiracDeterminant constructor calls buildOptVariables)
    */
   if (nel > nel_major_ && myVars.size() == 0)
   {
     nel_major_ = nel;
 
     const size_t nmo = Phi_->getOrbitalSetSize();
 
     // create active rotation parameter indices
     RotationIndices created_m_act_rot_inds;
 
     RotationIndices created_full_rot_inds;
     if (use_global_rot_)
       createRotationIndicesFull(nel, nmo, created_full_rot_inds);
 
     createRotationIndices(nel, nmo, created_m_act_rot_inds);
 
     buildOptVariables(created_m_act_rot_inds, created_full_rot_inds);
   }
 }

◆ buildOptVariables() [2/2]

void buildOptVariables	(	const RotationIndices &	rotations,
		const RotationIndices &	full_rotations
	)

Definition at line 302 of file RotatedSPOs.cpp.

References qmcplusplus::app_log(), RotatedSPOs::apply_rotation(), VariableSet::clear(), qmcplusplus::imag(), RotatedSPOs::m_act_rot_inds_, RotatedSPOs::m_full_rot_inds_, SPOSet::my_name_, SPOSet::myVars, RotatedSPOs::myVarsFull_, qmcplusplus::Units::force::N, RotatedSPOs::params_, RotatedSPOs::params_supplied_, RotatedSPOs::Phi_, VariableSet::print(), VariableSet::size(), and RotatedSPOs::use_global_rot_.

 {
   const size_t nmo = Phi_->getOrbitalSetSize();
 
   // create active rotations
   m_act_rot_inds_ = rotations;
 
   if (use_global_rot_)
     m_full_rot_inds_ = full_rotations;
 
   if (use_global_rot_)
     app_log() << "Orbital rotation using global rotation" << std::endl;
   else
     app_log() << "Orbital rotation using history" << std::endl;
 
   // This will add the orbital rotation parameters to myVars
   // and will also read in initial parameter values supplied in input file
   int nparams_active = m_act_rot_inds_.size();
 
   if (params_supplied_)
     if (nparams_active != params_.size())
       throw std::runtime_error(
           "The number of supplied orbital rotation parameters does not match number prdouced by the slater "
           "expansion. \n");
 
 
   auto registerParameter = [this](const int i, const int p, const int q, opt_variables_type& optvars,
                                   std::vector<ValueType>& params, bool real_part) {
     std::stringstream sstr;
     std::string label = real_part ? "_r" : "_i";
     sstr << my_name_ << "_orb_rot_" << (p < 10 ? "0" : "") << (p < 100 ? "0" : "") << (p < 1000 ? "0" : "") << p << "_"
          << (q < 10 ? "0" : "") << (q < 100 ? "0" : "") << (q < 1000 ? "0" : "") << q << label;
 
     // If the user input parameters, use those. Otherwise, initialize the parameters to zero
     if (params_supplied_)
       optvars.insert(sstr.str(), real_part ? std::real(params[i]) : std::imag(params[i]));
     else
       optvars.insert(sstr.str(), 0.0);
   };
 
   myVars.clear();
   for (int i = 0; i < nparams_active; i++)
   {
     const int p = m_act_rot_inds_[i].first;
     const int q = m_act_rot_inds_[i].second;
     registerParameter(i, p, q, myVars, params_, true);
     if constexpr (IsComplex_t<ValueType>::value)
       registerParameter(i, p, q, myVars, params_, false);
   }
 
   if (use_global_rot_)
   {
     const size_t nfull_rot = m_full_rot_inds_.size();
     myVarsFull_.resize(nfull_rot);
     for (int i = 0; i < nfull_rot; i++)
       myVarsFull_[i] = (params_supplied_ && i < m_act_rot_inds_.size()) ? params_[i] : 0.0;
   }
 
   //Printing the parameters
   if (true)
   {
     app_log() << std::string(16, ' ') << "Parameter name" << std::string(15, ' ') << "Value\n";
     myVars.print(app_log());
   }
 
   if (params_supplied_)
   {
     const size_t N = m_act_rot_inds_.size();
     std::vector<ValueType> param(N);
     //cast as RealType to copy from myVars into real or complex param vector
     auto* param_data_alias = (RealType*)param.data();
     //couldn't easily use std::copy since myVars is vector of pairs
     for (size_t i = 0; i < myVars.size(); i++)
       param_data_alias[i] = myVars[i];
     apply_rotation(param, false);
   }
 }

◆ checkInVariablesExclusive()

void checkInVariablesExclusive ( opt_variables_type & active )

inlineoverridevirtual

check in variational parameters to the global list of parameters used by the optimizer.

Parameters

active a super set of optimizable variables

The existing checkInVariables implementation in WFC/SPO/.. are inclusive and it calls checkInVariables of its members class A: public SPOSet {} class B: public WFC { A objA; checkInVariables() { objA.checkInVariables(); } };

With OptimizableObject, class A: public OptimizableObject {} class B: public OptimizableObject { A objA; checkInVariablesExclusive() { // should not call objA.checkInVariablesExclusive() if objA has been extracted; } }; A vector of OptimizableObject, will be created by calling extractOptimizableObjects(). All the checkInVariablesExclusive() will be called through this vector and thus checkInVariablesExclusive implementation should only handle non-OptimizableObject members.

Implements OptimizableObject.

Definition at line 257 of file RotatedSPOs.h.

References VariableSet::insertFrom(), SPOSet::myVars, and VariableSet::size().

Referenced by qmcplusplus::TEST_CASE().

   {
     if (myVars.size())
       active.insertFrom(myVars);
   }

◆ checkObject()

void checkObject ( ) const

inlineoverridevirtual

check a few key parameters before putting the SPO into a determinant

Reimplemented from SPOSet.

Definition at line 276 of file RotatedSPOs.h.

References RotatedSPOs::Phi_.

276 { Phi_->checkObject(); }

qmcplusplus::RotatedSPOs::Phi_

std::unique_ptr< SPOSet > Phi_

Definition: RotatedSPOs.h:119

◆ checkOutVariables()

void checkOutVariables ( const opt_variables_type & active )

inlineoverridevirtual

check out variational optimizable variables

Parameters

active a super set of optimizable variables

Reimplemented from SPOSet.

Definition at line 263 of file RotatedSPOs.h.

References VariableSet::getIndex(), and SPOSet::myVars.

263 { myVars.getIndex(active); }

qmcplusplus::SPOSet::myVars

opt_variables_type myVars

Optimizable variables.

Definition: SPOSet.h:568

optimize::VariableSet::getIndex

int getIndex(const std::string &vname) const

return the Index vaule for the named parameter

Definition: VariableSet.cpp:177

◆ constructAntiSymmetricMatrix()

void constructAntiSymmetricMatrix	(	const RotationIndices &	rot_indices,
		const std::vector< ValueType > &	param,
		ValueMatrix &	rot_mat
	)

static

Definition at line 76 of file RotatedSPOs.cpp.

References qmcplusplus::conj().

Referenced by RotatedSPOs::apply_rotation(), RotatedSPOs::applyFullRotation(), RotatedSPOs::constructDeltaRotation(), and qmcplusplus::TEST_CASE().

 {
   assert(rot_indices.size() == param.size());
   // Assumes rot_mat is of the correct size
 
   rot_mat = 0.0;
 
   for (int i = 0; i < rot_indices.size(); i++)
   {
     const int p       = rot_indices[i].first;
     const int q       = rot_indices[i].second;
     const ValueType x = param[i];
 
     rot_mat[q][p] = x;
     //This conj is from type_traits/complex_help.hpp.  So conj(Real) returns Real and not complex.
     rot_mat[p][q] = -qmcplusplus::conj(x);
   }
 }

◆ constructDeltaRotation()

void constructDeltaRotation	(	const std::vector< ValueType > &	delta_param,
		const std::vector< ValueType > &	old_param,
		const RotationIndices &	act_rot_inds,
		const RotationIndices &	full_rot_inds,
		std::vector< ValueType > &	new_param,
		ValueMatrix &	new_rot_mat
	)

static

Definition at line 415 of file RotatedSPOs.cpp.

References RotatedSPOs::constructAntiSymmetricMatrix(), RotatedSPOs::exponentiate_antisym_matrix(), RotatedSPOs::extractParamsFromAntiSymmetricMatrix(), BLAS::gemm(), and RotatedSPOs::log_antisym_matrix().

Referenced by RotatedSPOs::applyDeltaRotation(), and qmcplusplus::TEST_CASE().

 {
   assert(delta_param.size() == act_rot_inds.size());
   assert(old_param.size() == full_rot_inds.size());
   assert(new_param.size() == full_rot_inds.size());
 
   const size_t nmo = new_rot_mat.rows();
   assert(new_rot_mat.rows() == new_rot_mat.cols());
 
   ValueMatrix old_rot_mat(nmo, nmo);
 
   constructAntiSymmetricMatrix(full_rot_inds, old_param, old_rot_mat);
   exponentiate_antisym_matrix(old_rot_mat);
 
   ValueMatrix delta_rot_mat(nmo, nmo);
 
   constructAntiSymmetricMatrix(act_rot_inds, delta_param, delta_rot_mat);
   exponentiate_antisym_matrix(delta_rot_mat);
 
   // Apply delta rotation to old rotation.
   BLAS::gemm('N', 'N', nmo, nmo, nmo, 1.0, delta_rot_mat.data(), nmo, old_rot_mat.data(), nmo, 0.0, new_rot_mat.data(),
              nmo);
 
   ValueMatrix log_rot_mat(nmo, nmo);
   log_antisym_matrix(new_rot_mat, log_rot_mat);
   extractParamsFromAntiSymmetricMatrix(full_rot_inds, log_rot_mat, new_param);
 }

◆ createResource()

void createResource ( ResourceCollection & collection ) const

overridevirtual

initialize a shared resource and hand it to collection

Reimplemented from SPOSet.

Definition at line 1727 of file RotatedSPOs.cpp.

References RotatedSPOs::Phi_.

Referenced by qmcplusplus::TEST_CASE().

1727 { Phi_->createResource(collection); }

qmcplusplus::RotatedSPOs::Phi_

std::unique_ptr< SPOSet > Phi_

Definition: RotatedSPOs.h:119

◆ createRotationIndices()

void createRotationIndices	(	int	nel,
		int	nmo,
		RotationIndices &	rot_indices
	)

static

Definition at line 48 of file RotatedSPOs.cpp.

Referenced by RotatedSPOs::buildOptVariables(), and qmcplusplus::TEST_CASE().

 {
   for (int i = 0; i < nel; i++)
     for (int j = nel; j < nmo; j++)
       rot_indices.emplace_back(i, j);
 }

◆ createRotationIndicesFull()

void createRotationIndicesFull	(	int	nel,
		int	nmo,
		RotationIndices &	rot_indices
	)

static

Definition at line 55 of file RotatedSPOs.cpp.

Referenced by RotatedSPOs::buildOptVariables(), and qmcplusplus::TEST_CASE().

 {
   rot_indices.reserve(nmo * (nmo - 1) / 2);
 
   // start with core-active rotations - put them at the beginning of the list
   // so it matches the other list of rotation indices
   for (int i = 0; i < nel; i++)
     for (int j = nel; j < nmo; j++)
       rot_indices.emplace_back(i, j);
 
   // Add core-core rotations - put them at the end of the list
   for (int i = 0; i < nel; i++)
     for (int j = i + 1; j < nel; j++)
       rot_indices.emplace_back(i, j);
 
   // Add active-active rotations - put them at the end of the list
   for (int i = nel; i < nmo; i++)
     for (int j = i + 1; j < nmo; j++)
       rot_indices.emplace_back(i, j);
 }

◆ evaluate_notranspose() [1/3]

void evaluate_notranspose	(	const ParticleSet &	P,
		int	first,
		int	last,
		ValueMatrix &	logdet,
		GradMatrix &	dlogdet,
		ValueMatrix &	d2logdet
	)

inlineoverridevirtual

evaluate the values, gradients and laplacians of this single-particle orbital for [first,last) particles

Parameters

[in]	P	current ParticleSet
[in]	first	starting index of the particles
[in]	last	ending index of the particles
[out]	logdet	determinant matrix to be inverted
[out]	dlogdet	gradients
[out]	d2logdet	laplacians

Implements SPOSet.

Definition at line 341 of file RotatedSPOs.h.

References RotatedSPOs::Phi_.

   {
     Phi_->evaluate_notranspose(P, first, last, logdet, dlogdet, d2logdet);
   }

◆ evaluate_notranspose() [2/3]

void evaluate_notranspose	(	const ParticleSet &	P,
		int	first,
		int	last,
		ValueMatrix &	logdet,
		GradMatrix &	dlogdet,
		HessMatrix &	grad_grad_logdet
	)

inlineoverridevirtual

evaluate the values, gradients and hessians of this single-particle orbital for [first,last) particles

Parameters

P	current ParticleSet
first	starting index of the particles
last	ending index of the particles
logdet	determinant matrix to be inverted
dlogdet	gradients
grad_grad_logdet	hessians

Reimplemented from SPOSet.

Definition at line 356 of file RotatedSPOs.h.

References RotatedSPOs::Phi_.

   {
     Phi_->evaluate_notranspose(P, first, last, logdet, dlogdet, grad_grad_logdet);
   }

◆ evaluate_notranspose() [3/3]

void evaluate_notranspose	(	const ParticleSet &	P,
		int	first,
		int	last,
		ValueMatrix &	logdet,
		GradMatrix &	dlogdet,
		HessMatrix &	grad_grad_logdet,
		GGGMatrix &	grad_grad_grad_logdet
	)

inlineoverridevirtual

evaluate the values, gradients, hessians and third derivatives of this single-particle orbital for [first,last) particles

Parameters

P	current ParticleSet
first	starting index of the particles
last	ending index of the particles
logdet	determinant matrix to be inverted
dlogdet	gradients
grad_grad_logdet	hessians
grad_grad_grad_logdet	third derivatives

Reimplemented from SPOSet.

Definition at line 366 of file RotatedSPOs.h.

References RotatedSPOs::Phi_.

   {
     Phi_->evaluate_notranspose(P, first, last, logdet, dlogdet, grad_grad_logdet, grad_grad_grad_logdet);
   }

◆ evaluate_spin()

void evaluate_spin	(	const ParticleSet &	P,
		int	iat,
		ValueVector &	psi,
		ValueVector &	dpsi
	)

inlineoverridevirtual

evaluate the values of this single-particle orbital set

Parameters

P	current ParticleSet
iat	active particle
psi	values of the SPO

Reimplemented from SPOSet.

Definition at line 351 of file RotatedSPOs.h.

References RotatedSPOs::Phi_.

Referenced by qmcplusplus::TEST_CASE().

   {
     Phi_->evaluate_spin(P, iat, psi, dspin_psi);
   }

◆ evaluateDerivatives() [1/2]

void evaluateDerivatives	(	ParticleSet &	P,
		const opt_variables_type &	optvars,
		Vector< ValueType > &	dlogpsi,
		Vector< ValueType > &	dhpsioverpsi,
		const int &	FirstIndex,
		const int &	LastIndex
	)

overridevirtual

Parameter derivatives of the wavefunction and the Laplacian of the wavefunction.

Reimplemented from SPOSet.

Definition at line 770 of file RotatedSPOs.cpp.

References qmcplusplus::Units::distance::A, B(), RotatedSPOs::Bbar, RotatedSPOs::d2psiM_all, qmcplusplus::dot(), RotatedSPOs::dpsiM_all, ParticleSet::G, BLAS::gemm(), qmcplusplus::Invert(), ParticleSet::L, RotatedSPOs::m_act_rot_inds_, RotatedSPOs::myG_J, RotatedSPOs::myG_temp, RotatedSPOs::myL_J, RotatedSPOs::myL_temp, SPOSet::myVars, RotatedSPOs::Phi_, RotatedSPOs::psiM_all, RotatedSPOs::psiM_inv, Vector< T, Alloc >::resize(), VariableSet::size(), and VariableSet::where().

 {
   const size_t nel = LastIndex - FirstIndex;
   const size_t nmo = Phi_->getOrbitalSetSize();
 
   //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~PART1
   myG_temp.resize(nel);
   myG_J.resize(nel);
   myL_temp.resize(nel);
   myL_J.resize(nel);
 
   myG_temp = 0;
   myG_J    = 0;
   myL_temp = 0;
   myL_J    = 0;
 
   Bbar.resize(nel, nmo);
   psiM_inv.resize(nel, nel);
   psiM_all.resize(nel, nmo);
   dpsiM_all.resize(nel, nmo);
   d2psiM_all.resize(nel, nmo);
 
   Bbar       = 0;
   psiM_inv   = 0;
   psiM_all   = 0;
   dpsiM_all  = 0;
   d2psiM_all = 0;
 
 
   Phi_->evaluate_notranspose(P, FirstIndex, LastIndex, psiM_all, dpsiM_all, d2psiM_all);
 
   for (int i = 0; i < nel; i++)
     for (int j = 0; j < nel; j++)
       psiM_inv(i, j) = psiM_all(i, j);
 
   Invert(psiM_inv.data(), nel, nel);
 
   //current value of Gradient and Laplacian
   // gradient components
   for (int a = 0; a < nel; a++)
     for (int i = 0; i < nel; i++)
       for (int k = 0; k < 3; k++)
         myG_temp[a][k] += psiM_inv(i, a) * dpsiM_all(a, i)[k];
   // laplacian components
   for (int a = 0; a < nel; a++)
   {
     for (int i = 0; i < nel; i++)
       myL_temp[a] += psiM_inv(i, a) * d2psiM_all(a, i);
   }
 
   // calculation of myG_J which will be used to represent \frac{\nabla\psi_{J}}{\psi_{J}}
   // calculation of myL_J will be used to represent \frac{\nabla^2\psi_{J}}{\psi_{J}}
   // IMPORTANT NOTE:  The value of P.L holds \nabla^2 ln[\psi] but we need  \frac{\nabla^2 \psi}{\psi} and this is what myL_J will hold
   for (int a = 0, iat = FirstIndex; a < nel; a++, iat++)
   {
     myG_J[a] = (P.G[iat] - myG_temp[a]);
     myL_J[a] = (P.L[iat] + dot(P.G[iat], P.G[iat]) - myL_temp[a]);
   }
   //possibly replace wit BLAS calls
   for (int i = 0; i < nel; i++)
     for (int j = 0; j < nmo; j++)
       Bbar(i, j) = d2psiM_all(i, j) + ValueType(2.0) * ValueType(dot(myG_J[i], dpsiM_all(i, j))) +
           ValueType(myL_J[i]) * psiM_all(i, j);
 
 
   //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~PART2
   const ValueType* const A(psiM_all.data());
   const ValueType* const Ainv(psiM_inv.data());
   const ValueType* const B(Bbar.data());
   SPOSet::ValueMatrix T;
   SPOSet::ValueMatrix Y1;
   SPOSet::ValueMatrix Y2;
   SPOSet::ValueMatrix Y3;
   SPOSet::ValueMatrix Y4;
   T.resize(nel, nmo);
   Y1.resize(nel, nel);
   Y2.resize(nel, nmo);
   Y3.resize(nel, nmo);
   Y4.resize(nel, nmo);
 
 
   BLAS::gemm('N', 'N', nmo, nel, nel, ValueType(1.0), A, nmo, Ainv, nel, ValueType(0.0), T.data(), nmo);
   BLAS::gemm('N', 'N', nel, nel, nel, ValueType(1.0), B, nmo, Ainv, nel, ValueType(0.0), Y1.data(), nel);
   BLAS::gemm('N', 'N', nmo, nel, nel, ValueType(1.0), T.data(), nmo, Y1.data(), nel, ValueType(0.0), Y2.data(), nmo);
   BLAS::gemm('N', 'N', nmo, nel, nel, ValueType(1.0), B, nmo, Ainv, nel, ValueType(0.0), Y3.data(), nmo);
 
   //possibly replace with BLAS call
   Y4 = Y3 - Y2;
 
   for (int i = 0; i < myVars.size(); i++)
   {
     int kk = myVars.where(i);
     if (kk >= 0)
     {
       int j       = IsComplex_t<ValueType>::value ? i / 2 : i;
       const int p = m_act_rot_inds_.at(j).first;
       const int q = m_act_rot_inds_.at(j).second;
 
       ValueType pref1 = ValueType(1.0);
       ValueType pref2 = ValueType(-0.5);
 #ifdef QMC_COMPLEX
       if (i % 2 == 1)
       {
         pref1 *= ComplexType(0, 1);
         pref2 *= ComplexType(0, 1);
       }
 #endif
       dlogpsi[kk] += pref1 * T(p, q);
       dhpsioverpsi[kk] += pref2 * Y4(p, q);
     }
   }
 }

◆ evaluateDerivatives() [2/2]

void evaluateDerivatives	(	ParticleSet &	P,
		const opt_variables_type &	optvars,
		Vector< ValueType > &	dlogpsi,
		Vector< ValueType > &	dhpsioverpsi,
		const ValueType &	psiCurrent,
		const std::vector< ValueType > &	Coeff,
		const std::vector< size_t > &	C2node_up,
		const std::vector< size_t > &	C2node_dn,
		const ValueVector &	detValues_up,
		const ValueVector &	detValues_dn,
		const GradMatrix &	grads_up,
		const GradMatrix &	grads_dn,
		const ValueMatrix &	lapls_up,
		const ValueMatrix &	lapls_dn,
		const ValueMatrix &	M_up,
		const ValueMatrix &	M_dn,
		const ValueMatrix &	Minv_up,
		const ValueMatrix &	Minv_dn,
		const GradMatrix &	B_grad,
		const ValueMatrix &	B_lapl,
		const std::vector< int > &	detData_up,
		const size_t	N1,
		const size_t	N2,
		const size_t	NP1,
		const size_t	NP2,
		const std::vector< std::vector< int >> &	lookup_tbl
	)

overridevirtual

Evaluate the derivative of the optimized orbitals with respect to the parameters this is used only for MSD, to be refined for better serving both single and multi SD.

Reimplemented from SPOSet.

Definition at line 888 of file RotatedSPOs.cpp.

References qmcplusplus::dot(), ParticleSet::first(), ParticleSet::G, ParticleSet::getTotalNum(), ParticleSet::L, ParticleSet::last(), RotatedSPOs::myG_J, RotatedSPOs::myG_temp, RotatedSPOs::myL_J, RotatedSPOs::myL_temp, SPOSet::myVars, RotatedSPOs::Phi_, VariableSet::recompute(), Vector< T, Alloc >::resize(), VariableSet::size(), Vector< T, Alloc >::size(), RotatedSPOs::table_method_eval(), and VariableSet::where().

 {
 #ifndef QMC_COMPLEX
   bool recalculate(false);
   for (int k = 0; k < myVars.size(); ++k)
   {
     int kk = myVars.where(k);
     if (kk < 0)
       continue;
     if (optvars.recompute(kk))
       recalculate = true;
   }
   if (recalculate)
   {
     ParticleSet::ParticleGradient myG_temp, myG_J;
     ParticleSet::ParticleLaplacian myL_temp, myL_J;
     const int NP = P.getTotalNum();
     myG_temp.resize(NP);
     myG_temp = 0.0;
     myL_temp.resize(NP);
     myL_temp = 0.0;
     myG_J.resize(NP);
     myG_J = 0.0;
     myL_J.resize(NP);
     myL_J            = 0.0;
     const size_t nmo = Phi_->getOrbitalSetSize();
     const size_t nel = P.last(0) - P.first(0);
 
     const RealType* restrict C_p = Coeff.data();
     for (int i = 0; i < Coeff.size(); i++)
     {
       const size_t upC     = C2node_up[i];
       const size_t dnC     = C2node_dn[i];
       const ValueType tmp1 = C_p[i] * detValues_dn[dnC];
       const ValueType tmp2 = C_p[i] * detValues_up[upC];
       for (size_t k = 0, j = N1; k < NP1; k++, j++)
       {
         myG_temp[j] += tmp1 * grads_up(upC, k);
         myL_temp[j] += tmp1 * lapls_up(upC, k);
       }
       for (size_t k = 0, j = N2; k < NP2; k++, j++)
       {
         myG_temp[j] += tmp2 * grads_dn(dnC, k);
         myL_temp[j] += tmp2 * lapls_dn(dnC, k);
       }
     }
 
     myG_temp *= (1 / psiCurrent);
     myL_temp *= (1 / psiCurrent);
 
     // calculation of myG_J which will be used to represent \frac{\nabla\psi_{J}}{\psi_{J}}
     // calculation of myL_J will be used to represent \frac{\nabla^2\psi_{J}}{\psi_{J}}
     // IMPORTANT NOTE:  The value of P.L holds \nabla^2 ln[\psi] but we need  \frac{\nabla^2 \psi}{\psi} and this is what myL_J will hold
     for (int iat = 0; iat < (myL_temp.size()); iat++)
     {
       myG_J[iat] = (P.G[iat] - myG_temp[iat]);
       myL_J[iat] = (P.L[iat] + dot(P.G[iat], P.G[iat]) - myL_temp[iat]);
     }
 
 
     table_method_eval(dlogpsi, dhpsioverpsi, myL_J, myG_J, nel, nmo, psiCurrent, Coeff, C2node_up, C2node_dn,
                       detValues_up, detValues_dn, grads_up, grads_dn, lapls_up, lapls_dn, M_up, M_dn, Minv_up, Minv_dn,
                       B_grad, B_lapl, detData_up, N1, N2, NP1, NP2, lookup_tbl);
   }
 #endif
 }

◆ evaluateDerivativesWF() [1/2]

void evaluateDerivativesWF	(	ParticleSet &	P,
		const opt_variables_type &	optvars,
		Vector< ValueType > &	dlogpsi,
		int	FirstIndex,
		int	LastIndex
	)

overridevirtual

Parameter derivatives of the wavefunction.

Reimplemented from SPOSet.

Definition at line 716 of file RotatedSPOs.cpp.

References qmcplusplus::Units::distance::A, RotatedSPOs::d2psiM_all, RotatedSPOs::dpsiM_all, BLAS::gemm(), qmcplusplus::Invert(), RotatedSPOs::m_act_rot_inds_, SPOSet::myVars, RotatedSPOs::Phi_, RotatedSPOs::psiM_all, RotatedSPOs::psiM_inv, VariableSet::size(), and VariableSet::where().

 {
   const size_t nel = LastIndex - FirstIndex;
   const size_t nmo = Phi_->getOrbitalSetSize();
 
   //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~PART1
 
   psiM_inv.resize(nel, nel);
   psiM_all.resize(nel, nmo);
   dpsiM_all.resize(nel, nmo);
   d2psiM_all.resize(nel, nmo);
 
   psiM_inv   = 0;
   psiM_all   = 0;
   dpsiM_all  = 0;
   d2psiM_all = 0;
 
   Phi_->evaluate_notranspose(P, FirstIndex, LastIndex, psiM_all, dpsiM_all, d2psiM_all);
 
   for (int i = 0; i < nel; i++)
     for (int j = 0; j < nel; j++)
       psiM_inv(i, j) = psiM_all(i, j);
 
   Invert(psiM_inv.data(), nel, nel);
 
   //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~PART2
   const ValueType* const A(psiM_all.data());
   const ValueType* const Ainv(psiM_inv.data());
   SPOSet::ValueMatrix T;
   T.resize(nel, nmo);
 
   BLAS::gemm('N', 'N', nmo, nel, nel, ValueType(1.0), A, nmo, Ainv, nel, ValueType(0.0), T.data(), nmo);
 
   for (int i = 0; i < myVars.size(); i++)
   {
     int kk = myVars.where(i);
     if (kk >= 0)
     {
       int j       = IsComplex_t<ValueType>::value ? i / 2 : i;
       const int p = m_act_rot_inds_.at(j).first;
       const int q = m_act_rot_inds_.at(j).second;
       dlogpsi[kk] = T(p, q);
 #ifdef QMC_COMPLEX
       if (i % 2 == 1)
         dlogpsi[kk] *= ComplexType(0, 1);
 #endif
     }
   }
 }

◆ evaluateDerivativesWF() [2/2]

void evaluateDerivativesWF	(	ParticleSet &	P,
		const opt_variables_type &	optvars,
		Vector< ValueType > &	dlogpsi,
		const QTFull::ValueType &	psiCurrent,
		const std::vector< ValueType > &	Coeff,
		const std::vector< size_t > &	C2node_up,
		const std::vector< size_t > &	C2node_dn,
		const ValueVector &	detValues_up,
		const ValueVector &	detValues_dn,
		const ValueMatrix &	M_up,
		const ValueMatrix &	M_dn,
		const ValueMatrix &	Minv_up,
		const ValueMatrix &	Minv_dn,
		const std::vector< int > &	detData_up,
		const std::vector< std::vector< int >> &	lookup_tbl
	)

overridevirtual

Evaluate the derivative of the optimized orbitals with respect to the parameters this is used only for MSD, to be refined for better serving both single and multi SD.

Reimplemented from SPOSet.

Definition at line 981 of file RotatedSPOs.cpp.

References ParticleSet::first(), ParticleSet::last(), SPOSet::myVars, RotatedSPOs::Phi_, VariableSet::recompute(), VariableSet::size(), RotatedSPOs::table_method_evalWF(), and VariableSet::where().

 {
 #ifndef QMC_COMPLEX
   bool recalculate(false);
   for (int k = 0; k < myVars.size(); ++k)
   {
     int kk = myVars.where(k);
     if (kk < 0)
       continue;
     if (optvars.recompute(kk))
       recalculate = true;
   }
   if (recalculate)
   {
     const size_t nmo = Phi_->getOrbitalSetSize();
     const size_t nel = P.last(0) - P.first(0);
 
     table_method_evalWF(dlogpsi, nel, nmo, psiCurrent, Coeff, C2node_up, C2node_dn, detValues_up, detValues_dn, M_up,
                         M_dn, Minv_up, Minv_dn, detData_up, lookup_tbl);
   }
 #endif
 }

◆ evaluateDerivRatios()

void evaluateDerivRatios	(	const VirtualParticleSet &	VP,
		const opt_variables_type &	optvars,
		ValueVector &	psi,
		const ValueVector &	psiinv,
		std::vector< ValueType > &	ratios,
		Matrix< ValueType > &	dratios,
		int	FirstIndex,
		int	LastIndex
	)

overridevirtual

Determinant ratios and parameter derivatives of the wavefunction for virtual moves.

Reimplemented from SPOSet.

Definition at line 629 of file RotatedSPOs.cpp.

References qmcplusplus::Units::distance::A, RotatedSPOs::d2psiM_all, RotatedSPOs::dpsiM_all, BLAS::gemm(), VirtualParticleSet::getRefPS(), VirtualParticleSet::getTotalNum(), qmcplusplus::Invert(), RotatedSPOs::m_act_rot_inds_, SPOSet::myVars, RotatedSPOs::Phi_, RotatedSPOs::psiM_all, RotatedSPOs::psiM_inv, VirtualParticleSet::refPtcl, VariableSet::size(), and VariableSet::where().

 {
   Phi_->evaluateDetRatios(VP, psi, psiinv, ratios);
 
   const size_t nel = LastIndex - FirstIndex;
   const size_t nmo = Phi_->getOrbitalSetSize();
 
   psiM_inv.resize(nel, nel);
   psiM_all.resize(nel, nmo);
   dpsiM_all.resize(nel, nmo);
   d2psiM_all.resize(nel, nmo);
 
   psiM_inv   = 0;
   psiM_all   = 0;
   dpsiM_all  = 0;
   d2psiM_all = 0;
 
   const ParticleSet& P = VP.getRefPS();
   int iel              = VP.refPtcl;
 
   Phi_->evaluate_notranspose(P, FirstIndex, LastIndex, psiM_all, dpsiM_all, d2psiM_all);
 
   for (int i = 0; i < nel; i++)
     for (int j = 0; j < nel; j++)
       psiM_inv(i, j) = psiM_all(i, j);
 
   Invert(psiM_inv.data(), nel, nel);
 
   const ValueType* const A(psiM_all.data());
   const ValueType* const Ainv(psiM_inv.data());
   SPOSet::ValueMatrix T_orig;
   T_orig.resize(nel, nmo);
 
   BLAS::gemm('N', 'N', nmo, nel, nel, ValueType(1.0), A, nmo, Ainv, nel, ValueType(0.0), T_orig.data(), nmo);
 
   SPOSet::ValueMatrix T;
   T.resize(nel, nmo);
 
   ValueVector tmp_psi;
   tmp_psi.resize(nmo);
 
   for (int iat = 0; iat < VP.getTotalNum(); iat++)
   {
     Phi_->evaluateValue(VP, iat, tmp_psi);
 
     for (int j = 0; j < nmo; j++)
       psiM_all(iel - FirstIndex, j) = tmp_psi[j];
 
     for (int i = 0; i < nel; i++)
       for (int j = 0; j < nel; j++)
         psiM_inv(i, j) = psiM_all(i, j);
 
     Invert(psiM_inv.data(), nel, nel);
 
     const ValueType* const A(psiM_all.data());
     const ValueType* const Ainv(psiM_inv.data());
 
     // The matrix A is rectangular.  Ainv is the inverse of the square part of the matrix.
     // The multiply of Ainv and the square part of A is just the identity.
     // This multiply could be reduced to Ainv and the non-square part of A.
     BLAS::gemm('N', 'N', nmo, nel, nel, ValueType(1.0), A, nmo, Ainv, nel, ValueType(0.0), T.data(), nmo);
 
     for (int i = 0; i < myVars.size(); i++)
     {
       int kk = myVars.where(i);
       if (kk >= 0)
       {
         int j            = IsComplex_t<ValueType>::value ? i / 2 : i;
         const int p      = m_act_rot_inds_.at(j).first;
         const int q      = m_act_rot_inds_.at(j).second;
         dratios(iat, kk) = T(p, q) - T_orig(p, q); // dratio size is (nknot, num_vars)
 #ifdef QMC_COMPLEX
         if (i % 2 == 1)
           dratios(iat, kk) *= ComplexType(0, 1);
 #endif
       }
     }
   }
 }

◆ evaluateDetRatios()

void evaluateDetRatios	(	const VirtualParticleSet &	VP,
		ValueVector &	psi,
		const ValueVector &	psiinv,
		std::vector< ValueType > &	ratios
	)

inlineoverridevirtual

evaluate determinant ratios for virtual moves, e.g., sphere move for nonlocalPP

Parameters

VP	virtual particle set
psi	values of the SPO, used as a scratch space if needed
psiinv	the row of inverse slater matrix corresponding to the particle moved virtually
ratios	return determinant ratios

Reimplemented from SPOSet.

Definition at line 302 of file RotatedSPOs.h.

References RotatedSPOs::Phi_.

   {
     Phi_->evaluateDetRatios(VP, psi, psiinv, ratios);
   }

◆ evaluateGradSource() [1/2]

void evaluateGradSource	(	const ParticleSet &	P,
		int	first,
		int	last,
		const ParticleSet &	source,
		int	iat_src,
		GradMatrix &	gradphi
	)

inlineoverridevirtual

evaluate the gradients of this single-particle orbital for [first,last) target particles with respect to the given source particle

Parameters

P	current ParticleSet
first	starting index of the particles
last	ending index of the particles
iat_src	source particle index
gradphi	gradients

Reimplemented from SPOSet.

Definition at line 377 of file RotatedSPOs.h.

References RotatedSPOs::Phi_.

   {
     Phi_->evaluateGradSource(P, first, last, source, iat_src, grad_phi);
   }

◆ evaluateGradSource() [2/2]

void evaluateGradSource	(	const ParticleSet &	P,
		int	first,
		int	last,
		const ParticleSet &	source,
		int	iat_src,
		GradMatrix &	grad_phi,
		HessMatrix &	grad_grad_phi,
		GradMatrix &	grad_lapl_phi
	)

inlineoverridevirtual

evaluate the gradients of values, gradients, laplacians of this single-particle orbital for [first,last) target particles with respect to the given source particle

Parameters

P	current ParticleSet
first	starting index of the particles
last	ending index of the particles
iat_src	source particle index
gradphi	gradients of values
grad_grad_phi	gradients of gradients
grad_lapl_phi	gradients of laplacians

Reimplemented from SPOSet.

Definition at line 387 of file RotatedSPOs.h.

References RotatedSPOs::Phi_.

   {
     Phi_->evaluateGradSource(P, first, last, source, iat_src, grad_phi, grad_grad_phi, grad_lapl_phi);
   }

◆ evaluateValue()

void evaluateValue	(	const ParticleSet &	P,
		int	iat,
		ValueVector &	psi
	)

inlineoverridevirtual

evaluate the values of this single-particle orbital set

Parameters

P	current ParticleSet
iat	active particle
psi	values of the SPO

Implements SPOSet.

Definition at line 278 of file RotatedSPOs.h.

References SPOSet::OrbitalSetSize, and RotatedSPOs::Phi_.

   {
     assert(psi.size() <= OrbitalSetSize);
     Phi_->evaluateValue(P, iat, psi);
   }

◆ evaluateVGH()

void evaluateVGH	(	const ParticleSet &	P,
		int	iat,
		ValueVector &	psi,
		GradVector &	dpsi,
		HessVector &	grad_grad_psi
	)

inlineoverridevirtual

evaluate the values, gradients and hessians of this single-particle orbital set

Parameters

P	current ParticleSet
iat	active particle
psi	values of the SPO
dpsi	gradients of the SPO
grad_grad_psi	hessians of the SPO

Reimplemented from SPOSet.

Definition at line 319 of file RotatedSPOs.h.

References SPOSet::OrbitalSetSize, and RotatedSPOs::Phi_.

   {
     assert(psi.size() <= OrbitalSetSize);
     Phi_->evaluateVGH(P, iat, psi, dpsi, grad_grad_psi);
   }

◆ evaluateVGHGH()

void evaluateVGHGH	(	const ParticleSet &	P,
		int	iat,
		ValueVector &	psi,
		GradVector &	dpsi,
		HessVector &	grad_grad_psi,
		GGGVector &	grad_grad_grad_psi
	)

inlineoverridevirtual

evaluate the values, gradients, hessians, and grad hessians of this single-particle orbital set

Parameters

P	current ParticleSet
iat	active particle
psi	values of the SPO
dpsi	gradients of the SPO
grad_grad_psi	hessians of the SPO
grad_grad_grad_psi	grad hessians of the SPO

Reimplemented from SPOSet.

Definition at line 330 of file RotatedSPOs.h.

References RotatedSPOs::Phi_.

   {
     Phi_->evaluateVGHGH(P, iat, psi, dpsi, grad_grad_psi, grad_grad_grad_psi);
   }

◆ evaluateVGL()

void evaluateVGL	(	const ParticleSet &	P,
		int	iat,
		ValueVector &	psi,
		GradVector &	dpsi,
		ValueVector &	d2psi
	)

inlineoverridevirtual

evaluate the values, gradients and laplacians of this single-particle orbital set

Parameters

P	current ParticleSet
iat	active particle
psi	values of the SPO
dpsi	gradients of the SPO
d2psi	laplacians of the SPO

Implements SPOSet.

Definition at line 285 of file RotatedSPOs.h.

References SPOSet::OrbitalSetSize, and RotatedSPOs::Phi_.

   {
     assert(psi.size() <= OrbitalSetSize);
     Phi_->evaluateVGL(P, iat, psi, dpsi, d2psi);
   }

◆ evaluateVGL_spin()

void evaluateVGL_spin	(	const ParticleSet &	P,
		int	iat,
		ValueVector &	psi,
		GradVector &	dpsi,
		ValueVector &	d2psi,
		ValueVector &	dspin
	)

inlineoverridevirtual

evaluate the values, gradients and laplacians and spin gradient of this single-particle orbital set

Parameters

P	current ParticleSet
iat	active particle
psi	values of the SPO
dpsi	gradients of the SPO
d2psi	laplacians of the SPO
dspin	spin gradients of the SPO

Reimplemented from SPOSet.

Definition at line 291 of file RotatedSPOs.h.

References SPOSet::OrbitalSetSize, and RotatedSPOs::Phi_.

   {
     assert(psi.size() <= OrbitalSetSize);
     Phi_->evaluateVGL_spin(P, iat, psi, dpsi, d2psi, dspin_psi);
   }

◆ exponentiate_antisym_matrix()

void exponentiate_antisym_matrix ( ValueMatrix & mat )

static

Definition at line 476 of file RotatedSPOs.cpp.

References qmcplusplus::copy_with_complex_cast(), qmcplusplus::exp(), BLAS::gemm(), LAPACK::heev(), qmcplusplus::imag(), qmcplusplus::Units::force::N, qmcplusplus::n, and BLAS::UPLO.

Referenced by RotatedSPOs::apply_rotation(), RotatedSPOs::applyFullRotation(), RotatedSPOs::constructDeltaRotation(), and qmcplusplus::TEST_CASE().

 {
   const int n = mat.rows();
   std::vector<std::complex<RealType>> mat_h(n * n, 0);
   std::vector<RealType> eval(n, 0);
   std::vector<std::complex<RealType>> work(2 * n, 0);
   std::vector<RealType> rwork(3 * n, 0);
   std::vector<std::complex<RealType>> mat_d(n * n, 0);
   std::vector<std::complex<RealType>> mat_t(n * n, 0);
   // exponentiating e^X = e^iY (Y hermitian)
   // i(-iX) = X, so -iX is hermitian
   // diagonalize -iX = UDU^T, exponentiate e^iD, and return U e^iD U^T
   // construct hermitian analogue of mat by multiplying by -i
   for (int i = 0; i < n; ++i)
   {
     for (int j = i; j < n; ++j)
     {
       //This two liner does several things.  The first is it unpacks row-major mat into column major format.
       //Second, it builds the hermitian matrix -i*mat.  Third, it relies on the hermiticity of -i*mat to
       //fill the entire -i*mat matrix (in column major form) by iterating over the upper diagonal only.
       mat_h[i + n * j] = std::complex<RealType>(std::imag(mat[i][j]), -1.0 * std::real(mat[i][j]));
       mat_h[j + n * i] = std::complex<RealType>(-std::imag(mat[i][j]), 1.0 * std::real(mat[i][j]));
     }
   }
   // diagonalize the matrix
   char JOBZ('V'); //compute eigenvalues and eigenvectors.
   char UPLO('U'); //store upper triangle of A.
   int N(n);
   int LDA(n);
   int LWORK(2 * n);
   int info = 0;
   //Ax=lamda x.  For given A=mat_h, returns the list of *real* eigenvalues lamda=eval, and
   //the matrix of eigenvectors V=mat_h (overwritten).  Eigenvectors are columns of this matrix.
   //The eigendecomposition of this matrix is thus V*LAMBDA*V^dagger.
   LAPACK::heev(JOBZ, UPLO, N, &mat_h.at(0), LDA, &eval.at(0), &work.at(0), LWORK, &rwork.at(0), info);
   if (info != 0)
   {
     std::ostringstream msg;
     msg << "heev failed with info = " << info << " in RotatedSPOs::exponentiate_antisym_matrix";
     throw std::runtime_error(msg.str());
   }
   // iterate through diagonal matrix, exponentiate terms
   for (int i = 0; i < n; ++i)
   {
     for (int j = 0; j < n; ++j)
     {
       mat_d[i + j * n] = (i == j) ? std::exp(std::complex<RealType>(0.0, eval[i])) : std::complex<RealType>(0.0, 0.0);
     }
   }
   // perform matrix multiplication
   // Everything here is column major, so normal BLAS ordering and conventions apply.
 
   // e^{LAMBDA} * V^dagger
   BLAS::gemm('N', 'C', n, n, n, std::complex<RealType>(1.0, 0), &mat_d.at(0), n, &mat_h.at(0), n,
              std::complex<RealType>(0.0, 0.0), &mat_t.at(0), n);
   // V * [ e^{LAMBDA} * V^dagger ] = exp(K)
   BLAS::gemm('N', 'N', n, n, n, std::complex<RealType>(1.0, 0), &mat_h.at(0), n, &mat_t.at(0), n,
              std::complex<RealType>(0.0, 0.0), &mat_d.at(0), n);
   for (int i = 0; i < n; ++i)
     for (int j = 0; j < n; ++j)
       //Copy [exp(K)]_ij in column major form to mat in row major form.
       //For real build, the imaginary part is discarded.  For complex build,
       //the entire complex entry is copied.
       copy_with_complex_cast(mat_d[i + n * j], mat[i][j]);
 }

◆ extractOptimizableObjectRefs()

void extractOptimizableObjectRefs ( UniqueOptObjRefs & opt_obj_refs )

inlineoverridevirtual

extract underlying OptimizableObject references

Parameters

opt_obj_refs aggregated list of optimizable object references

Reimplemented from SPOSet.

Definition at line 255 of file RotatedSPOs.h.

References UniqueOptObjRefs::push_back().

255 { opt_obj_refs.push_back(*this); }

◆ extractParamsFromAntiSymmetricMatrix()

void extractParamsFromAntiSymmetricMatrix	(	const RotationIndices &	rot_indices,
		const ValueMatrix &	rot_mat,
		std::vector< ValueType > &	param
	)

static

Definition at line 97 of file RotatedSPOs.cpp.

Referenced by RotatedSPOs::constructDeltaRotation(), and qmcplusplus::TEST_CASE().

 {
   assert(rot_indices.size() == param.size());
   // Assumes rot_mat is of the correct size
 
   for (int i = 0; i < rot_indices.size(); i++)
   {
     const int p = rot_indices[i].first;
     const int q = rot_indices[i].second;
     param[i]    = rot_mat[q][p];
   }
 }

◆ extractPhiRefList()

RefVectorWithLeader< SPOSet > extractPhiRefList ( const RefVectorWithLeader< SPOSet > & spo_list )

staticprivate

Definition at line 1743 of file RotatedSPOs.cpp.

References RefVectorWithLeader< T >::getCastedElement(), RefVectorWithLeader< T >::getCastedLeader(), and RotatedSPOs::Phi_.

Referenced by RotatedSPOs::acquireResource(), RotatedSPOs::mw_evaluate_notranspose(), RotatedSPOs::mw_evaluateDetRatios(), RotatedSPOs::mw_evaluateValue(), RotatedSPOs::mw_evaluateVGL(), RotatedSPOs::mw_evaluateVGLandDetRatioGrads(), RotatedSPOs::mw_evaluateVGLandDetRatioGradsWithSpin(), RotatedSPOs::mw_evaluateVGLWithSpin(), and RotatedSPOs::releaseResource().

 {
   auto& spo_leader = spo_list.getCastedLeader<RotatedSPOs>();
   const auto nw    = spo_list.size();
   RefVectorWithLeader<SPOSet> phi_list(*spo_leader.Phi_);
   phi_list.reserve(nw);
   for (int iw = 0; iw < nw; iw++)
   {
     RotatedSPOs& rot = spo_list.getCastedElement<RotatedSPOs>(iw);
     phi_list.emplace_back(*rot.Phi_);
   }
   return phi_list;
 }

◆ getClassName()

std::string getClassName ( ) const

inlineoverridevirtual

return class name

Implements SPOSet.

Definition at line 36 of file RotatedSPOs.h.

36 { return "RotatedSPOs"; }

◆ hasIonDerivs()

bool hasIonDerivs ( ) const

inlineoverridevirtual

Query if this SPOSet has an explicit ion dependence.

returns true if it does.

Reimplemented from SPOSet.

Definition at line 39 of file RotatedSPOs.h.

References RotatedSPOs::Phi_.

39 { return Phi_->hasIonDerivs(); }

qmcplusplus::RotatedSPOs::Phi_

std::unique_ptr< SPOSet > Phi_

Definition: RotatedSPOs.h:119

◆ isOMPoffload()

bool isOMPoffload ( ) const

inlineoverridevirtual

Query if this SPOSet uses OpenMP offload.

Reimplemented from SPOSet.

Definition at line 38 of file RotatedSPOs.h.

References RotatedSPOs::Phi_.

38 { return Phi_->isOMPoffload(); }

qmcplusplus::RotatedSPOs::Phi_

std::unique_ptr< SPOSet > Phi_

Definition: RotatedSPOs.h:119

◆ isOptimizable()

bool isOptimizable ( ) const

inlineoverridevirtual

Query if this SPOSet is optimizable.

Reimplemented from SPOSet.

Definition at line 37 of file RotatedSPOs.h.

37 { return true; }

◆ log_antisym_matrix()

void log_antisym_matrix	(	const ValueMatrix &	mat,
		ValueMatrix &	output
	)

static

Definition at line 542 of file RotatedSPOs.cpp.

References qmcplusplus::app_log(), qmcplusplus::Units::charge::e, LAPACK::geev(), BLAS::gemm(), qmcplusplus::imag(), qmcplusplus::log(), qmcplusplus::Units::force::N, and qmcplusplus::n.

Referenced by RotatedSPOs::constructDeltaRotation(), and qmcplusplus::TEST_CASE().

 {
   const int n = mat.rows();
   std::vector<ValueType> mat_h(n * n, 0);
   std::vector<RealType> mat_l(n * n, 0);
   std::vector<std::complex<RealType>> mat_cd(n * n, 0);
   std::vector<std::complex<RealType>> mat_cl(n * n, 0);
   std::vector<std::complex<RealType>> mat_ch(n * n, 0);
 
   for (int i = 0; i < n; ++i)
     for (int j = 0; j < n; ++j)
       //we copy input mat in row major form to column major array for LAPACK consumption.
       mat_h[i + n * j] = mat[i][j];
 
   // diagonalize the matrix
   char JOBL('V'); //Compute left eigenvectors.
   char JOBR('N'); //Don't compute right eigenvectors.
   int N(n);
   int LDA(n);
   int LWORK(4 * n);
   int info = 0;
 
 #ifndef QMC_COMPLEX
   std::vector<RealType> eval_r(n, 0);
   std::vector<RealType> eval_i(n, 0);
   std::vector<RealType> work(4 * n, 0);
   LAPACK::geev(&JOBL, &JOBR, &N, &mat_h.at(0), &LDA, &eval_r.at(0), &eval_i.at(0), &mat_l.at(0), &LDA, nullptr, &LDA,
                &work.at(0), &LWORK, &info);
 #else
   std::vector<ValueType> eval(n, 0);
   std::vector<ValueType> work(2 * n, 0);
   std::vector<RealType> rwork(2 * n, 0);
   LAPACK::geev(&JOBL, &JOBR, &N, &mat_h.at(0), &LDA, &eval.at(0), &mat_cl.at(0), &LDA, nullptr, &LDA, &work.at(0),
                &LWORK, &rwork.at(0), &info);
 #endif
   if (info != 0)
   {
     std::ostringstream msg;
     msg << "heev failed with info = " << info << " in RotatedSPOs::log_antisym_matrix";
     throw std::runtime_error(msg.str());
   }
 
   // iterate through diagonal matrix, take log
   for (int i = 0; i < n; ++i)
   {
     for (int j = 0; j < n; ++j)
     {
 #ifndef QMC_COMPLEX
       auto tmp = (i == j) ? std::log(std::complex<RealType>(eval_r[i], eval_i[i])) : std::complex<RealType>(0.0, 0.0);
       if (eval_i[j] > 0.0)
       {
         mat_cl[i + j * n]       = std::complex<RealType>(mat_l[i + j * n], mat_l[i + (j + 1) * n]);
         mat_cl[i + (j + 1) * n] = std::complex<RealType>(mat_l[i + j * n], -mat_l[i + (j + 1) * n]);
       }
       else if (!(eval_i[j] < 0.0))
       {
         mat_cl[i + j * n] = std::complex<RealType>(mat_l[i + j * n], 0.0);
       }
 #else
       auto tmp     = (i == j) ? std::log(eval[i]) : ValueType(0.0);
 #endif
       mat_cd[i + j * n] = tmp;
     }
   }
 
   RealType one(1.0);
   RealType zero(0.0);
   BLAS::gemm('N', 'N', n, n, n, one, &mat_cl.at(0), n, &mat_cd.at(0), n, zero, &mat_ch.at(0), n);
   BLAS::gemm('N', 'C', n, n, n, one, &mat_ch.at(0), n, &mat_cl.at(0), n, zero, &mat_cd.at(0), n);
 
 
   for (int i = 0; i < n; ++i)
     for (int j = 0; j < n; ++j)
     {
 #ifndef QMC_COMPLEX
       if (mat_cd[i + n * j].imag() > 1e-12)
       {
         app_log() << "warning: large imaginary value in antisymmetric matrix: (i,j) = (" << i << "," << j
                   << "), im = " << mat_cd[i + n * j].imag() << std::endl;
       }
       output[i][j] = mat_cd[i + n * j].real();
 #else
       output[i][j] = mat_cd[i + n * j];
 #endif
     }
 }

◆ makeClone()

std::unique_ptr< SPOSet > makeClone ( ) const

overridevirtual

make a clone of itself every derived class must implement this to have threading working correctly.

Reimplemented from SPOSet.

Definition at line 1625 of file RotatedSPOs.cpp.

References RotatedSPOs::history_params_, RotatedSPOs::m_act_rot_inds_, RotatedSPOs::m_full_rot_inds_, SPOSet::my_name_, SPOSet::myVars, RotatedSPOs::myVarsFull_, RotatedSPOs::params_, RotatedSPOs::params_supplied_, RotatedSPOs::Phi_, and RotatedSPOs::use_global_rot_.

 {
   auto myclone = std::make_unique<RotatedSPOs>(my_name_, std::unique_ptr<SPOSet>(Phi_->makeClone()));
 
   myclone->params_          = this->params_;
   myclone->params_supplied_ = this->params_supplied_;
   myclone->m_act_rot_inds_  = this->m_act_rot_inds_;
   myclone->m_full_rot_inds_ = this->m_full_rot_inds_;
   myclone->myVars           = this->myVars;
   myclone->myVarsFull_      = this->myVarsFull_;
   myclone->history_params_  = this->history_params_;
   myclone->use_global_rot_  = this->use_global_rot_;
   return myclone;
 }

◆ mw_evaluate_notranspose()

void mw_evaluate_notranspose	(	const RefVectorWithLeader< SPOSet > &	spo_list,
		const RefVectorWithLeader< ParticleSet > &	P_list,
		int	first,
		int	last,
		const RefVector< ValueMatrix > &	logdet_list,
		const RefVector< GradMatrix > &	dlogdet_list,
		const RefVector< ValueMatrix > &	d2logdet_list
	)		const

overridevirtual

Reimplemented from SPOSet.

Definition at line 1714 of file RotatedSPOs.cpp.

References RotatedSPOs::extractPhiRefList().

 {
   auto phi_list = extractPhiRefList(spo_list);
   auto& leader  = phi_list.getLeader();
   leader.mw_evaluate_notranspose(phi_list, P_list, first, last, logdet_list, dlogdet_list, d2logdet_list);
 }

◆ mw_evaluateDetRatios()

void mw_evaluateDetRatios	(	const RefVectorWithLeader< SPOSet > &	spo_list,
		const RefVectorWithLeader< const VirtualParticleSet > &	vp_list,
		const RefVector< ValueVector > &	psi_list,
		const std::vector< const ValueType *> &	invRow_ptr_list,
		std::vector< std::vector< ValueType >> &	ratios_list
	)		const

overridevirtual

evaluate determinant ratios for virtual moves, e.g., sphere move for nonlocalPP, of multiple walkers

Parameters

spo_list	the list of SPOSet pointers in a walker batch
vp_list	a list of virtual particle sets in a walker batch
psi_list	a list of values of the SPO, used as a scratch space if needed
invRow_ptr_list	a list of pointers to the rows of inverse slater matrix corresponding to the particles moved virtually
ratios_list	a list of returning determinant ratios

Reimplemented from SPOSet.

Definition at line 1640 of file RotatedSPOs.cpp.

References RotatedSPOs::extractPhiRefList().

 {
   auto phi_list = extractPhiRefList(spo_list);
   auto& leader  = phi_list.getLeader();
   leader.mw_evaluateDetRatios(phi_list, vp_list, psi_list, invRow_ptr_list, ratios_list);
 }

◆ mw_evaluateValue()

void mw_evaluateValue	(	const RefVectorWithLeader< SPOSet > &	spo_list,
		const RefVectorWithLeader< ParticleSet > &	P_list,
		int	iat,
		const RefVector< ValueVector > &	psi_v_list
	)		const

overridevirtual

evaluate the values this single-particle orbital sets of multiple walkers

Parameters

spo_list	the list of SPOSet pointers in a walker batch
P_list	the list of ParticleSet pointers in a walker batch
iat	active particle
psi_v_list	the list of value vector pointers in a walker batch

Reimplemented from SPOSet.

Definition at line 1651 of file RotatedSPOs.cpp.

References RotatedSPOs::extractPhiRefList().

Referenced by qmcplusplus::TEST_CASE().

 {
   auto phi_list = extractPhiRefList(spo_list);
   auto& leader  = phi_list.getLeader();
   leader.mw_evaluateValue(phi_list, P_list, iat, psi_v_list);
 }

◆ mw_evaluateVGL()

void mw_evaluateVGL	(	const RefVectorWithLeader< SPOSet > &	spo_list,
		const RefVectorWithLeader< ParticleSet > &	P_list,
		int	iat,
		const RefVector< ValueVector > &	psi_v_list,
		const RefVector< GradVector > &	dpsi_v_list,
		const RefVector< ValueVector > &	d2psi_v_list
	)		const

overridevirtual

evaluate the values, gradients and laplacians of this single-particle orbital sets of multiple walkers

Parameters

spo_list	the list of SPOSet pointers in a walker batch
P_list	the list of ParticleSet pointers in a walker batch
iat	active particle
psi_v_list	the list of value vector pointers in a walker batch
dpsi_v_list	the list of gradient vector pointers in a walker batch
d2psi_v_list	the list of laplacian vector pointers in a walker batch

Reimplemented from SPOSet.

Definition at line 1661 of file RotatedSPOs.cpp.

References RotatedSPOs::extractPhiRefList().

 {
   auto phi_list = extractPhiRefList(spo_list);
   auto& leader  = phi_list.getLeader();
   leader.mw_evaluateVGL(phi_list, P_list, iat, psi_v_list, dpsi_v_list, d2psi_v_list);
 }

◆ mw_evaluateVGLandDetRatioGrads()

void mw_evaluateVGLandDetRatioGrads	(	const RefVectorWithLeader< SPOSet > &	spo_list,
		const RefVectorWithLeader< ParticleSet > &	P_list,
		int	iat,
		const std::vector< const ValueType *> &	invRow_ptr_list,
		OffloadMWVGLArray &	phi_vgl_v,
		std::vector< ValueType > &	ratios,
		std::vector< GradType > &	grads
	)		const

overridevirtual

evaluate the values, gradients and laplacians of this single-particle orbital sets and determinant ratio and grads of multiple walkers.

Device data of phi_vgl_v must be up-to-date upon return

Parameters

spo_list	the list of SPOSet pointers in a walker batch
P_list	the list of ParticleSet pointers in a walker batch
iat	active particle
phi_vgl_v	orbital values, gradients and laplacians of all the walkers
psi_ratio_grads_v	determinant ratio and grads of all the walkers

Reimplemented from SPOSet.

Definition at line 1686 of file RotatedSPOs.cpp.

References RotatedSPOs::extractPhiRefList().

 {
   auto phi_list = extractPhiRefList(spo_list);
   auto& leader  = phi_list.getLeader();
   leader.mw_evaluateVGLandDetRatioGrads(phi_list, P_list, iat, invRow_ptr_list, phi_vgl_v, ratios, grads);
 }

◆ mw_evaluateVGLandDetRatioGradsWithSpin()

void mw_evaluateVGLandDetRatioGradsWithSpin	(	const RefVectorWithLeader< SPOSet > &	spo_list,
		const RefVectorWithLeader< ParticleSet > &	P_list,
		int	iat,
		const std::vector< const ValueType *> &	invRow_ptr_list,
		OffloadMWVGLArray &	phi_vgl_v,
		std::vector< ValueType > &	ratios,
		std::vector< GradType > &	grads,
		std::vector< ValueType > &	spingrads
	)		const

overridevirtual

evaluate the values, gradients and laplacians of this single-particle orbital sets and determinant ratio and grads of multiple walkers.

Device data of phi_vgl_v must be up-to-date upon return. Includes spin gradients

Parameters

spo_list	the list of SPOSet pointers in a walker batch
P_list	the list of ParticleSet pointers in a walker batch
iat	active particle
phi_vgl_v	orbital values, gradients and laplacians of all the walkers
ratios,ratios	of all walkers
grads,spatial	gradients of all walkers
spingrads,spin	gradients of all walkers

Reimplemented from SPOSet.

Definition at line 1699 of file RotatedSPOs.cpp.

References RotatedSPOs::extractPhiRefList().

 {
   auto phi_list = extractPhiRefList(spo_list);
   auto& leader  = phi_list.getLeader();
   leader.mw_evaluateVGLandDetRatioGradsWithSpin(phi_list, P_list, iat, invRow_ptr_list, phi_vgl_v, ratios, grads,
                                                 spingrads);
 }

◆ mw_evaluateVGLWithSpin()

void mw_evaluateVGLWithSpin	(	const RefVectorWithLeader< SPOSet > &	spo_list,
		const RefVectorWithLeader< ParticleSet > &	P_list,
		int	iat,
		const RefVector< ValueVector > &	psi_v_list,
		const RefVector< GradVector > &	dpsi_v_list,
		const RefVector< ValueVector > &	d2psi_v_list,
		OffloadMatrix< ComplexType > &	mw_dspin
	)		const

overridevirtual

evaluate the values, gradients and laplacians and spin gradient of this single-particle orbital sets of multiple walkers

Parameters

spo_list	the list of SPOSet pointers in a walker batch
P_list	the list of ParticleSet pointers in a walker batch
iat	active particle
psi_v_list	the list of value vector pointers in a walker batch
dpsi_v_list	the list of gradient vector pointers in a walker batch
d2psi_v_list	the list of laplacian vector pointers in a walker batch
mw_dspin	is a dual matrix of spin gradients [nw][norb] Note that the device side of mw_dspin is up to date

Reimplemented from SPOSet.

Definition at line 1673 of file RotatedSPOs.cpp.

References RotatedSPOs::extractPhiRefList().

Referenced by qmcplusplus::TEST_CASE().

 {
   auto phi_list = extractPhiRefList(spo_list);
   auto& leader  = phi_list.getLeader();
   leader.mw_evaluateVGLWithSpin(phi_list, P_list, iat, psi_v_list, dpsi_v_list, d2psi_v_list, mw_dspin);
 }

◆ readVariationalParameters()

void readVariationalParameters ( hdf_archive & hin )

overridevirtual

Read the variational parameters for this object from the VP HDF file.

The hin parameter should come from VariableSet::readFromHDF

By default the parameters are read in VariableSet::readFromHDF, and objects do not need to implement this function (yet).

Reimplemented from OptimizableObject.

Definition at line 188 of file RotatedSPOs.cpp.

References qmcplusplus::app_warning(), RotatedSPOs::applyFullRotation(), RotatedSPOs::applyRotationHistory(), SPOSet::getName(), hdf_archive::getShape(), RotatedSPOs::history_params_, hdf_archive::is_group(), SPOSet::myVars, RotatedSPOs::myVarsFull_, hdf_archive::pop(), hdf_archive::push(), hdf_archive::read(), and VariableSet::size().

Referenced by qmcplusplus::TEST_CASE().

 {
   hin.push("RotatedSPOs", false);
 
   bool grp_hist_exists   = hin.is_group("rotation_history");
   bool grp_global_exists = hin.is_group("rotation_global");
   if (!grp_hist_exists && !grp_global_exists)
     app_warning() << "Rotation parameters not found in VP file";
 
 
   if (grp_global_exists)
   {
     hin.push("rotation_global", false);
     const std::string rot_global_name = std::string("rotation_global_") + SPOSet::getName();
 
     std::vector<int> sizes(1);
     if (!hin.getShape<ValueType>(rot_global_name, sizes))
       throw std::runtime_error("Failed to read rotation_global in VP file");
 
     if (myVarsFull_.size() != sizes[0])
     {
       std::ostringstream tmp_err;
       tmp_err << "Expected number of full rotation parameters (" << myVarsFull_.size()
               << ") does not match number in file (" << sizes[0] << ")";
       throw std::runtime_error(tmp_err.str());
     }
     hin.read(myVarsFull_, rot_global_name);
 
     hin.pop();
 
     applyFullRotation(myVarsFull_, true);
   }
   else if (grp_hist_exists)
   {
     hin.push("rotation_history", false);
     std::string rot_hist_name = std::string("rotation_history_") + SPOSet::getName();
     std::vector<int> sizes(2);
     if (!hin.getShape<ValueType>(rot_hist_name, sizes))
       throw std::runtime_error("Failed to read rotation history in VP file");
 
     int rows = sizes[0];
     int cols = sizes[1];
     history_params_.resize(rows);
     Matrix<ValueType> tmp(rows, cols);
     hin.read(tmp, rot_hist_name);
     for (size_t i = 0; i < rows; i++)
     {
       history_params_[i].resize(cols);
       for (size_t j = 0; j < cols; j++)
         history_params_[i][j] = tmp(i, j);
     }
 
     hin.pop();
 
     applyRotationHistory();
   }
 
   hin.push("rotation_params", false);
   std::string rot_param_name = std::string("rotation_params_") + SPOSet::getName();
 
   std::vector<int> sizes(1);
   if (!hin.getShape<ValueType>(rot_param_name, sizes))
     throw std::runtime_error("Failed to read rotation_params in VP file");
 
   //values stored as ValueType. Now unpack into reals
   int nparam_actual = IsComplex_t<ValueType>::value ? 2 * sizes[0] : sizes[0];
   int nparam        = myVars.size();
   if (nparam != nparam_actual)
   {
     std::ostringstream tmp_err;
     tmp_err << "Expected number of rotation parameters (" << nparam << ") does not match number in file ("
             << nparam_actual << ")";
     throw std::runtime_error(tmp_err.str());
   }
 
   std::vector<ValueType> params(sizes[0]);
   hin.read(params, rot_param_name);
   auto* params_data_alias = (RealType*)params.data();
   for (int i = 0; i < nparam; i++)
     myVars[i] = params_data_alias[i];
 
   hin.pop();
 
   hin.pop();
 }

◆ releaseResource()

void releaseResource	(	ResourceCollection &	collection,
		const RefVectorWithLeader< SPOSet > &	spo_list
	)		const

overridevirtual

return a shared resource to collection

Reimplemented from SPOSet.

Definition at line 1736 of file RotatedSPOs.cpp.

References RotatedSPOs::extractPhiRefList().

 {
   auto phi_list = extractPhiRefList(spo_list);
   auto& leader  = phi_list.getLeader();
   leader.releaseResource(collection, phi_list);
 }

◆ resetParametersExclusive()

void resetParametersExclusive ( const opt_variables_type & active )

overridevirtual

reset

Implements OptimizableObject.

Definition at line 112 of file RotatedSPOs.cpp.

References RotatedSPOs::apply_rotation(), RotatedSPOs::applyDeltaRotation(), qmcplusplus::syclBLAS::copy_n(), RotatedSPOs::history_params_, RotatedSPOs::m_act_rot_inds_, RotatedSPOs::m_full_rot_inds_, SPOSet::myVars, RotatedSPOs::myVarsFull_, VariableSet::size(), RotatedSPOs::use_global_rot_, and VariableSet::where().

Referenced by qmcplusplus::TEST_CASE().

 {
   const size_t nact_rot = m_act_rot_inds_.size();
   std::vector<ValueType> delta_param(nact_rot);
 
   //cast ValueType to RealType for delta param
   //allows us to work with both real and complex since
   //active and myVars are stored as only reals
   auto* delta_param_data_alias = (RealType*)delta_param.data();
   for (int i = 0; i < myVars.size(); i++)
   {
     int loc                   = myVars.where(i);
     delta_param_data_alias[i] = active[loc] - myVars[i];
     myVars[i]                 = active[loc];
   }
 
   if (use_global_rot_)
   {
     std::vector<ValueType> old_param(m_full_rot_inds_.size());
     std::copy_n(myVarsFull_.data(), myVarsFull_.size(), old_param.data());
 
     applyDeltaRotation(delta_param, old_param, myVarsFull_);
   }
   else
   {
     apply_rotation(delta_param, false);
 
     // Save the parameters in the history list
     history_params_.push_back(delta_param);
   }
 }

◆ set_use_global_rotation()

void set_use_global_rotation ( bool use_global_rotation )

inline

Use history list (false) or global rotation (true)

Definition at line 403 of file RotatedSPOs.h.

References RotatedSPOs::use_global_rot_.

Referenced by qmcplusplus::TEST_CASE().

403 { use_global_rot_ = use_global_rotation; }

qmcplusplus::RotatedSPOs::use_global_rot_

bool use_global_rot_

Use global rotation or history list.

Definition: RotatedSPOs.h:480

◆ setOrbitalSetSize()

void setOrbitalSetSize ( int norbs )

inlineoverridevirtual

set the OrbitalSetSize

Parameters

norbs number of single-particle orbitals Ye: I prefer to remove this interface in the future. SPOSet builders need to handle the size correctly. It doesn't make sense allowing to set the value at any place in the code.

Implements SPOSet.

Definition at line 274 of file RotatedSPOs.h.

References RotatedSPOs::Phi_.

274 { Phi_->setOrbitalSetSize(norbs); }

qmcplusplus::RotatedSPOs::Phi_

std::unique_ptr< SPOSet > Phi_

Definition: RotatedSPOs.h:119

◆ setRotationParameters()

void setRotationParameters ( const std::vector< RealType > & param_list )

For now, this takes the real optimizable parameters (real rotation coefficients) and converts them to ValueType parameter lists for internal consumption by the real and complex orb-opt code.

This will do something more non-trivial when bona fide complex orbital optimization is working.

Definition at line 36 of file RotatedSPOs.cpp.

References copy(), RotatedSPOs::params_, and RotatedSPOs::params_supplied_.

 {
   const size_t num_param = IsComplex_t<ValueType>::value ? param_list.size() / 2 : param_list.size();
   params_.resize(num_param);
 
   //handling both real and complex by casting data to RealType*, since laid out as real_0, imag_0, real_1, imag_1, etc
   auto* params_data_alias = (RealType*)params_.data();
   std::copy(param_list.begin(), param_list.end(), params_data_alias);
 
   params_supplied_ = true;
 }

◆ table_method_eval()

void table_method_eval	(	Vector< ValueType > &	dlogpsi,
		Vector< ValueType > &	dhpsioverpsi,
		const ParticleSet::ParticleLaplacian &	myL_J,
		const ParticleSet::ParticleGradient &	myG_J,
		const size_t	nel,
		const size_t	nmo,
		const ValueType &	psiCurrent,
		const std::vector< RealType > &	Coeff,
		const std::vector< size_t > &	C2node_up,
		const std::vector< size_t > &	C2node_dn,
		const ValueVector &	detValues_up,
		const ValueVector &	detValues_dn,
		const GradMatrix &	grads_up,
		const GradMatrix &	grads_dn,
		const ValueMatrix &	lapls_up,
		const ValueMatrix &	lapls_dn,
		const ValueMatrix &	M_up,
		const ValueMatrix &	M_dn,
		const ValueMatrix &	Minv_up,
		const ValueMatrix &	Minv_dn,
		const GradMatrix &	B_grad,
		const ValueMatrix &	B_lapl,
		const std::vector< int > &	detData_up,
		const size_t	N1,
		const size_t	N2,
		const size_t	NP1,
		const size_t	NP2,
		const std::vector< std::vector< int >> &	lookup_tbl
	)

Definition at line 1018 of file RotatedSPOs.cpp.

References qmcplusplus::Units::distance::A, BLAS::axpy(), B(), RotatedSPOs::Bbar, BLAS::copy(), Vector< T, Alloc >::data(), qmcplusplus::dot(), BLAS::gemm(), qmcplusplus::InvertWithLog(), RotatedSPOs::m_act_rot_inds_, RotatedSPOs::myG_J, RotatedSPOs::myL_J, SPOSet::myVars, Vector< T, Alloc >::resize(), qmcplusplus::Units::second, and VariableSet::where().

Referenced by RotatedSPOs::evaluateDerivatives().

 {
 #ifndef QMC_COMPLEX
   ValueMatrix Table;
   ValueMatrix Bbar;
   ValueMatrix Y1, Y2, Y3, Y4, Y5, Y6, Y7, Y11, Y23, Y24, Y25, Y26;
   ValueMatrix pK1, K1T, TK1T, pK2, K2AiB, TK2AiB, K2XA, TK2XA, K2T, TK2T, MK2T, pK3, K3T, TK3T, pK5, K5T, TK5T;
 
   Table.resize(nel, nmo);
 
   Bbar.resize(nel, nmo);
 
   Y1.resize(nel, nel);
   Y2.resize(nel, nmo);
   Y3.resize(nel, nmo);
   Y4.resize(nel, nmo);
 
   pK1.resize(nmo, nel);
   K1T.resize(nmo, nmo);
   TK1T.resize(nel, nmo);
 
   pK2.resize(nmo, nel);
   K2AiB.resize(nmo, nmo);
   TK2AiB.resize(nel, nmo);
   K2XA.resize(nmo, nmo);
   TK2XA.resize(nel, nmo);
   K2T.resize(nmo, nmo);
   TK2T.resize(nel, nmo);
   MK2T.resize(nel, nmo);
 
   pK3.resize(nmo, nel);
   K3T.resize(nmo, nmo);
   TK3T.resize(nel, nmo);
 
   pK5.resize(nmo, nel);
   K5T.resize(nmo, nmo);
   TK5T.resize(nel, nmo);
 
   const int parameters_size(m_act_rot_inds_.size());
   const int parameter_start_index(0);
 
   const size_t num_unique_up_dets(detValues_up.size());
   const size_t num_unique_dn_dets(detValues_dn.size());
 
   const RealType* restrict cptr = Coeff.data();
   const size_t nc               = Coeff.size();
   const size_t* restrict upC(C2node_up.data());
   const size_t* restrict dnC(C2node_dn.data());
   //B_grad holds the gradient operator
   //B_lapl holds the laplacian operator
   //B_bar will hold our special O operator
 
   const int offset1(N1);
   const int offset2(N2);
   const int NPother(NP2);
 
   RealType* T(Table.data());
 
   //possibly replace wit BLAS calls
   for (int i = 0; i < nel; i++)
     for (int j = 0; j < nmo; j++)
       Bbar(i, j) = B_lapl(i, j) + 2 * dot(myG_J[i + offset1], B_grad(i, j)) + myL_J[i + offset1] * M_up(i, j);
 
   const RealType* restrict B(Bbar.data());
   const RealType* restrict A(M_up.data());
   const RealType* restrict Ainv(Minv_up.data());
   //IMPORTANT NOTE: THE Dets[0]->psiMinv OBJECT DOES NOT HOLD THE INVERSE IF THE MULTIDIRACDETERMINANTBASE ONLY CONTAINS ONE ELECTRON. NEED A FIX FOR THIS CASE
   // The T matrix should be calculated and stored for use
   // T = A^{-1} \widetilde A
   //REMINDER: that the ValueMatrix "matrix" stores data in a row major order and that BLAS commands assume column major
   BLAS::gemm('N', 'N', nmo, nel, nel, RealType(1.0), A, nmo, Ainv, nel, RealType(0.0), T, nmo);
 
   BLAS::gemm('N', 'N', nel, nel, nel, RealType(1.0), B, nmo, Ainv, nel, RealType(0.0), Y1.data(), nel);
   BLAS::gemm('N', 'N', nmo, nel, nel, RealType(1.0), T, nmo, Y1.data(), nel, RealType(0.0), Y2.data(), nmo);
   BLAS::gemm('N', 'N', nmo, nel, nel, RealType(1.0), B, nmo, Ainv, nel, RealType(0.0), Y3.data(), nmo);
 
   //possibly replace with BLAS call
   Y4 = Y3 - Y2;
 
   //Need to create the constants: (Oi, const0, const1, const2)to take advantage of minimal BLAS commands;
   //Oi is the special operator applied to the slater matrix "A subscript i" from the total CI expansion
   //\hat{O_{i}} = \hat{O}D_{i} with D_{i}=det(A_{i}) and Multi-Slater component defined as \sum_{i=0} C_{i} D_{i\uparrow}D_{i\downarrow}
   std::vector<RealType> Oi(num_unique_dn_dets);
 
   for (int index = 0; index < num_unique_dn_dets; index++)
     for (int iat = 0; iat < NPother; iat++)
       Oi[index] += lapls_dn(index, iat) + 2 * dot(grads_dn(index, iat), myG_J[offset2 + iat]) +
           myL_J[offset2 + iat] * detValues_dn[index];
 
   //const0 = C_{0}*det(A_{0\downarrow})+\sum_{i=1} C_{i}*det(A_{i\downarrow})* det(\alpha_{i\uparrow})
   //const1 = C_{0}*\hat{O} det(A_{0\downarrow})+\sum_{i=1} C_{i}*\hat{O}det(A_{i\downarrow})* det(\alpha_{i\uparrow})
   //const2 = \sum_{i=1} C_{i}*det(A_{i\downarrow})* Tr[\alpha_{i}^{-1}M_{i}]*det(\alpha_{i})
   RealType const0(0.0), const1(0.0), const2(0.0);
   for (size_t i = 0; i < nc; ++i)
   {
     const RealType c  = cptr[i];
     const size_t up   = upC[i];
     const size_t down = dnC[i];
 
     const0 += c * detValues_dn[down] * (detValues_up[up] / detValues_up[0]);
     const1 += c * Oi[down] * (detValues_up[up] / detValues_up[0]);
   }
 
   std::fill(pK1.begin(), pK1.end(), 0.0);
   std::fill(pK2.begin(), pK2.end(), 0.0);
   std::fill(pK3.begin(), pK3.end(), 0.0);
   std::fill(pK5.begin(), pK5.end(), 0.0);
 
   //Now we are going to loop through all unique determinants.
   //The few lines above are for the reference matrix contribution.
   //Although I start the loop below from index 0, the loop only performs actions when the index is >= 1
   //the detData object contains all the information about the P^T and Q matrices (projection matrices) needed in the table method
   const int* restrict data_it = detData_up.data();
   for (int index = 0, datum = 0; index < num_unique_up_dets; index++)
   {
     const int k = data_it[datum];
 
     if (k == 0)
     {
       datum += 3 * k + 1;
     }
 
     else
     {
       //Number of rows and cols of P^T
       const int prows = k;
       const int pcols = nel;
       //Number of rows and cols of Q
       const int qrows = nmo;
       const int qcols = k;
 
       Y5.resize(nel, k);
       Y6.resize(k, k);
 
       //Any matrix multiplication of P^T or Q is simply a projection
       //Explicit matrix multiplication can be avoided; instead column or row copying can be done
       //BlAS::copy(size of col/row being copied,
       //           Matrix pointer + place to begin copying,
       //           storage spacing (number of elements btw next row/col element),
       //           Pointer to resultant matrix + place to begin pasting,
       //           storage spacing of resultant matrix)
       //For example the next 4 lines is the matrix multiplication of T*Q = Y5
       std::fill(Y5.begin(), Y5.end(), 0.0);
       for (int i = 0; i < k; i++)
       {
         BLAS::copy(nel, T + data_it[datum + 1 + k + i], nmo, Y5.data() + i, k);
       }
 
       std::fill(Y6.begin(), Y6.end(), 0.0);
       for (int i = 0; i < k; i++)
       {
         BLAS::copy(k, Y5.data() + (data_it[datum + 1 + i]) * k, 1, (Y6.data() + i * k), 1);
       }
 
 
       Vector<ValueType> WS;
       Vector<IndexType> Piv;
       WS.resize(k);
       Piv.resize(k);
       std::complex<RealType> logdet = 0.0;
       InvertWithLog(Y6.data(), k, k, WS.data(), Piv.data(), logdet);
 
       Y11.resize(nel, k);
       Y23.resize(k, k);
       Y24.resize(k, k);
       Y25.resize(k, k);
       Y26.resize(k, nel);
 
       std::fill(Y11.begin(), Y11.end(), 0.0);
       for (int i = 0; i < k; i++)
       {
         BLAS::copy(nel, Y4.data() + (data_it[datum + 1 + k + i]), nmo, Y11.data() + i, k);
       }
 
       std::fill(Y23.begin(), Y23.end(), 0.0);
       for (int i = 0; i < k; i++)
       {
         BLAS::copy(k, Y11.data() + (data_it[datum + 1 + i]) * k, 1, (Y23.data() + i * k), 1);
       }
 
       BLAS::gemm('N', 'N', k, k, k, RealType(1.0), Y23.data(), k, Y6.data(), k, RealType(0.0), Y24.data(), k);
       BLAS::gemm('N', 'N', k, k, k, RealType(1.0), Y6.data(), k, Y24.data(), k, RealType(0.0), Y25.data(), k);
 
 
       Y26.resize(k, nel);
 
       std::fill(Y26.begin(), Y26.end(), 0.0);
       for (int i = 0; i < k; i++)
       {
         BLAS::copy(k, Y25.data() + i, k, Y26.data() + (data_it[datum + 1 + i]), nel);
       }
 
 
       Y7.resize(k, nel);
 
       std::fill(Y7.begin(), Y7.end(), 0.0);
       for (int i = 0; i < k; i++)
       {
         BLAS::copy(k, Y6.data() + i, k, Y7.data() + (data_it[datum + 1 + i]), nel);
       }
 
       // c_Tr_AlphaI_MI is a constant contributing to constant const2
       // c_Tr_AlphaI_MI = Tr[\alpha_{I}^{-1}(P^{T}\widetilde{M} Q)]
       RealType c_Tr_AlphaI_MI = 0.0;
       for (int i = 0; i < k; i++)
       {
         c_Tr_AlphaI_MI += Y24(i, i);
       }
 
       for (int p = 0; p < lookup_tbl[index].size(); p++)
       {
         //el_p is the element position that contains information about the CI coefficient, and det up/dn values associated with the current unique determinant
         const int el_p(lookup_tbl[index][p]);
         const RealType c  = cptr[el_p];
         const size_t up   = upC[el_p];
         const size_t down = dnC[el_p];
 
         const RealType alpha_1(c * detValues_dn[down] * detValues_up[up] / detValues_up[0] * c_Tr_AlphaI_MI);
         const RealType alpha_2(c * detValues_dn[down] * detValues_up[up] / detValues_up[0]);
         const RealType alpha_3(c * Oi[down] * detValues_up[up] / detValues_up[0]);
 
         const2 += alpha_1;
 
         for (int i = 0; i < k; i++)
         {
           BLAS::axpy(nel, alpha_1, Y7.data() + i * nel, 1, pK1.data() + (data_it[datum + 1 + k + i]) * nel, 1);
           BLAS::axpy(nel, alpha_2, Y7.data() + i * nel, 1, pK2.data() + (data_it[datum + 1 + k + i]) * nel, 1);
           BLAS::axpy(nel, alpha_3, Y7.data() + i * nel, 1, pK3.data() + (data_it[datum + 1 + k + i]) * nel, 1);
           BLAS::axpy(nel, alpha_2, Y26.data() + i * nel, 1, pK5.data() + (data_it[datum + 1 + k + i]) * nel, 1);
         }
       }
       datum += 3 * k + 1;
     }
   }
 
 
   BLAS::gemm('N', 'N', nmo, nmo, nel, 1.0 / const0, T, nmo, pK1.data(), nel, RealType(0.0), K1T.data(), nmo);
   BLAS::gemm('N', 'N', nmo, nel, nmo, RealType(1.0), K1T.data(), nmo, T, nmo, RealType(0.0), TK1T.data(), nmo);
 
   BLAS::gemm('N', 'N', nmo, nmo, nel, 1.0 / const0, Y3.data(), nmo, pK2.data(), nel, RealType(0.0), K2AiB.data(), nmo);
   BLAS::gemm('N', 'N', nmo, nel, nmo, RealType(1.0), K2AiB.data(), nmo, T, nmo, RealType(0.0), TK2AiB.data(), nmo);
   BLAS::gemm('N', 'N', nmo, nmo, nel, 1.0 / const0, Y2.data(), nmo, pK2.data(), nel, RealType(0.0), K2XA.data(), nmo);
   BLAS::gemm('N', 'N', nmo, nel, nmo, RealType(1.0), K2XA.data(), nmo, T, nmo, RealType(0.0), TK2XA.data(), nmo);
 
   BLAS::gemm('N', 'N', nmo, nmo, nel, const1 / (const0 * const0), T, nmo, pK2.data(), nel, RealType(0.0), K2T.data(),
              nmo);
   BLAS::gemm('N', 'N', nmo, nel, nmo, RealType(1.0), K2T.data(), nmo, T, nmo, RealType(0.0), TK2T.data(), nmo);
   BLAS::gemm('N', 'N', nmo, nel, nmo, const0 / const1, K2T.data(), nmo, Y4.data(), nmo, RealType(0.0), MK2T.data(),
              nmo);
 
   BLAS::gemm('N', 'N', nmo, nmo, nel, 1.0 / const0, T, nmo, pK3.data(), nel, RealType(0.0), K3T.data(), nmo);
   BLAS::gemm('N', 'N', nmo, nel, nmo, RealType(1.0), K3T.data(), nmo, T, nmo, RealType(0.0), TK3T.data(), nmo);
 
   BLAS::gemm('N', 'N', nmo, nmo, nel, 1.0 / const0, T, nmo, pK5.data(), nel, RealType(0.0), K5T.data(), nmo);
   BLAS::gemm('N', 'N', nmo, nel, nmo, RealType(1.0), K5T.data(), nmo, T, nmo, RealType(0.0), TK5T.data(), nmo);
 
 
   for (int mu = 0, k = parameter_start_index; k < (parameter_start_index + parameters_size); k++, mu++)
   {
     int kk = myVars.where(k);
     if (kk >= 0)
     {
       const int i(m_act_rot_inds_[mu].first), j(m_act_rot_inds_[mu].second);
       if (i <= nel - 1 && j > nel - 1)
       {
         dhpsioverpsi[kk] +=
             ValueType(-0.5 * Y4(i, j) -
                       0.5 *
                           (-K5T(i, j) + K5T(j, i) + TK5T(i, j) + K2AiB(i, j) - K2AiB(j, i) - TK2AiB(i, j) - K2XA(i, j) +
                            K2XA(j, i) + TK2XA(i, j) - MK2T(i, j) + K1T(i, j) - K1T(j, i) - TK1T(i, j) -
                            const2 / const1 * K2T(i, j) + const2 / const1 * K2T(j, i) + const2 / const1 * TK2T(i, j) +
                            K3T(i, j) - K3T(j, i) - TK3T(i, j) - K2T(i, j) + K2T(j, i) + TK2T(i, j)));
       }
       else if (i <= nel - 1 && j <= nel - 1)
       {
         dhpsioverpsi[kk] += ValueType(
             -0.5 * (Y4(i, j) - Y4(j, i)) -
             0.5 *
                 (-K5T(i, j) + K5T(j, i) + TK5T(i, j) - TK5T(j, i) + K2AiB(i, j) - K2AiB(j, i) - TK2AiB(i, j) +
                  TK2AiB(j, i) - K2XA(i, j) + K2XA(j, i) + TK2XA(i, j) - TK2XA(j, i) - MK2T(i, j) + MK2T(j, i) +
                  K1T(i, j) - K1T(j, i) - TK1T(i, j) + TK1T(j, i) - const2 / const1 * K2T(i, j) +
                  const2 / const1 * K2T(j, i) + const2 / const1 * TK2T(i, j) - const2 / const1 * TK2T(j, i) + K3T(i, j) -
                  K3T(j, i) - TK3T(i, j) + TK3T(j, i) - K2T(i, j) + K2T(j, i) + TK2T(i, j) - TK2T(j, i)));
       }
       else
       {
         dhpsioverpsi[kk] += ValueType(-0.5 *
                                       (-K5T(i, j) + K5T(j, i) + K2AiB(i, j) - K2AiB(j, i) - K2XA(i, j) + K2XA(j, i)
 
                                        + K1T(i, j) - K1T(j, i) - const2 / const1 * K2T(i, j) +
                                        const2 / const1 * K2T(j, i) + K3T(i, j) - K3T(j, i) - K2T(i, j) + K2T(j, i)));
       }
     }
   }
 #endif
 }

◆ table_method_evalWF()

void table_method_evalWF	(	Vector< ValueType > &	dlogpsi,
		const size_t	nel,
		const size_t	nmo,
		const ValueType &	psiCurrent,
		const std::vector< RealType > &	Coeff,
		const std::vector< size_t > &	C2node_up,
		const std::vector< size_t > &	C2node_dn,
		const ValueVector &	detValues_up,
		const ValueVector &	detValues_dn,
		const ValueMatrix &	M_up,
		const ValueMatrix &	M_dn,
		const ValueMatrix &	Minv_up,
		const ValueMatrix &	Minv_dn,
		const std::vector< int > &	detData_up,
		const std::vector< std::vector< int >> &	lookup_tbl
	)

Definition at line 1453 of file RotatedSPOs.cpp.

References qmcplusplus::Units::distance::A, BLAS::axpy(), RotatedSPOs::Bbar, BLAS::copy(), Vector< T, Alloc >::data(), BLAS::gemm(), qmcplusplus::InvertWithLog(), RotatedSPOs::m_act_rot_inds_, SPOSet::myVars, Vector< T, Alloc >::resize(), qmcplusplus::Units::second, and VariableSet::where().

Referenced by RotatedSPOs::evaluateDerivativesWF().

 {
 #ifndef QMC_COMPLEX
   ValueMatrix Table;
   ValueMatrix Y5, Y6, Y7;
   ValueMatrix pK4, K4T, TK4T;
 
   Table.resize(nel, nmo);
 
   Bbar.resize(nel, nmo);
 
   pK4.resize(nmo, nel);
   K4T.resize(nmo, nmo);
   TK4T.resize(nel, nmo);
 
   const int parameters_size(m_act_rot_inds_.size());
   const int parameter_start_index(0);
 
   const size_t num_unique_up_dets(detValues_up.size());
   const size_t num_unique_dn_dets(detValues_dn.size());
 
   const RealType* restrict cptr = Coeff.data();
   const size_t nc               = Coeff.size();
   const size_t* restrict upC(C2node_up.data());
   const size_t* restrict dnC(C2node_dn.data());
 
   RealType* T(Table.data());
 
   const RealType* restrict A(M_up.data());
   const RealType* restrict Ainv(Minv_up.data());
   //IMPORTANT NOTE: THE Dets[0]->psiMinv OBJECT DOES NOT HOLD THE INVERSE IF THE MULTIDIRACDETERMINANTBASE ONLY CONTAINS ONE ELECTRON. NEED A FIX FOR THIS CASE
   // The T matrix should be calculated and stored for use
   // T = A^{-1} \widetilde A
   //REMINDER: that the ValueMatrix "matrix" stores data in a row major order and that BLAS commands assume column major
   BLAS::gemm('N', 'N', nmo, nel, nel, RealType(1.0), A, nmo, Ainv, nel, RealType(0.0), T, nmo);
 
   //const0 = C_{0}*det(A_{0\downarrow})+\sum_{i=1} C_{i}*det(A_{i\downarrow})* det(\alpha_{i\uparrow})
   RealType const0(0.0), const1(0.0), const2(0.0);
   for (size_t i = 0; i < nc; ++i)
   {
     const RealType c  = cptr[i];
     const size_t up   = upC[i];
     const size_t down = dnC[i];
 
     const0 += c * detValues_dn[down] * (detValues_up[up] / detValues_up[0]);
   }
 
   std::fill(pK4.begin(), pK4.end(), 0.0);
 
   //Now we are going to loop through all unique determinants.
   //The few lines above are for the reference matrix contribution.
   //Although I start the loop below from index 0, the loop only performs actions when the index is >= 1
   //the detData object contains all the information about the P^T and Q matrices (projection matrices) needed in the table method
   const int* restrict data_it = detData_up.data();
   for (int index = 0, datum = 0; index < num_unique_up_dets; index++)
   {
     const int k = data_it[datum];
 
     if (k == 0)
     {
       datum += 3 * k + 1;
     }
 
     else
     {
       //Number of rows and cols of P^T
       const int prows = k;
       const int pcols = nel;
       //Number of rows and cols of Q
       const int qrows = nmo;
       const int qcols = k;
 
       Y5.resize(nel, k);
       Y6.resize(k, k);
 
       //Any matrix multiplication of P^T or Q is simply a projection
       //Explicit matrix multiplication can be avoided; instead column or row copying can be done
       //BlAS::copy(size of col/row being copied,
       //           Matrix pointer + place to begin copying,
       //           storage spacing (number of elements btw next row/col element),
       //           Pointer to resultant matrix + place to begin pasting,
       //           storage spacing of resultant matrix)
       //For example the next 4 lines is the matrix multiplication of T*Q = Y5
       std::fill(Y5.begin(), Y5.end(), 0.0);
       for (int i = 0; i < k; i++)
       {
         BLAS::copy(nel, T + data_it[datum + 1 + k + i], nmo, Y5.data() + i, k);
       }
 
       std::fill(Y6.begin(), Y6.end(), 0.0);
       for (int i = 0; i < k; i++)
       {
         BLAS::copy(k, Y5.data() + (data_it[datum + 1 + i]) * k, 1, (Y6.data() + i * k), 1);
       }
 
       Vector<ValueType> WS;
       Vector<IndexType> Piv;
       WS.resize(k);
       Piv.resize(k);
       std::complex<RealType> logdet = 0.0;
       InvertWithLog(Y6.data(), k, k, WS.data(), Piv.data(), logdet);
 
       Y7.resize(k, nel);
 
       std::fill(Y7.begin(), Y7.end(), 0.0);
       for (int i = 0; i < k; i++)
       {
         BLAS::copy(k, Y6.data() + i, k, Y7.data() + (data_it[datum + 1 + i]), nel);
       }
 
       for (int p = 0; p < lookup_tbl[index].size(); p++)
       {
         //el_p is the element position that contains information about the CI coefficient, and det up/dn values associated with the current unique determinant
         const int el_p(lookup_tbl[index][p]);
         const RealType c  = cptr[el_p];
         const size_t up   = upC[el_p];
         const size_t down = dnC[el_p];
 
         const RealType alpha_4(c * detValues_dn[down] * detValues_up[up] * (1 / psiCurrent));
 
         for (int i = 0; i < k; i++)
         {
           BLAS::axpy(nel, alpha_4, Y7.data() + i * nel, 1, pK4.data() + (data_it[datum + 1 + k + i]) * nel, 1);
         }
       }
       datum += 3 * k + 1;
     }
   }
 
   BLAS::gemm('N', 'N', nmo, nmo, nel, RealType(1.0), T, nmo, pK4.data(), nel, RealType(0.0), K4T.data(), nmo);
   BLAS::gemm('N', 'N', nmo, nel, nmo, RealType(1.0), K4T.data(), nmo, T, nmo, RealType(0.0), TK4T.data(), nmo);
 
   for (int mu = 0, k = parameter_start_index; k < (parameter_start_index + parameters_size); k++, mu++)
   {
     int kk = myVars.where(k);
     if (kk >= 0)
     {
       const int i(m_act_rot_inds_[mu].first), j(m_act_rot_inds_[mu].second);
       if (i <= nel - 1 && j > nel - 1)
       {
         dlogpsi[kk] += ValueType(detValues_up[0] * (Table(i, j)) * const0 * (1 / psiCurrent) +
                                  (K4T(i, j) - K4T(j, i) - TK4T(i, j)));
       }
       else if (i <= nel - 1 && j <= nel - 1)
       {
         dlogpsi[kk] += ValueType(detValues_up[0] * (Table(i, j) - Table(j, i)) * const0 * (1 / psiCurrent) +
                                  (K4T(i, j) - TK4T(i, j) - K4T(j, i) + TK4T(j, i)));
       }
       else
       {
         dlogpsi[kk] += ValueType((K4T(i, j) - K4T(j, i)));
       }
     }
   }
 #endif
 }

◆ writeVariationalParameters()

void writeVariationalParameters ( hdf_archive & hout )

overridevirtual

Write the variational parameters for this object to the VP HDF file.

The hout parameter should come from VariableSet::writeToHDF

Objects can use this function to store additional information to the file.

By default the parameters are saved in VariableSet::writeToHDF, and objects do not need to implement this function (yet).

Reimplemented from OptimizableObject.

Definition at line 144 of file RotatedSPOs.cpp.

References SPOSet::getName(), RotatedSPOs::history_params_, RotatedSPOs::m_act_rot_inds_, SPOSet::myVars, RotatedSPOs::myVarsFull_, hdf_archive::pop(), hdf_archive::push(), VariableSet::size(), RotatedSPOs::use_global_rot_, and hdf_archive::write().

Referenced by qmcplusplus::TEST_CASE().

 {
   hout.push("RotatedSPOs");
   if (use_global_rot_)
   {
     hout.push("rotation_global");
     const std::string rot_global_name = std::string("rotation_global_") + SPOSet::getName();
 
     hout.write(myVarsFull_, rot_global_name);
     hout.pop();
   }
   else
   {
     hout.push("rotation_history");
     size_t rows = history_params_.size();
     size_t cols = 0;
     if (rows > 0)
       cols = history_params_[0].size();
 
     Matrix<ValueType> tmp(rows, cols);
     for (size_t i = 0; i < rows; i++)
       for (size_t j = 0; j < cols; j++)
         tmp[i][j] = history_params_[i][j];
     std::string rot_hist_name = std::string("rotation_history_") + SPOSet::getName();
     hout.write(tmp, rot_hist_name);
     hout.pop();
   }
 
   // Save myVars in order to restore object state exactly
   //  The values aren't meaningful, but they need to match those saved in VariableSet
   hout.push("rotation_params");
   std::string rot_params_name = std::string("rotation_params_") + SPOSet::getName();
 
   std::vector<ValueType> params(m_act_rot_inds_.size());
   auto* params_data_alias = (RealType*)params.data();
   for (int i = 0; i < myVars.size(); i++)
     params_data_alias[i] = myVars[i];
 
   hout.write(params, rot_params_name);
   hout.pop();
 
   hout.pop();
 }

Friends And Related Function Documentation

◆ testing::getHistoryParams

std::vector<std::vector<ValueType> >& testing::getHistoryParams ( RotatedSPOs & rot )

friend

◆ testing::getMyVarsFull

std::vector<ValueType>& testing::getMyVarsFull ( RotatedSPOs & rot )

friend

Member Data Documentation

◆ apply_rotation_timer_

NewTimer& apply_rotation_timer_

private

timer for apply_rotation

Definition at line 472 of file RotatedSPOs.h.

Referenced by RotatedSPOs::apply_rotation(), and RotatedSPOs::applyDeltaRotation().

◆ Bbar

ValueMatrix Bbar

Definition at line 139 of file RotatedSPOs.h.

Referenced by RotatedSPOs::evaluateDerivatives(), RotatedSPOs::table_method_eval(), and RotatedSPOs::table_method_evalWF().

◆ d2psiM_all

ValueMatrix d2psiM_all

Definition at line 143 of file RotatedSPOs.h.

Referenced by RotatedSPOs::evaluateDerivatives(), RotatedSPOs::evaluateDerivativesWF(), and RotatedSPOs::evaluateDerivRatios().

◆ dpsiM_all

GradMatrix dpsiM_all

Definition at line 142 of file RotatedSPOs.h.

Referenced by RotatedSPOs::evaluateDerivatives(), RotatedSPOs::evaluateDerivativesWF(), and RotatedSPOs::evaluateDerivRatios().

◆ history_params_

std::vector<std::vector<ValueType> > history_params_

private

List of previously applied parameters.

Definition at line 475 of file RotatedSPOs.h.

Referenced by RotatedSPOs::applyRotationHistory(), qmcplusplus::testing::getHistoryParams(), RotatedSPOs::makeClone(), RotatedSPOs::readVariationalParameters(), RotatedSPOs::resetParametersExclusive(), and RotatedSPOs::writeVariationalParameters().

◆ m_act_rot_inds_

RotationIndices m_act_rot_inds_

Definition at line 54 of file RotatedSPOs.h.

Referenced by RotatedSPOs::apply_rotation(), RotatedSPOs::applyDeltaRotation(), RotatedSPOs::buildOptVariables(), RotatedSPOs::evaluateDerivatives(), RotatedSPOs::evaluateDerivativesWF(), RotatedSPOs::evaluateDerivRatios(), RotatedSPOs::makeClone(), RotatedSPOs::resetParametersExclusive(), RotatedSPOs::table_method_eval(), RotatedSPOs::table_method_evalWF(), and RotatedSPOs::writeVariationalParameters().

◆ m_full_rot_inds_

RotationIndices m_full_rot_inds_

Definition at line 57 of file RotatedSPOs.h.

Referenced by RotatedSPOs::applyDeltaRotation(), RotatedSPOs::applyFullRotation(), RotatedSPOs::buildOptVariables(), RotatedSPOs::makeClone(), and RotatedSPOs::resetParametersExclusive().

◆ myG_J

ParticleSet::ParticleGradient myG_J

Definition at line 136 of file RotatedSPOs.h.

Referenced by RotatedSPOs::evaluateDerivatives(), and RotatedSPOs::table_method_eval().

◆ myG_temp

ParticleSet::ParticleGradient myG_temp

Definition at line 136 of file RotatedSPOs.h.

Referenced by RotatedSPOs::evaluateDerivatives().

◆ myL_J

ParticleSet::ParticleLaplacian myL_J

Definition at line 137 of file RotatedSPOs.h.

Referenced by RotatedSPOs::evaluateDerivatives(), and RotatedSPOs::table_method_eval().

◆ myL_temp

ParticleSet::ParticleLaplacian myL_temp

Definition at line 137 of file RotatedSPOs.h.

Referenced by RotatedSPOs::evaluateDerivatives().

◆ myVarsFull_

std::vector<ValueType> myVarsFull_

private

Full set of rotation matrix parameters for use in global rotation method.

Definition at line 469 of file RotatedSPOs.h.

Referenced by RotatedSPOs::buildOptVariables(), qmcplusplus::testing::getMyVarsFull(), RotatedSPOs::makeClone(), RotatedSPOs::readVariationalParameters(), RotatedSPOs::resetParametersExclusive(), and RotatedSPOs::writeVariationalParameters().

◆ nel_major_

size_t nel_major_

the number of electrons of the majority spin

Definition at line 127 of file RotatedSPOs.h.

Referenced by RotatedSPOs::buildOptVariables().

◆ params_

std::vector<ValueType> params_

private

list of supplied orbital rotation parameters.

Definition at line 466 of file RotatedSPOs.h.

Referenced by RotatedSPOs::buildOptVariables(), RotatedSPOs::makeClone(), and RotatedSPOs::setRotationParameters().

◆ params_supplied_

bool params_supplied_

private

true if SPO parameters (orbital rotation parameters) have been supplied by input

Definition at line 464 of file RotatedSPOs.h.

Referenced by RotatedSPOs::buildOptVariables(), RotatedSPOs::makeClone(), and RotatedSPOs::setRotationParameters().

◆ Phi_

std::unique_ptr<SPOSet> Phi_

Definition at line 119 of file RotatedSPOs.h.

◆ psiM_all

ValueMatrix psiM_all

Definition at line 141 of file RotatedSPOs.h.

Referenced by RotatedSPOs::evaluateDerivatives(), RotatedSPOs::evaluateDerivativesWF(), and RotatedSPOs::evaluateDerivRatios().

◆ psiM_inv

ValueMatrix psiM_inv

Definition at line 140 of file RotatedSPOs.h.

Referenced by RotatedSPOs::evaluateDerivatives(), RotatedSPOs::evaluateDerivativesWF(), and RotatedSPOs::evaluateDerivRatios().

◆ use_global_rot_

bool use_global_rot_ = true

private

Use global rotation or history list.

Definition at line 480 of file RotatedSPOs.h.

Referenced by RotatedSPOs::buildOptVariables(), RotatedSPOs::makeClone(), RotatedSPOs::resetParametersExclusive(), RotatedSPOs::set_use_global_rotation(), and RotatedSPOs::writeVariationalParameters().

The documentation for this class was generated from the following files:

/home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCWaveFunctions/RotatedSPOs.h
/home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCWaveFunctions/RotatedSPOs.cpp

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ RotationIndices

Constructor & Destructor Documentation

◆ RotatedSPOs()

◆ ~RotatedSPOs()

Member Function Documentation

◆ acquireResource()

◆ apply_rotation()

◆ applyDeltaRotation()

◆ applyFullRotation()

◆ applyRotationHistory()

◆ buildOptVariables() [1/2]

◆ buildOptVariables() [2/2]

◆ checkInVariablesExclusive()

◆ checkObject()

◆ checkOutVariables()

◆ constructAntiSymmetricMatrix()

◆ constructDeltaRotation()

◆ createResource()

◆ createRotationIndices()

◆ createRotationIndicesFull()

◆ evaluate_notranspose() [1/3]

◆ evaluate_notranspose() [2/3]

◆ evaluate_notranspose() [3/3]

◆ evaluate_spin()

◆ evaluateDerivatives() [1/2]

◆ evaluateDerivatives() [2/2]

◆ evaluateDerivativesWF() [1/2]

◆ evaluateDerivativesWF() [2/2]

◆ evaluateDerivRatios()

◆ evaluateDetRatios()

◆ evaluateGradSource() [1/2]

◆ evaluateGradSource() [2/2]

◆ evaluateValue()

◆ evaluateVGH()

◆ evaluateVGHGH()

◆ evaluateVGL()

◆ evaluateVGL_spin()

◆ exponentiate_antisym_matrix()

◆ extractOptimizableObjectRefs()

◆ extractParamsFromAntiSymmetricMatrix()

◆ extractPhiRefList()

◆ getClassName()

◆ hasIonDerivs()

◆ isOMPoffload()

◆ isOptimizable()

◆ log_antisym_matrix()

◆ makeClone()

◆ mw_evaluate_notranspose()

◆ mw_evaluateDetRatios()

◆ mw_evaluateValue()

◆ mw_evaluateVGL()

◆ mw_evaluateVGLandDetRatioGrads()

◆ mw_evaluateVGLandDetRatioGradsWithSpin()

◆ mw_evaluateVGLWithSpin()

◆ readVariationalParameters()

◆ releaseResource()

◆ resetParametersExclusive()

◆ set_use_global_rotation()

◆ setOrbitalSetSize()

◆ setRotationParameters()

◆ table_method_eval()

◆ table_method_evalWF()

◆ writeVariationalParameters()

Friends And Related Function Documentation

◆ testing::getHistoryParams

◆ testing::getMyVarsFull

Member Data Documentation

◆ apply_rotation_timer_

◆ Bbar

◆ d2psiM_all