QMCHamiltonian Class Reference

Collection of Local Energy Operators. More...

Collaboration diagram for QMCHamiltonian:

Classes
struct	QMCHamiltonianMultiWalkerResource

Public Types
enum	{ DIM = OHMMS_DIM }
using	Return_t = OperatorBase::Return_t
using	PosType = OperatorBase::PosType
using	TensorType = OperatorBase::TensorType
using	RealType = OperatorBase::RealType
using	ValueType = OperatorBase::ValueType
using	FullPrecRealType = QMCTraits::FullPrecRealType
using	PropertySetType = OperatorBase::PropertySetType
using	BufferType = OperatorBase::BufferType
using	Walker_t = OperatorBase::Walker_t
using	WP = WalkerProperties::Indexes
using	ValueMatrix = SPOSet::ValueMatrix

Public Member Functions
	QMCHamiltonian (const std::string &aname="psi0")
	constructor More...
	~QMCHamiltonian ()
	destructor More...
void	addOperator (std::unique_ptr< OperatorBase > &&h, const std::string &aname, bool physical=true)
	add an operator More...
void	addOperatorType (const std::string &name, const std::string &type)
	record the name-type pair of an operator More...
const std::string &	getOperatorType (const std::string &name)
	return type of named H element or fail More...
int	size () const
	return the number of Hamiltonians More...
int	total_size () const
	return the total number of Hamiltonians (physical + aux) More...
OperatorBase *	getHamiltonian (const std::string &aname)
	return OperatorBase with the name aname More...
OperatorBase *	getHamiltonian (int i)
	return i-th OperatorBase More...
RefVector< OperatorBase >	getTWFDependentComponents ()
	return components, auxH not included, depending on TWF. More...
void	initialize_traces (TraceManager &tm, ParticleSet &P)
	initialize trace data More...
void	collect_walker_traces (Walker_t &walker, int step)
	collect walker trace data More...
void	finalize_traces ()
	finalize trace data More...
int	addObservables (ParticleSet &P)
	add each term to the PropertyList for averages More...
void	registerObservables (std::vector< ObservableHelper > &h5desc, hdf_archive &file) const
	register obsevables so that their averages can be dumped to hdf5 More...
void	registerCollectables (std::vector< ObservableHelper > &h5desc, hdf_archive &file) const
	register collectables so that their averages can be dumped to hdf5 More...
void	informOperatorsOfListener ()
	Some Hamiltonian components need to be informed that they are in a per particle reporting situation so additional state can be added either to them or the objects they are strongly coupled with. More...
int	startIndex () const
	retrun the starting index More...
int	sizeOfObservables () const
	return the size of observables More...
int	sizeOfCollectables () const
	return the size of collectables More...
RealType	getObservable (int i) const
	return the value of the i-th observable More...
int	getObservable (std::string Oname) const
	return the value of the observable with a set name if it exists More...
std::string	getObservableName (int i) const
	return the name of the i-th observable More...
template<class IT , typename = std::enable_if_t<std::is_same<std::add_pointer<FullPrecRealType>::type, IT>::value>>
void	saveProperty (IT first)
	save the values of Hamiltonian elements to the Properties More...
template<class IT , typename = std::enable_if_t<std::is_same<std::add_pointer<FullPrecRealType>::type, IT>::value>>
void	setProperty (IT first)
void	updateSource (ParticleSet &s)
	remove a named Hamiltonian from the list More...
FullPrecRealType	getLocalEnergy ()
FullPrecRealType	getLocalPotential ()
FullPrecRealType	getKineticEnergy ()
void	auxHevaluate (ParticleSet &P)
void	auxHevaluate (ParticleSet &P, Walker_t &ThisWalker)
	This is more efficient. Only calculate auxH elements if moves are accepted. More...
void	auxHevaluate (ParticleSet &P, Walker_t &ThisWalker, bool do_properties, bool do_collectables)
	Evaluate properties only. More...
void	rejectedMove (ParticleSet &P, Walker_t &ThisWalker)
	Looks like a hack see DMCBatched.cpp and DMC.cpp weight is used like temporary flag from DMC. More...
void	setPrimary (bool primary)
	set PRIMARY bit of all the components More...
FullPrecRealType	evaluate (ParticleSet &P)
	evaluate Local Energy More...
FullPrecRealType	evaluateDeterministic (ParticleSet &P)
	evaluate Local Energy deterministically. More...
FullPrecRealType	evaluateWithToperator (ParticleSet &P)
	evaluate Local energy with Toperators updated. More...
FullPrecRealType	evaluateValueAndDerivatives (ParticleSet &P, const opt_variables_type &optvars, Vector< ValueType > &dlogpsi, Vector< ValueType > &dhpsioverpsi)
	evaluate energy and derivatives wrt to the variables More...
FullPrecRealType	evaluateIonDerivsDeterministicFast (ParticleSet &P, ParticleSet &ions, TrialWaveFunction &psi_in, TWFFastDerivWrapper &psi_wrapper, ParticleSet::ParticlePos &dedr, ParticleSet::ParticlePos &wf_grad)
	evaluate local energy and derivatives w.r.t ionic coordinates, but deterministically. More...
void	evaluateElecGrad (ParticleSet &P, TrialWaveFunction &psi, ParticleSet::ParticlePos &EGrad, RealType delta=1e-5)
	Evaluate the electron gradient of the local energy. More...
FullPrecRealType	evaluateIonDerivs (ParticleSet &P, ParticleSet &ions, TrialWaveFunction &psi, ParticleSet::ParticlePos &hf_terms, ParticleSet::ParticlePos &pulay_terms, ParticleSet::ParticlePos &wf_grad)
	evaluate local energy and derivatives w.r.t ionic coordinates. More...
FullPrecRealType	evaluateIonDerivsDeterministic (ParticleSet &P, ParticleSet &ions, TrialWaveFunction &psi, ParticleSet::ParticlePos &hf_terms, ParticleSet::ParticlePos &pulay_terms, ParticleSet::ParticlePos &wf_grad)
	evaluate local energy and derivatives w.r.t ionic coordinates, but deterministically. More...
void	setNonLocalMoves (xmlNodePtr cur)
	set non local moves options More...
void	setNonLocalMoves (const std::string &non_local_move_option, const double tau, const double alpha, const double gamma)
int	makeNonLocalMoves (ParticleSet &P)
	make non local moves More...
bool	has_L2 ()
	determine if L2 potential is present More...
void	computeL2DK (ParticleSet &P, int iel, TensorType &D, PosType &K)
	compute D matrix and K vector for L2 potential propagator More...
void	computeL2D (ParticleSet &P, int iel, TensorType &D)
	compute D matrix for L2 potential propagator More...
FullPrecRealType	evaluateVariableEnergy (ParticleSet &P, bool free_nlpp)
	evaluate energy More...
FullPrecRealType	getEnsembleAverage ()
	return an average value of the LocalEnergy More...
void	resetTargetParticleSet (ParticleSet &P)
const std::string &	getName () const
bool	get (std::ostream &os) const
void	setRandomGenerator (RandomBase< FullPrecRealType > *rng)
void	createResource (ResourceCollection &collection) const
	initialize a shared resource and hand it to a collection More...
std::unique_ptr< QMCHamiltonian >	makeClone (ParticleSet &qp, TrialWaveFunction &psi) const
	return a clone More...

Static Public Member Functions
static void	mw_registerKineticListener (QMCHamiltonian &ham_leader, ListenerVector< RealType > listener)
	Listener Registration This must be called on a QMCHamiltonian that has acquired multiwalker resources. More...
static void	mw_registerLocalEnergyListener (QMCHamiltonian &ham_leader, ListenerVector< RealType > listener)
static void	mw_registerLocalPotentialListener (QMCHamiltonian &ham_leader, ListenerVector< RealType > listener)
static void	mw_registerLocalIonPotentialListener (QMCHamiltonian &ham_leader, ListenerVector< RealType > listener)
static std::vector< QMCHamiltonian::FullPrecRealType >	mw_evaluate (const RefVectorWithLeader< QMCHamiltonian > &ham_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list)
	batched version of evaluate for LocalEnergy More...
static std::vector< QMCHamiltonian::FullPrecRealType >	mw_evaluateWithToperator (const RefVectorWithLeader< QMCHamiltonian > &ham_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list)
	batched version of evaluate Local energy with Toperators updated. More...
static std::vector< QMCHamiltonian::FullPrecRealType >	mw_evaluateValueAndDerivatives (const RefVectorWithLeader< QMCHamiltonian > &ham_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, const opt_variables_type &optvars, RecordArray< ValueType > &dlogpsi, RecordArray< ValueType > &dhpsioverpsi)
static std::vector< int >	mw_makeNonLocalMoves (const RefVectorWithLeader< QMCHamiltonian > &ham_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list)
static void	updateComponent (OperatorBase &op, QMCHamiltonian &ham, ParticleSet &pset)
	accumulate local energy and update Observables and PropertyList More...
static void	updateKinetic (QMCHamiltonian &ham, ParticleSet &pset)
	extract kinetic and potential energies. More...
static void	acquireResource (ResourceCollection &collection, const RefVectorWithLeader< QMCHamiltonian > &ham_list)
	acquire external resource Note: use RAII ResourceCollectionLock whenever possible More...
static void	releaseResource (ResourceCollection &collection, const RefVectorWithLeader< QMCHamiltonian > &ham_list)
	release external resource Note: use RAII ResourceCollectionLock whenever possible More...

Private Member Functions
void	resetObservables (int start, int ncollects)
	reset Observables and counters More...
void	reportToListeners ()

Static Private Member Functions
static RefVectorWithLeader< OperatorBase >	extract_HC_list (const RefVectorWithLeader< QMCHamiltonian > &ham_list, int id)

Private Attributes
int	myIndex
	starting index More...
int	numCollectables
	starting index More...
FullPrecRealType	LocalEnergy
	Current Local Energy. More...
FullPrecRealType	KineticEnergy
	Current Kinetic Energy. More...
FullPrecRealType	NewLocalEnergy
	Current Local Energy for the proposed move. More...
const std::string	myName
	getName is in the way More...
std::vector< std::unique_ptr< OperatorBase > >	H
	vector of Hamiltonians More...
NonLocalECPotential *	nlpp_ptr
	pointer to NonLocalECP More...
L2Potential *	l2_ptr
	pointer to L2Potential More...
std::vector< std::unique_ptr< OperatorBase > >	auxH
	vector of Hamiltonians More...
NewTimer &	ham_timer_
	Total timer for H evaluation. More...
NewTimer &	eval_vals_derivs_timer_
	Total timer for H evaluation. More...
NewTimer &	eval_ion_derivs_fast_timer_
	Total timer for H ion deriv evaluation;. More...
std::vector< std::reference_wrapper< NewTimer > >	my_timers_
	timers for H components More...
std::map< std::string, std::string >	operator_types
	types of component operators More...
PropertySetType	Observables
	data More...
TraceRequest	request
	traces variables More...
bool	streaming_position
Array< TraceInt, 1 > *	id_sample
Array< TraceInt, 1 > *	pid_sample
Array< TraceInt, 1 > *	step_sample
Array< TraceInt, 1 > *	gen_sample
Array< TraceInt, 1 > *	age_sample
Array< TraceInt, 1 > *	mult_sample
Array< TraceReal, 1 > *	weight_sample
Array< TraceReal, 2 > *	position_sample
ResourceHandle< QMCHamiltonianMultiWalkerResource >	mw_res_handle_

Static Private Attributes
static constexpr std::array< std::string_view, 8 >	available_quantities_

Friends
class	HamiltonianFactory

Detailed Description

Collection of Local Energy Operators.

Note that QMCHamiltonian is not derived from QMCHmailtonianBase.

Definition at line 49 of file QMCHamiltonian.h.

Member Typedef Documentation

BufferType

using BufferType = OperatorBase::BufferType

Definition at line 61 of file QMCHamiltonian.h.

FullPrecRealType

using FullPrecRealType = QMCTraits::FullPrecRealType

Definition at line 59 of file QMCHamiltonian.h.

PosType

using PosType = OperatorBase::PosType

Definition at line 55 of file QMCHamiltonian.h.

PropertySetType

using PropertySetType = OperatorBase::PropertySetType

Definition at line 60 of file QMCHamiltonian.h.

RealType

using RealType = OperatorBase::RealType

Definition at line 57 of file QMCHamiltonian.h.

Return_t

using Return_t = OperatorBase::Return_t

Definition at line 54 of file QMCHamiltonian.h.

TensorType

using TensorType = OperatorBase::TensorType

Definition at line 56 of file QMCHamiltonian.h.

ValueMatrix

using ValueMatrix = SPOSet::ValueMatrix

Definition at line 64 of file QMCHamiltonian.h.

ValueType

using ValueType = OperatorBase::ValueType

Definition at line 58 of file QMCHamiltonian.h.

Walker_t

using Walker_t = OperatorBase::Walker_t

Definition at line 62 of file QMCHamiltonian.h.

WP

using WP = WalkerProperties::Indexes

Definition at line 63 of file QMCHamiltonian.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
DIM

Definition at line 65 of file QMCHamiltonian.h.

  {
    DIM = OHMMS_DIM
  };

Constructor & Destructor Documentation

QMCHamiltonian()

QMCHamiltonian

(

const std::string &

aname = "psi0"

)

constructor

Definition at line 49 of file QMCHamiltonian.cpp.

    : myIndex(0),
      numCollectables(0),
      myName(aname),
      nlpp_ptr(nullptr),
      l2_ptr(nullptr),
      ham_timer_(createGlobalTimer("Hamiltonian:" + aname + "::evaluate", timer_level_medium)),
      eval_vals_derivs_timer_(createGlobalTimer("Hamiltonian:" + aname + "::ValueParamDerivs", timer_level_medium)),
      eval_ion_derivs_fast_timer_(
          createGlobalTimer("Hamiltonian:" + aname + ":::evaluateIonDerivsDeterministicFast", timer_level_medium))
#if !defined(REMOVE_TRACEMANAGER)
      ,
      streaming_position(false),
      id_sample(nullptr),
      pid_sample(nullptr),
      step_sample(nullptr),
      gen_sample(nullptr),
      age_sample(nullptr),
      mult_sample(nullptr),
      weight_sample(nullptr),
      position_sample(nullptr)
#endif
{}

~QMCHamiltonian()

~QMCHamiltonian

(

)

destructor

Definition at line 78 of file QMCHamiltonian.cpp.

{
  //@todo clean up H and auxH
}

Member Function Documentation

acquireResource()

void acquireResource ( ResourceCollection &  collection, const RefVectorWithLeader< QMCHamiltonian > &  ham_list  )

static

acquire external resource Note: use RAII ResourceCollectionLock whenever possible

Definition at line 1042 of file QMCHamiltonian.cpp.

References QMCHamiltonian::extract_HC_list(), RefVectorWithLeader< T >::getLeader(), and ResourceCollection::lendResource().

{
  auto& ham_leader          = ham_list.getLeader();
  ham_leader.mw_res_handle_ = collection.lendResource<QMCHamiltonianMultiWalkerResource>();
  for (int i_ham_op = 0; i_ham_op < ham_leader.H.size(); ++i_ham_op)
  {
    const auto HC_list(extract_HC_list(ham_list, i_ham_op));
    ham_leader.H[i_ham_op]->acquireResource(collection, HC_list);
  }
}

addOperator()

void addOperator	(	std::unique_ptr< OperatorBase > &&	h,
		const std::string &	aname,
		bool	physical = true
	)

add an operator

add a new Hamiltonian the the list of Hamiltonians.

Parameters

h	an operator
aname	name of h
physical	if true, a physical operator

Definition at line 99 of file QMCHamiltonian.cpp.

References APP_ABORT, qmcplusplus::app_log(), qmcplusplus::app_warning(), QMCHamiltonian::auxH, qmcplusplus::createGlobalTimer(), QMCHamiltonian::getName(), QMCHamiltonian::H, QMCHamiltonian::l2_ptr, QMCHamiltonian::my_timers_, QMCHamiltonian::nlpp_ptr, OperatorBase::PHYSICAL, and qmcplusplus::timer_level_fine.

Referenced by ACForce::add2Hamiltonian(), OperatorBase::add2Hamiltonian(), CostFunctionCrowdData::CostFunctionCrowdData(), ECPotentialBuilder::put(), and qmcplusplus::TEST_CASE().

{
  //change UpdateMode[PHYSICAL] of h so that cloning can be done correctly
  h->getUpdateMode()[OperatorBase::PHYSICAL] = physical;
  if (physical)
  {
    for (int i = 0; i < H.size(); ++i)
    {
      if (H[i]->getName() == aname)
      {
        app_warning() << "QMCHamiltonian::addOperator cannot " << aname << ". The name is already used" << std::endl;
        return;
      }
    }
    app_log() << "  QMCHamiltonian::addOperator " << aname << " to H, physical Hamiltonian " << std::endl;
    h->setName(aname);
    H.push_back(std::move(h));
    std::string tname = "Hamiltonian:" + aname;
    my_timers_.push_back(createGlobalTimer(tname, timer_level_fine));
  }
  else
  {
    //ignore timers for now
    for (int i = 0; i < auxH.size(); ++i)
    {
      if (auxH[i]->getName() == aname)
      {
        app_warning() << "QMCHamiltonian::addOperator cannot " << aname << ". The name is already used" << std::endl;
        return;
      }
    }
    app_log() << "  QMCHamiltonian::addOperator " << aname << " to auxH " << std::endl;
    h->setName(aname);
    auxH.push_back(std::move(h));
  }

  //assign save NLPP if found
  //  name is fixed in ECPotentialBuilder::put()
  if (aname == "NonLocalECP")
  {
    if (nlpp_ptr == nullptr)
    {
      // original h arguments moved to either H or auxH
      nlpp_ptr = physical ? dynamic_cast<NonLocalECPotential*>(H.back().get())
                          : dynamic_cast<NonLocalECPotential*>(auxH.back().get());
    }
    else
    {
      APP_ABORT("QMCHamiltonian::addOperator nlpp_ptr is supposed to be null. Something went wrong!");
    }
  }

  //save L2 potential if found
  //  name is fixed in ECPotentialBuilder::put()
  if (aname == "L2")
  {
    if (l2_ptr == nullptr)
    {
      l2_ptr = physical ? dynamic_cast<L2Potential*>(H.back().get()) : dynamic_cast<L2Potential*>(auxH.back().get());
    }
    else
    {
      APP_ABORT("QMCHamiltonian::addOperator l2_ptr is supposed to be null. Something went wrong!");
    }
  }
}

addOperatorType()

void addOperatorType	(	const std::string &	name,
		const std::string &	type
	)

record the name-type pair of an operator

Definition at line 167 of file QMCHamiltonian.cpp.

References qmcplusplus::app_log(), and QMCHamiltonian::operator_types.

{
  app_log() << "QMCHamiltonian::addOperatorType added type " << type << " named " << name << std::endl;
  operator_types[name] = type;
}

auxHevaluate() [1/3]

void auxHevaluate

(

ParticleSet &

P

)

Definition at line 723 of file QMCHamiltonian.cpp.

References QMCHamiltonian::auxH, QMCHamiltonian::myIndex, QMCHamiltonian::Observables, and ParticleSet::PropertyList.

Referenced by SOVMCUpdateAll::advanceWalker(), SODMCUpdatePbyPWithRejectionFast::advanceWalker(), DMCUpdateAllWithRejection::advanceWalker(), VMCUpdateAll::advanceWalker(), VMCUpdatePbyP::advanceWalker(), DMCUpdatePbyPWithRejectionFast::advanceWalker(), SOVMCUpdatePbyP::advanceWalker(), DMCUpdatePbyPL2::advanceWalker(), DMCUpdateAllWithKill::advanceWalker(), VMCBatched::advanceWalkers(), RMCUpdatePbyPWithDrift::advanceWalkersRMC(), RMCUpdateAllWithDrift::advanceWalkersRMC(), RMCUpdatePbyPWithDrift::advanceWalkersVMC(), RMCUpdateAllWithDrift::advanceWalkersVMC(), QMCDriverNew::initialLogEvaluation(), RMCUpdateAllWithDrift::initWalkers(), QMCUpdateBase::initWalkersForPbyP(), and WaveFunctionTester::runGradSourceTest().

{
  for (int i = 0; i < auxH.size(); ++i)
  {
    RealType sink = auxH[i]->evaluate(P);
    auxH[i]->setObservables(Observables);
#if !defined(REMOVE_TRACEMANAGER)
    auxH[i]->collectScalarTraces();
#endif
    auxH[i]->setParticlePropertyList(P.PropertyList, myIndex);
    //H[i]->setParticlePropertyList(P.PropertyList,myIndex);
  }
}

auxHevaluate() [2/3]

void auxHevaluate	(	ParticleSet &	P,
		Walker_t &	ThisWalker
	)

This is more efficient. Only calculate auxH elements if moves are accepted.

Definition at line 738 of file QMCHamiltonian.cpp.

References QMCHamiltonian::auxH, QMCHamiltonian::collect_walker_traces(), ParticleSet::current_step, QMCHamiltonian::myIndex, QMCHamiltonian::Observables, and ParticleSet::PropertyList.

{
#if !defined(REMOVE_TRACEMANAGER)
  collect_walker_traces(ThisWalker, P.current_step);
#endif
  for (int i = 0; i < auxH.size(); ++i)
  {
    auxH[i]->setHistories(ThisWalker);
    RealType sink = auxH[i]->evaluate(P);
    auxH[i]->setObservables(Observables);
#if !defined(REMOVE_TRACEMANAGER)
    auxH[i]->collectScalarTraces();
#endif
    auxH[i]->setParticlePropertyList(P.PropertyList, myIndex);
  }
}

auxHevaluate() [3/3]

void auxHevaluate	(	ParticleSet &	P,
		Walker_t &	ThisWalker,
		bool	do_properties,
		bool	do_collectables
	)

Evaluate properties only.

Definition at line 755 of file QMCHamiltonian.cpp.

References QMCHamiltonian::auxH, QMCHamiltonian::collect_walker_traces(), OperatorBase::COLLECTABLE, ParticleSet::current_step, QMCHamiltonian::myIndex, QMCHamiltonian::Observables, and ParticleSet::PropertyList.

{
#if !defined(REMOVE_TRACEMANAGER)
  collect_walker_traces(ThisWalker, P.current_step);
#endif
  for (int i = 0; i < auxH.size(); ++i)
  {
    bool is_property    = !(auxH[i]->getMode(OperatorBase::COLLECTABLE));
    bool is_collectable = (auxH[i]->getMode(OperatorBase::COLLECTABLE));
    if ((is_property && do_properties) || (is_collectable && do_collectables))
    {
      auxH[i]->setHistories(ThisWalker);
      RealType sink = auxH[i]->evaluate(P);
      auxH[i]->setObservables(Observables);
#if !defined(REMOVE_TRACEMANAGER)
      auxH[i]->collectScalarTraces();
#endif
      auxH[i]->setParticlePropertyList(P.PropertyList, myIndex);
    }
  }
}

collect_walker_traces()

void collect_walker_traces	(	Walker_t &	walker,
		int	step
	)

collect walker trace data

Definition at line 491 of file QMCHamiltonian.cpp.

References QMCHamiltonian::age_sample, QMCHamiltonian::DIM, QMCHamiltonian::mult_sample, QMCHamiltonian::position_sample, QMCHamiltonian::request, TraceRequest::streaming_default_scalars, QMCHamiltonian::streaming_position, qmcplusplus::walker, and QMCHamiltonian::weight_sample.

Referenced by QMCHamiltonian::auxHevaluate(), and QMCHamiltonian::rejectedMove().

{
  if (request.streaming_default_scalars)
  {
    (*id_sample)(0)     = walker.getWalkerID();
    (*pid_sample)(0)    = walker.getParentID();
    (*step_sample)(0)   = step;
    (*gen_sample)(0)    = walker.Generation;
    (*age_sample)(0)    = walker.Age;
    (*mult_sample)(0)   = walker.Multiplicity;
    (*weight_sample)(0) = walker.Weight;
  }
  if (streaming_position)
    for (int i = 0; i < walker.R.size(); ++i)
      for (int d = 0; d < DIM; ++d)
        (*position_sample)(i, d) = walker.R[i][d];
}

computeL2D()

void computeL2D ( ParticleSet &  P, int  iel, TensorType &  D  )

inline

compute D matrix for L2 potential propagator

Parameters

r	single particle coordinate
D	diffusion matrix (outputted)

Definition at line 381 of file QMCHamiltonian.h.

References L2Potential::evaluateD(), and QMCHamiltonian::l2_ptr.

Referenced by DMCUpdatePbyPL2::advanceWalker().

  {
    if (l2_ptr != nullptr)
      l2_ptr->evaluateD(P, iel, D);
  }

computeL2DK()

void computeL2DK ( ParticleSet &  P, int  iel, TensorType &  D, PosType &  K  )

inline

compute D matrix and K vector for L2 potential propagator

Parameters

r	single particle coordinate
D	diffusion matrix (outputted)
K	drift modification vector (outputted)

Definition at line 371 of file QMCHamiltonian.h.

References L2Potential::evaluateDK(), qmcplusplus::Units::energy::K, and QMCHamiltonian::l2_ptr.

Referenced by DMCUpdatePbyPL2::advanceWalker().

  {
    if (l2_ptr != nullptr)
      l2_ptr->evaluateDK(P, iel, D, K);
  }

createResource()

void createResource

(

ResourceCollection &

collection

)

const

initialize a shared resource and hand it to a collection

Definition at line 1035 of file QMCHamiltonian.cpp.

References ResourceCollection::addResource(), and QMCHamiltonian::H.

Referenced by CostFunctionCrowdData::CostFunctionCrowdData(), and QMCDriverNew::initializeQMC().

{
  auto resource_index = collection.addResource(std::make_unique<QMCHamiltonianMultiWalkerResource>());
  for (int i = 0; i < H.size(); ++i)
    H[i]->createResource(collection);
}

evaluate()

QMCHamiltonian::FullPrecRealType evaluate

(

ParticleSet &

P

)

evaluate Local Energy

Evaluate all the Hamiltonians for the N-particle configuration.

Parameters

P	ParticleSet

Returns

the local energy

P.R, P.G and P.L are used to evaluate the LocalEnergy.

Parameters

P	input configuration containing N particles

Returns

the local energy

Definition at line 540 of file QMCHamiltonian.cpp.

References QMCHamiltonian::H, QMCHamiltonian::ham_timer_, QMCHamiltonian::LocalEnergy, QMCHamiltonian::my_timers_, QMCHamiltonian::updateComponent(), and QMCHamiltonian::updateKinetic().

Referenced by SOVMCUpdateAll::advanceWalker(), VMCUpdateAll::advanceWalker(), SOVMCUpdatePbyP::advanceWalker(), VMCUpdatePbyP::advanceWalker(), DMCUpdateAllWithKill::advanceWalker(), RMCUpdatePbyPWithDrift::advanceWalkersRMC(), RMCUpdateAllWithDrift::advanceWalkersRMC(), RMCUpdatePbyPWithDrift::advanceWalkersVMC(), RMCUpdateAllWithDrift::advanceWalkersVMC(), QMCHamiltonian::evaluateVariableEnergy(), QMCMain::executeCMCSection(), RMCUpdateAllWithDrift::initWalkers(), QMCUpdateBase::initWalkers(), RMCUpdatePbyPWithDrift::initWalkersForPbyP(), QMCUpdateBase::initWalkersForPbyP(), WaveFunctionTester::printEloc(), WaveFunctionTester::runCloneTest(), WaveFunctionTester::runDerivCloneTest(), WaveFunctionTester::runDerivNLPPTest(), WaveFunctionTester::runDerivTest(), WaveFunctionTester::runGradSourceTest(), WaveFunctionTester::runRatioTest(), WaveFunctionTester::runRatioTest2(), WaveFunctionTester::runZeroVarianceTest(), and qmcplusplus::test_hcpBe_rotation().

{
  ScopedTimer local_timer(ham_timer_);
  LocalEnergy = 0.0;
  for (int i = 0; i < H.size(); ++i)
  {
    ScopedTimer h_timer(my_timers_[i]);
    H[i]->evaluate(P);
    updateComponent(*H[i], *this, P);
#if !defined(REMOVE_TRACEMANAGER)
    H[i]->collectScalarTraces();
#endif
  }
  updateKinetic(*this, P);
  return LocalEnergy;
}

evaluateDeterministic()

QMCHamiltonian::FullPrecRealType evaluateDeterministic

(

ParticleSet &

P

)

evaluate Local Energy deterministically.

Defaults to evaluate(P) for operators without a stochastic component. For the nonlocal PP, the quadrature grid is not rerandomized.

Parameters

P	ParticleSet

Returns

Local energy.

Definition at line 557 of file QMCHamiltonian.cpp.

References QMCHamiltonian::H, QMCHamiltonian::ham_timer_, QMCHamiltonian::LocalEnergy, QMCHamiltonian::my_timers_, QMCHamiltonian::updateComponent(), and QMCHamiltonian::updateKinetic().

Referenced by QMCHamiltonian::evaluateElecGrad(), and qmcplusplus::TEST_CASE().

{
  ScopedTimer local_timer(ham_timer_);
  LocalEnergy = 0.0;
  for (int i = 0; i < H.size(); ++i)
  {
    ScopedTimer h_timer(my_timers_[i]);
    H[i]->evaluateDeterministic(P);
    updateComponent(*H[i], *this, P);
#if !defined(REMOVE_TRACEMANAGER)
    H[i]->collectScalarTraces();
#endif
  }
  updateKinetic(*this, P);
  return LocalEnergy;
}

evaluateElecGrad()

void evaluateElecGrad	(	ParticleSet &	P,
		TrialWaveFunction &	psi,
		ParticleSet::ParticlePos &	EGrad,
		RealType	delta = 1e-5
	)

Evaluate the electron gradient of the local energy.

Parameters

psi	Trial Wave Function
P	electron particle set
EGrad	an Nelec x 3 real array which corresponds to d/d[r_i]_j E_L
A	finite difference step size if applicable. Default is to use finite diff with delta=1e-5.

Returns

EGrad. Function itself returns nothing.

Definition at line 863 of file QMCHamiltonian.cpp.

References QMCHamiltonian::evaluateDeterministic(), TrialWaveFunction::evaluateLog(), ParticleSet::getTotalNum(), OHMMS_DIM, ParticleSet::R, and ParticleSet::update().

Referenced by ACForce::evaluate().

{
  int nelec = P.getTotalNum();
  RealType ep(0.0);
  RealType em(0.0);
  RealType e0(0.0);
  for (int iel = 0; iel < nelec; iel++)
  {
    for (int dim = 0; dim < OHMMS_DIM; dim++)
    {
      RealType r0 = P.R[iel][dim];
      ep          = 0;
      em          = 0;
      //Plus
      RealType rp   = r0 + delta;
      P.R[iel][dim] = rp;
      P.update();
      psi.evaluateLog(P);
      ep = evaluateDeterministic(P);

      //minus
      RealType rm   = r0 - delta;
      P.R[iel][dim] = rm;
      P.update();
      psi.evaluateLog(P);
      em = evaluateDeterministic(P);

      Egrad[iel][dim] = (ep - em) / (2.0 * delta);
      P.R[iel][dim]   = r0;
      P.update();
      psi.evaluateLog(P);
    }
  }
}

evaluateIonDerivs()

QMCHamiltonian::FullPrecRealType evaluateIonDerivs	(	ParticleSet &	P,
		ParticleSet &	ions,
		TrialWaveFunction &	psi,
		ParticleSet::ParticlePos &	hf_terms,
		ParticleSet::ParticlePos &	pulay_terms,
		ParticleSet::ParticlePos &	wf_grad
	)

evaluate local energy and derivatives w.r.t ionic coordinates.

Parameters

P	target particle set (electrons)
ions	source particle set (ions)
psi	Trial wave function
hf_terms	Re [(dH)Psi]/Psi
pulay_terms	Re [(H-E_L)dPsi]/Psi
wf_grad	Re (dPsi/Psi)

Returns

Local Energy.

Definition at line 900 of file QMCHamiltonian.cpp.

References qmcplusplus::convertToReal(), TrialWaveFunction::evalGradSource(), ParticleSet::getTotalNum(), and QMCHamiltonian::H.

Referenced by qmcplusplus::TEST_CASE().

{
  ParticleSet::ParticleGradient wfgradraw_(ions.getTotalNum());
  wfgradraw_           = 0.0;
  RealType localEnergy = 0.0;

  for (int i = 0; i < H.size(); ++i)
    localEnergy += H[i]->evaluateWithIonDerivs(P, ions, psi, hf_term, pulay_terms);

  for (int iat = 0; iat < ions.getTotalNum(); iat++)
  {
    wfgradraw_[iat] = psi.evalGradSource(P, ions, iat);
    convertToReal(wfgradraw_[iat], wf_grad[iat]);
  }
  return localEnergy;
}

evaluateIonDerivsDeterministic()

QMCHamiltonian::FullPrecRealType evaluateIonDerivsDeterministic	(	ParticleSet &	P,
		ParticleSet &	ions,
		TrialWaveFunction &	psi,
		ParticleSet::ParticlePos &	hf_terms,
		ParticleSet::ParticlePos &	pulay_terms,
		ParticleSet::ParticlePos &	wf_grad
	)

evaluate local energy and derivatives w.r.t ionic coordinates, but deterministically.

Parameters

P	target particle set (electrons)
ions	source particle set (ions)
psi	Trial wave function
hf_terms	Re [(dH)Psi]/Psi
pulay_terms	Re [(H-E_L)dPsi]/Psi
wf_grad	Re (dPsi/Psi)

Returns

Local Energy.

Definition at line 922 of file QMCHamiltonian.cpp.

References qmcplusplus::convertToReal(), TrialWaveFunction::evalGradSource(), ParticleSet::getTotalNum(), and QMCHamiltonian::H.

Referenced by ACForce::evaluate(), and qmcplusplus::TEST_CASE().

{
  ParticleSet::ParticleGradient wfgradraw_(ions.getTotalNum());
  wfgradraw_           = 0.0;
  RealType localEnergy = 0.0;

  for (int i = 0; i < H.size(); ++i)
    localEnergy += H[i]->evaluateWithIonDerivsDeterministic(P, ions, psi, hf_term, pulay_terms);

  for (int iat = 0; iat < ions.getTotalNum(); iat++)
  {
    wfgradraw_[iat] = psi.evalGradSource(P, ions, iat);
    convertToReal(wfgradraw_[iat], wf_grad[iat]);
  }
  return localEnergy;
}

evaluateIonDerivsDeterministicFast()

QMCHamiltonian::FullPrecRealType evaluateIonDerivsDeterministicFast	(	ParticleSet &	P,
		ParticleSet &	ions,
		TrialWaveFunction &	psi_in,
		TWFFastDerivWrapper &	psi_wrapper,
		ParticleSet::ParticlePos &	dedr,
		ParticleSet::ParticlePos &	wf_grad
	)

evaluate local energy and derivatives w.r.t ionic coordinates, but deterministically.

Parameters

P	target particle set (electrons)
ions	source particle set (ions)
psi	Trial wave function
hf_terms	Re [(dH)Psi]/Psi
pulay_terms	Re [(H-E_L)dPsi]/Psi
wf_grad	Re (dPsi/Psi)

Returns

Local Energy.

Definition at line 1097 of file QMCHamiltonian.cpp.

References TWFFastDerivWrapper::buildX(), TWFFastDerivWrapper::computeGSDerivative(), qmcplusplus::convertToReal(), QMCHamiltonian::eval_ion_derivs_fast_timer_, TWFFastDerivWrapper::evaluateJastrowGradSource(), ParticleSet::first(), TWFFastDerivWrapper::getGSMatrices(), TWFFastDerivWrapper::getIonGradM(), TWFFastDerivWrapper::getM(), ParticleSet::getTotalNum(), TWFFastDerivWrapper::getTWFGroupIndex(), QMCHamiltonian::H, TWFFastDerivWrapper::invertMatrices(), ParticleSet::last(), TWFFastDerivWrapper::numGroups(), TWFFastDerivWrapper::numOrbitals(), OHMMS_DIM, TWFFastDerivWrapper::trAB(), ParticleSet::update(), and TWFFastDerivWrapper::wipeMatrices().

Referenced by ACForce::evaluate(), and qmcplusplus::TEST_CASE().

{
  ScopedTimer local_timer(eval_ion_derivs_fast_timer_);
  P.update();
  //resize everything;
  const int ngroups = psi_wrapper_in.numGroups();

  std::vector<ValueMatrix> X_;    //Working arrays for derivatives
  std::vector<ValueMatrix> Minv_; //Working array for derivatives.
  std::vector<ValueMatrix> B_;
  std::vector<ValueMatrix> B_gs_;
  std::vector<ValueMatrix> M_;
  std::vector<ValueMatrix> M_gs_;

  std::vector<std::vector<ValueMatrix>> dM_;
  std::vector<std::vector<ValueMatrix>> dM_gs_;
  std::vector<std::vector<ValueMatrix>> dB_;
  std::vector<std::vector<ValueMatrix>> dB_gs_;

  {
    M_.resize(ngroups);
    M_gs_.resize(ngroups);
    X_.resize(ngroups);
    B_.resize(ngroups);
    B_gs_.resize(ngroups);
    Minv_.resize(ngroups);

    for (int gid = 0; gid < ngroups; gid++)
    {
      const int sid    = psi_wrapper_in.getTWFGroupIndex(gid);
      const int norbs  = psi_wrapper_in.numOrbitals(sid);
      const int first  = P.first(gid);
      const int last   = P.last(gid);
      const int nptcls = last - first;

      M_[sid].resize(nptcls, norbs);
      B_[sid].resize(nptcls, norbs);

      M_gs_[sid].resize(nptcls, nptcls);
      Minv_[sid].resize(nptcls, nptcls);
      B_gs_[sid].resize(nptcls, nptcls);
      X_[sid].resize(nptcls, nptcls);
    }

    dM_.resize(OHMMS_DIM);
    dM_gs_.resize(OHMMS_DIM);
    dB_.resize(OHMMS_DIM);
    dB_gs_.resize(OHMMS_DIM);

    for (int idim = 0; idim < OHMMS_DIM; idim++)
    {
      dM_[idim].resize(ngroups);
      dB_[idim].resize(ngroups);
      dM_gs_[idim].resize(ngroups);
      dB_gs_[idim].resize(ngroups);

      for (int gid = 0; gid < ngroups; gid++)
      {
        const int sid    = psi_wrapper_in.getTWFGroupIndex(gid);
        const int norbs  = psi_wrapper_in.numOrbitals(sid);
        const int first  = P.first(gid);
        const int last   = P.last(gid);
        const int nptcls = last - first;

        dM_[idim][sid].resize(nptcls, norbs);
        dB_[idim][sid].resize(nptcls, norbs);
        dM_gs_[idim][sid].resize(nptcls, nptcls);
        dB_gs_[idim][sid].resize(nptcls, nptcls);
      }
    }
    psi_wrapper_in.wipeMatrices(M_);
    psi_wrapper_in.wipeMatrices(M_gs_);
    psi_wrapper_in.wipeMatrices(X_);
    psi_wrapper_in.wipeMatrices(B_);
    psi_wrapper_in.wipeMatrices(Minv_);
    psi_wrapper_in.wipeMatrices(B_gs_);

    for (int idim = 0; idim < OHMMS_DIM; idim++)
    {
      psi_wrapper_in.wipeMatrices(dM_[idim]);
      psi_wrapper_in.wipeMatrices(dM_gs_[idim]);
      psi_wrapper_in.wipeMatrices(dB_[idim]);
      psi_wrapper_in.wipeMatrices(dB_gs_[idim]);
    }
  }
  ParticleSet::ParticleGradient wfgradraw_(ions.getTotalNum());
  ParticleSet::ParticleGradient pulay_(ions.getTotalNum());
  ParticleSet::ParticleGradient hf_(ions.getTotalNum());
  ParticleSet::ParticleGradient dedr_complex(ions.getTotalNum());
  ParticleSet::ParticlePos pulayterms_(ions.getTotalNum());
  ParticleSet::ParticlePos hfdiag_(ions.getTotalNum());
  wfgradraw_           = 0.0;
  RealType localEnergy = 0.0;

  {
    psi_wrapper_in.getM(P, M_);
  }
  {
    psi_wrapper_in.getGSMatrices(M_, M_gs_);
    psi_wrapper_in.invertMatrices(M_gs_, Minv_);
  }
  //Build B-matrices.  Only for non-diagonal observables right now.
  for (int i = 0; i < H.size(); ++i)
  {
    if (H[i]->dependsOnWaveFunction())
    {
      H[i]->evaluateOneBodyOpMatrix(P, psi_wrapper_in, B_);
    }
    else
    {
      localEnergy += H[i]->evaluateWithIonDerivsDeterministic(P, ions, psi_in, hfdiag_, pulayterms_);
    }
  }

  ValueType nondiag_cont   = 0.0;
  RealType nondiag_cont_re = 0.0;

  psi_wrapper_in.getGSMatrices(B_, B_gs_);
  nondiag_cont = psi_wrapper_in.trAB(Minv_, B_gs_);
  convertToReal(nondiag_cont, nondiag_cont_re);
  localEnergy += nondiag_cont_re;

  {
    psi_wrapper_in.buildX(Minv_, B_gs_, X_);
  }
  //And now we compute the 3N force derivatives.  3 at a time for each atom.
  for (int iat = 0; iat < ions.getTotalNum(); iat++)
  {
    //The total wavefunction derivative has two contributions.  One from determinantal piece,
    //One from the Jastrow.  Jastrow is easy, so we evaluate it here, then add on the
    //determinantal piece at the end of this block.

    wfgradraw_[iat] = psi_wrapper_in.evaluateJastrowGradSource(P, ions, iat);
    for (int idim = 0; idim < OHMMS_DIM; idim++)
    {
      psi_wrapper_in.wipeMatrices(dM_[idim]);
      psi_wrapper_in.wipeMatrices(dM_gs_[idim]);
      psi_wrapper_in.wipeMatrices(dB_[idim]);
      psi_wrapper_in.wipeMatrices(dB_gs_[idim]);
    }

    {
      //ion derivative of slater matrix.
      psi_wrapper_in.getIonGradM(P, ions, iat, dM_);
    }
    for (int i = 0; i < H.size(); ++i)
    {
      if (H[i]->dependsOnWaveFunction())
      {
        H[i]->evaluateOneBodyOpMatrixForceDeriv(P, ions, psi_wrapper_in, iat, dB_);
      }
    }

    for (int idim = 0; idim < OHMMS_DIM; idim++)
    {
      psi_wrapper_in.getGSMatrices(dB_[idim], dB_gs_[idim]);
      psi_wrapper_in.getGSMatrices(dM_[idim], dM_gs_[idim]);

      ValueType fval          = 0.0;
      fval                    = psi_wrapper_in.computeGSDerivative(Minv_, X_, dM_gs_[idim], dB_gs_[idim]);
      dedr_complex[iat][idim] = fval;

      ValueType wfcomp = 0.0;
      wfcomp           = psi_wrapper_in.trAB(Minv_, dM_gs_[idim]);
      wfgradraw_[iat][idim] += wfcomp; //The determinantal piece of the WF grad.
    }
    convertToReal(dedr_complex[iat], dEdR[iat]);
    convertToReal(wfgradraw_[iat], wf_grad[iat]);
  }
  dEdR += hfdiag_;
  return localEnergy;
}

evaluateValueAndDerivatives()

QMCHamiltonian::FullPrecRealType evaluateValueAndDerivatives	(	ParticleSet &	P,
		const opt_variables_type &	optvars,
		Vector< ValueType > &	dlogpsi,
		Vector< ValueType > &	dhpsioverpsi
	)

evaluate energy and derivatives wrt to the variables

Parameters

P	ParticleSet
optvars	current optimiable variables
dlogpsi
dhpsioverpsi
compute_deriv	if true, compute dhpsioverpsi of the non-local potential component

Definition at line 649 of file QMCHamiltonian.cpp.

References QMCHamiltonian::eval_vals_derivs_timer_, QMCHamiltonian::H, QMCHamiltonian::KineticEnergy, QMCHamiltonian::LocalEnergy, and QMCHamiltonian::my_timers_.

Referenced by WaveFunctionTester::runDerivNLPPTest(), and qmcplusplus::test_hcpBe_rotation().

{
  // The first componennt must be BareKineticEnergy for both handling KineticEnergy and dlogpsi computation
  // by calling TWF::evaluateDerivatives inside BareKineticEnergy::evaluateValueAndDerivatives
  assert(dynamic_cast<BareKineticEnergy*>(H[0].get()) &&
         "BUG: The first componennt in Hamiltonian must be BareKineticEnergy.");
  ScopedTimer local_timer(eval_vals_derivs_timer_);

  {
    ScopedTimer h_timer(my_timers_[0]);
    LocalEnergy = KineticEnergy = H[0]->evaluateValueAndDerivatives(P, optvars, dlogpsi, dhpsioverpsi);
  }

  for (int i = 1; i < H.size(); ++i)
  {
    ScopedTimer h_timer(my_timers_[i]);
    LocalEnergy += H[i]->evaluateValueAndDerivatives(P, optvars, dlogpsi, dhpsioverpsi);
  }
  return LocalEnergy;
}

evaluateVariableEnergy()

QMCHamiltonian::FullPrecRealType evaluateVariableEnergy	(	ParticleSet &	P,
		bool	free_nlpp
	)

evaluate energy

Parameters

P	quantum particleset
free_nlpp	if true, non-local PP is a variable

Returns

KE + NonLocal potential

Definition at line 710 of file QMCHamiltonian.cpp.

References QMCHamiltonian::evaluate(), and QMCHamiltonian::H.

Referenced by WaveFunctionTester::runDerivNLPPTest().

{
  RealType nlpp = 0.0;
  RealType ke   = H[0]->evaluate(P);
  if (free_nlpp)
    for (int i = 1; i < H.size(); ++i)
    {
      if (H[i]->isNonLocal())
        nlpp += H[i]->evaluate(P);
    }
  return ke + nlpp;
}

evaluateWithToperator()

QMCHamiltonian::FullPrecRealType evaluateWithToperator

(

ParticleSet &

P

)

evaluate Local energy with Toperators updated.

Parameters

P	ParticleSEt

Returns

Local energy

Definition at line 796 of file QMCHamiltonian.cpp.

References QMCHamiltonian::H, QMCHamiltonian::ham_timer_, QMCHamiltonian::LocalEnergy, QMCHamiltonian::my_timers_, QMCHamiltonian::updateComponent(), and QMCHamiltonian::updateKinetic().

Referenced by DMCUpdateAllWithRejection::advanceWalker(), SODMCUpdatePbyPWithRejectionFast::advanceWalker(), DMCUpdatePbyPWithRejectionFast::advanceWalker(), and DMCUpdatePbyPL2::advanceWalker().

{
  ScopedTimer local_timer(ham_timer_);
  LocalEnergy = 0.0;
  for (int i = 0; i < H.size(); ++i)
  {
    ScopedTimer h_timer(my_timers_[i]);
    H[i]->evaluateWithToperator(P);
    updateComponent(*H[i], *this, P);
#if !defined(REMOVE_TRACEMANAGER)
    H[i]->collectScalarTraces();
#endif
  }
  updateKinetic(*this, P);
  return LocalEnergy;
}

extract_HC_list()

RefVectorWithLeader< OperatorBase > extract_HC_list ( const RefVectorWithLeader< QMCHamiltonian > &  ham_list, int  id  )

staticprivate

Definition at line 1087 of file QMCHamiltonian.cpp.

References RefVectorWithLeader< T >::getLeader(), and QMCHamiltonian::H.

Referenced by QMCHamiltonian::acquireResource(), QMCHamiltonian::mw_evaluate(), QMCHamiltonian::mw_evaluateValueAndDerivatives(), QMCHamiltonian::mw_evaluateWithToperator(), and QMCHamiltonian::releaseResource().

{
  RefVectorWithLeader<OperatorBase> HC_list(*ham_list.getLeader().H[id]);
  HC_list.reserve(ham_list.size());
  for (QMCHamiltonian& H : ham_list)
    HC_list.push_back(*(H.H[id]));
  return HC_list;
}

finalize_traces()

void finalize_traces

(

)

finalize trace data

Definition at line 510 of file QMCHamiltonian.cpp.

References QMCHamiltonian::age_sample, QMCHamiltonian::auxH, QMCHamiltonian::gen_sample, QMCHamiltonian::H, QMCHamiltonian::id_sample, QMCHamiltonian::mult_sample, QMCHamiltonian::pid_sample, QMCHamiltonian::position_sample, QMCHamiltonian::request, TraceRequest::reset(), QMCHamiltonian::step_sample, TraceRequest::streaming(), TraceRequest::streaming_default_scalars, QMCHamiltonian::streaming_position, and QMCHamiltonian::weight_sample.

Referenced by QMCUpdateBase::stopRun2().

{
  if (request.streaming_default_scalars)
  {
    delete id_sample;
    delete pid_sample;
    delete step_sample;
    delete gen_sample;
    delete age_sample;
    delete mult_sample;
    delete weight_sample;
  }
  if (streaming_position)
    delete position_sample;
  if (request.streaming())
  {
    for (int i = 0; i < H.size(); ++i)
      H[i]->deleteTraceQuantities();
    for (int i = 0; i < auxH.size(); ++i)
      auxH[i]->deleteTraceQuantities();
  }
  streaming_position = false;
  request.reset();
}

get()

bool get

(

std::ostream &

os

)

const

Definition at line 83 of file QMCHamiltonian.cpp.

References QMCHamiltonian::H.

{
  for (int i = 0; i < H.size(); i++)
  {
    os << "  " << std::setw(16) << std::left << H[i]->getName();
    H[i]->get(os);
    os << "\n";
  }
  return true;
}

getEnsembleAverage()

QMCHamiltonian::FullPrecRealType getEnsembleAverage

(

)

return an average value of the LocalEnergy

Introduced to get a collective value

Definition at line 944 of file QMCHamiltonian.cpp.

References QMCHamiltonian::H.

{
  FullPrecRealType sum = 0.0;
  for (int i = 0; i < H.size(); i++)
    sum += H[i]->getEnsembleAverage();
  return sum;
}

getHamiltonian() [1/2]

OperatorBase * getHamiltonian

(

const std::string &

aname

)

return OperatorBase with the name aname

return pointer to the QMCHamtiltonian with the name

Parameters

aname

name of a OperatorBase

Returns

0 if aname is not found.

Parameters

aname

the name of Hamiltonian

Returns

the pointer to the named term.

If not found, return 0

Definition at line 958 of file QMCHamiltonian.cpp.

References QMCHamiltonian::auxH, QMCHamiltonian::getName(), and QMCHamiltonian::H.

Referenced by qmcplusplus::TEST_CASE(), and qmcplusplus::test_hcpBe_rotation().

{
  for (int i = 0; i < H.size(); ++i)
    if (H[i]->getName() == aname)
      return H[i].get();
  for (int i = 0; i < auxH.size(); ++i)
    if (auxH[i]->getName() == aname)
      return auxH[i].get();
  return nullptr;
}

getHamiltonian() [2/2]

OperatorBase* getHamiltonian ( int  i )

inline

return i-th OperatorBase

Parameters

i	index of the OperatorBase

Returns

H[i]

Definition at line 101 of file QMCHamiltonian.h.

References QMCHamiltonian::H.

{ return H[i].get(); }

getKineticEnergy()

FullPrecRealType getKineticEnergy ( )

inline

Definition at line 216 of file QMCHamiltonian.h.

References QMCHamiltonian::KineticEnergy.

Referenced by qmcplusplus::test_hcpBe_rotation().

{ return KineticEnergy; }

getLocalEnergy()

FullPrecRealType getLocalEnergy ( )

inline

Definition at line 213 of file QMCHamiltonian.h.

References QMCHamiltonian::LocalEnergy.

Referenced by QMCHamiltonian::mw_evaluate(), QMCHamiltonian::mw_evaluateValueAndDerivatives(), QMCHamiltonian::mw_evaluateWithToperator(), WaveFunctionTester::runDerivCloneTest(), WaveFunctionTester::runDerivNLPPTest(), WaveFunctionTester::runDerivTest(), WaveFunctionTester::runRatioTest(), and qmcplusplus::test_hcpBe_rotation().

{ return LocalEnergy; }

getLocalPotential()

FullPrecRealType getLocalPotential ( )

inline

Definition at line 215 of file QMCHamiltonian.h.

References QMCHamiltonian::KineticEnergy, and QMCHamiltonian::LocalEnergy.

Referenced by WaveFunctionTester::runDerivCloneTest(), and WaveFunctionTester::runDerivTest().

{ return LocalEnergy - KineticEnergy; }

getName()

const std::string& getName ( ) const

inline

Definition at line 405 of file QMCHamiltonian.h.

References QMCHamiltonian::myName.

Referenced by QMCHamiltonian::addOperator(), and QMCHamiltonian::getHamiltonian().

{ return myName; }

getOperatorType()

const std::string & getOperatorType

(

const std::string &

name

)

return type of named H element or fail

Definition at line 174 of file QMCHamiltonian.cpp.

References APP_ABORT, and QMCHamiltonian::operator_types.

Referenced by qmcplusplus::TEST_CASE().

{
  std::map<std::string, std::string>::iterator type = operator_types.find(name);
  if (type == operator_types.end())
    APP_ABORT("QMCHamiltonian::getOperatorType\n  operator type not found for name " + name);
  return type->second;
}

getTWFDependentComponents()

RefVector< OperatorBase > getTWFDependentComponents

(

)

return components, auxH not included, depending on TWF.

Definition at line 969 of file QMCHamiltonian.cpp.

References QMCHamiltonian::H.

Referenced by QMCCostFunctionBatched::correlatedSampling(), CostFunctionCrowdData::CostFunctionCrowdData(), and QMCCostFunctionBatched::getConfigurations().

{
  RefVector<OperatorBase> components;
  for (int i = 0; i < H.size(); i++)
    if (H[i]->dependsOnWaveFunction())
      components.push_back(*H[i]);
  return components;
}

has_L2()

bool has_L2 ( )

inline

determine if L2 potential is present

Definition at line 364 of file QMCHamiltonian.h.

References QMCHamiltonian::l2_ptr.

Referenced by DMCUpdatePbyPL2::advanceWalker().

{ return l2_ptr != nullptr; }

initialize_traces()

void initialize_traces	(	TraceManager &	tm,
		ParticleSet &	P
	)

initialize trace data

Definition at line 310 of file QMCHamiltonian.cpp.

References QMCHamiltonian::age_sample, APP_ABORT, qmcplusplus::app_log(), QMCHamiltonian::auxH, TraceManager::checkout_int(), TraceManager::checkout_real(), TraceRequest::contribute_array(), TraceRequest::contribute_combined(), TraceRequest::contribute_scalar(), TraceRequest::determine_stream_write(), QMCHamiltonian::DIM, QMCHamiltonian::gen_sample, OperatorBase::getName(), QMCHamiltonian::H, QMCHamiltonian::id_sample, TraceRequest::incorporate(), OperatorBase::isClassical(), OperatorBase::isClassicalClassical(), OperatorBase::isQuantum(), OperatorBase::isQuantumClassical(), OperatorBase::isQuantumQuantum(), TraceManager::make_combined_trace(), QMCHamiltonian::mult_sample, omp_get_thread_num(), QMCHamiltonian::pid_sample, QMCHamiltonian::position_sample, TraceRequest::relay_stream_info(), QMCHamiltonian::request, TraceManager::request, TraceManager::screen_writes(), QMCHamiltonian::step_sample, TraceRequest::streaming(), TraceRequest::streaming_array(), TraceRequest::streaming_default_scalars, QMCHamiltonian::streaming_position, TraceManager::streaming_traces, TraceManager::update_status(), TraceManager::user_report(), TraceManager::verbose, and QMCHamiltonian::weight_sample.

Referenced by QMCUpdateBase::startRun().

{
  static bool first_init = true;
  bool trace_log         = first_init && tm.verbose && omp_get_thread_num() == 0;
  if (trace_log)
    app_log() << "\n  Hamiltonian is initializing traces" << std::endl;

  //fill std::string vectors for combined trace quantities
  std::vector<std::string> Eloc;
  std::vector<std::string> Vloc;
  std::vector<std::string> Vq, Vc, Vqq, Vqc, Vcc;
  for (int i = 0; i < H.size(); ++i)
    Eloc.push_back(H[i]->getName());
  for (int i = 1; i < H.size(); ++i)
    Vloc.push_back(H[i]->getName());

  // These contributions are based on the potential energy components.
  // Loop starts at one to skip the kinetic energy component.
  for (int i = 1; i < H.size(); ++i)
  {
    OperatorBase& h = *H[i];
    if (h.isQuantum())
      Vq.push_back(h.getName());
    else if (h.isClassical())
      Vc.push_back(h.getName());
    else if (h.isQuantumQuantum())
      Vqq.push_back(h.getName());
    else if (h.isQuantumClassical())
      Vqc.push_back(h.getName());
    else if (h.isClassicalClassical())
      Vcc.push_back(h.getName());
    else if (omp_get_thread_num() == 0)
      app_log() << "  warning: potential named " << h.getName()
                << " has not been classified according to its quantum domain (q,c,qq,qc,cc)\n    estimators depending "
                   "on this classification may not function properly"
                << std::endl;
  }


  //make trace quantities available
  request.contribute_scalar("id", true);           //default trace quantity
  request.contribute_scalar("parent_id", true);    //default trace quantity
  request.contribute_scalar("step", true);         //default trace quantity
  request.contribute_scalar("generation", true);   //default trace quantity
  request.contribute_scalar("age", true);          //default trace quantity
  request.contribute_scalar("multiplicity", true); //default trace quantity
  request.contribute_scalar("weight", true);       //default trace quantity
  request.contribute_array("position");
  for (int i = 0; i < H.size(); ++i)
    H[i]->contributeTraceQuantities();
  for (int i = 0; i < auxH.size(); ++i)
    auxH[i]->contributeTraceQuantities();


  //note availability of combined quantities
  request.contribute_combined("LocalEnergy", Eloc, true);
  request.contribute_combined("LocalPotential", Vloc, true, true);
  if (Vq.size() > 0)
    request.contribute_combined("Vq", Vq, true, true);
  if (Vc.size() > 0)
    request.contribute_combined("Vc", Vc, true, true);
  if (Vqq.size() > 0)
    request.contribute_combined("Vqq", Vqq, true, true);
  if (Vqc.size() > 0)
    request.contribute_combined("Vqc", Vqc, true, true);
  if (Vcc.size() > 0)
    request.contribute_combined("Vcc", Vcc, true, true);


  //collect trace requests
  std::vector<TraceRequest*> requests;
  //  Hamiltonian request (id, step, weight, positions)
  requests.push_back(&request);
  //  requests from Hamiltonian components
  for (int i = 0; i < H.size(); ++i)
    requests.push_back(&H[i]->getRequest());
  //  requests from other observables
  for (int i = 0; i < auxH.size(); ++i)
    requests.push_back(&auxH[i]->getRequest());

  //collect trace quantity availability/requests from contributors/requestors
  for (int i = 0; i < requests.size(); ++i)
    tm.request.incorporate(*requests[i]);

  //balance requests with availability, mark quantities as streaming/writing
  tm.request.determine_stream_write();

  //relay updated streaming information to all contributors/requestors
  for (int i = 0; i < requests.size(); ++i)
    tm.request.relay_stream_info(*requests[i]);

  //set streaming/writing traces in general
  tm.update_status();

  // setup traces, if any quantities should be streaming

  // tracing
  bool tracing = request.streaming();
  if (tracing != tm.streaming_traces)
    APP_ABORT("QMCHamiltonian::initialize_traces  trace request failed to initialize properly");
  if (!tracing)
  {
    // Empty. Do not log if nothing will be done

    if (trace_log)
      app_log() << "    no traces streaming" << std::endl;
  }
  else
  {
    if (trace_log)
      app_log() << "    traces streaming" << std::endl;
    //checkout trace quantities
    //(requested sources checkout arrays to place samples in for streaming)
    //  checkout walker trace quantities
    streaming_position = request.streaming_array("position");
    if (request.streaming_default_scalars)
    {
      id_sample     = tm.checkout_int<1>("id");
      pid_sample    = tm.checkout_int<1>("parent_id");
      step_sample   = tm.checkout_int<1>("step");
      gen_sample    = tm.checkout_int<1>("generation");
      age_sample    = tm.checkout_int<1>("age");
      mult_sample   = tm.checkout_int<1>("multiplicity");
      weight_sample = tm.checkout_real<1>("weight");
    }
    if (streaming_position)
      position_sample = tm.checkout_real<2>("position", P, DIM);
    //  checkout observable trace quantities
    for (int i = 0; i < H.size(); ++i)
    {
      if (trace_log)
        app_log() << "    OperatorBase::checkoutTraceQuantities  " << H[i]->getName() << std::endl;
      H[i]->checkoutTraceQuantities(tm);
    }
    for (int i = 0; i < auxH.size(); ++i)
    {
      if (trace_log)
        app_log() << "    OperatorBase::checkoutTraceQuantities  " << auxH[i]->getName() << std::endl;
      auxH[i]->checkoutTraceQuantities(tm);
    }
    //setup combined traces that depend on H information
    //  LocalEnergy, LocalPotential, Vq, Vc, Vqq, Vqc, Vcc
    if (Vloc.size() > 0 && request.streaming("LocalPotential"))
      tm.make_combined_trace("LocalPotential", Vloc);
    if (Eloc.size() > 0 && request.streaming("LocalEnergy"))
      tm.make_combined_trace("LocalEnergy", Eloc);
    if (Vq.size() > 0 && request.streaming("Vq"))
      tm.make_combined_trace("Vq", Eloc);
    if (Vc.size() > 0 && request.streaming("Vc"))
      tm.make_combined_trace("Vc", Eloc);
    if (Vqq.size() > 0 && request.streaming("Vqq"))
      tm.make_combined_trace("Vqq", Eloc);
    if (Vqc.size() > 0 && request.streaming("Vqc"))
      tm.make_combined_trace("Vqc", Eloc);
    if (Vcc.size() > 0 && request.streaming("Vcc"))
      tm.make_combined_trace("Vcc", Eloc);

    //all trace samples have been created ( streaming instances)
    //  mark the ones that will be writing also
    tm.screen_writes();

    //observables that depend on traces check them out
    if (trace_log)
      app_log() << "\n  Hamiltonian is fulfilling trace requests from observables" << std::endl;
    for (int i = 0; i < auxH.size(); ++i)
    {
      if (trace_log)
        app_log() << "    OperatorBase::getRequiredTraces  " << auxH[i]->getName() << std::endl;
      auxH[i]->getRequiredTraces(tm);
    }
    //report

    //write traces status to the log
    if (trace_log)
      tm.user_report();

    first_init = false;
  }
}

makeClone()

std::unique_ptr< QMCHamiltonian > makeClone	(	ParticleSet &	qp,
		TrialWaveFunction &	psi
	)		const

return a clone

Definition at line 1066 of file QMCHamiltonian.cpp.

References QMCHamiltonian::auxH, PooledData< T >::clear(), ParticleSet::Collectables, QMCHamiltonian::H, QMCHamiltonian::myIndex, QMCHamiltonian::myName, QMCHamiltonian::numCollectables, and PooledData< T >::resize().

Referenced by CostFunctionCrowdData::CostFunctionCrowdData(), MCPopulation::createWalkers(), Crowd::Crowd(), CloneManager::makeClones(), WaveFunctionTester::runCloneTest(), WaveFunctionTester::runDerivCloneTest(), and MCPopulation::spawnWalker().

{
  auto myclone = std::make_unique<QMCHamiltonian>(myName);
  for (int i = 0; i < H.size(); ++i)
    H[i]->add2Hamiltonian(qp, psi, *myclone);
  for (int i = 0; i < auxH.size(); ++i)
    auxH[i]->add2Hamiltonian(qp, psi, *myclone);
  //sync indices
  myclone->resetObservables(myIndex, numCollectables);
  //Hamiltonian needs to make sure qp.Collectables are the same as defined by the original Hamiltonian
  if (numCollectables)
  {
    qp.Collectables.clear();
    qp.Collectables.resize(numCollectables);
  }
  //Assume tau is correct for the Kinetic energy operator and assign to the rest of the clones
  //Return_t tau = H[0]->Tau;
  //myclone->setTau(tau);
  return myclone;
}

makeNonLocalMoves()

int makeNonLocalMoves

(

ParticleSet &

P

)

make non local moves

Parameters

P	particle set

Returns

the number of accepted moves

Definition at line 1011 of file QMCHamiltonian.cpp.

References NonLocalECPotential::makeNonLocalMovesPbyP(), and QMCHamiltonian::nlpp_ptr.

Referenced by DMCUpdateAllWithRejection::advanceWalker(), SODMCUpdatePbyPWithRejectionFast::advanceWalker(), DMCUpdatePbyPWithRejectionFast::advanceWalker(), and DMCUpdatePbyPL2::advanceWalker().

{
  if (nlpp_ptr == nullptr)
    return 0;
  else
    return nlpp_ptr->makeNonLocalMovesPbyP(P);
}

mw_evaluate()

std::vector< QMCHamiltonian::FullPrecRealType > mw_evaluate ( const RefVectorWithLeader< QMCHamiltonian > &  ham_list, const RefVectorWithLeader< TrialWaveFunction > &  wf_list, const RefVectorWithLeader< ParticleSet > &  p_list  )

static

batched version of evaluate for LocalEnergy

Encapsulation is ignored for ham_list hamiltonians method uses its status as QMCHamiltonian to break encapsulation. ParticleSet is also updated. Bugs could easily be created by accessing this scope. This should be set to static and fixed.

Definition at line 596 of file QMCHamiltonian.cpp.

References QMCHamiltonian::extract_HC_list(), RefVectorWithLeader< T >::getLeader(), QMCHamiltonian::getLocalEnergy(), qmcplusplus::ham, QMCHamiltonian::LocalEnergy, QMCHamiltonian::updateComponent(), and QMCHamiltonian::updateKinetic().

Referenced by QMCCostFunctionBatched::checkConfigurations(), QMCCostFunctionBatched::correlatedSampling(), Hdispatcher::flex_evaluate(), and qmcplusplus::TEST_CASE().

{
  auto& ham_leader = ham_list.getLeader();
  ScopedTimer local_timer(ham_leader.ham_timer_);
  for (QMCHamiltonian& ham : ham_list)
    ham.LocalEnergy = 0.0;

  const int num_ham_operators = ham_leader.H.size();

  // It is an invariant of the class that H[0] be the kinetic energy operator.
  // This is enforced by HamiltonianFactory's constuctor and not QMCHamiltonians
  int kinetic_index = 0;
  {
    ScopedTimer h_timer(ham_leader.my_timers_[kinetic_index]);
    const auto HC_list(extract_HC_list(ham_list, kinetic_index));
    if (ham_leader.mw_res_handle_.getResource().kinetic_listeners_.size() > 0)
      ham_leader.H[kinetic_index]
          ->mw_evaluatePerParticle(HC_list, wf_list, p_list, ham_leader.mw_res_handle_.getResource().kinetic_listeners_,
                                   ham_leader.mw_res_handle_.getResource().ion_kinetic_listeners_);
    else
      ham_leader.H[kinetic_index]->mw_evaluate(HC_list, wf_list, p_list);
    for (int iw = 0; iw < ham_list.size(); iw++)
      updateComponent(HC_list[iw], ham_list[iw], p_list[iw]);
  }

  for (int i_ham_op = 1; i_ham_op < num_ham_operators; ++i_ham_op)
  {
    ScopedTimer h_timer(ham_leader.my_timers_[i_ham_op]);
    const auto HC_list(extract_HC_list(ham_list, i_ham_op));

    if (ham_leader.mw_res_handle_.getResource().potential_listeners_.size() > 0)
      ham_leader.H[i_ham_op]->mw_evaluatePerParticle(HC_list, wf_list, p_list,
                                                     ham_leader.mw_res_handle_.getResource().potential_listeners_,
                                                     ham_leader.mw_res_handle_.getResource().ion_potential_listeners_);
    else
      ham_leader.H[i_ham_op]->mw_evaluate(HC_list, wf_list, p_list);
    for (int iw = 0; iw < ham_list.size(); iw++)
      updateComponent(HC_list[iw], ham_list[iw], p_list[iw]);
  }

  for (int iw = 0; iw < ham_list.size(); iw++)
    updateKinetic(ham_list[iw], p_list[iw]);

  std::vector<FullPrecRealType> local_energies(ham_list.size(), 0.0);
  for (int iw = 0; iw < ham_list.size(); ++iw)
    local_energies[iw] = ham_list[iw].getLocalEnergy();

  return local_energies;
}

mw_evaluateValueAndDerivatives()

std::vector< QMCHamiltonian::FullPrecRealType > mw_evaluateValueAndDerivatives ( const RefVectorWithLeader< QMCHamiltonian > &  ham_list, const RefVectorWithLeader< TrialWaveFunction > &  wf_list, const RefVectorWithLeader< ParticleSet > &  p_list, const opt_variables_type &  optvars, RecordArray< ValueType > &  dlogpsi, RecordArray< ValueType > &  dhpsioverpsi  )

static

Definition at line 673 of file QMCHamiltonian.cpp.

References QMCHamiltonian::extract_HC_list(), RefVectorWithLeader< T >::getLeader(), QMCHamiltonian::getLocalEnergy(), QMCHamiltonian::LocalEnergy, QMCHamiltonian::updateComponent(), and QMCHamiltonian::updateKinetic().

Referenced by QMCCostFunctionBatched::checkConfigurations(), QMCCostFunctionBatched::correlatedSampling(), and qmcplusplus::test_hcpBe_rotation().

{
  std::vector<FullPrecRealType> local_energies(ham_list.size(), 0.0);
  for (int iw = 0; iw < ham_list.size(); iw++)
    ham_list[iw].LocalEnergy = 0.0;

  if (ham_list.size() > 0)
  {
    auto& ham_leader            = ham_list.getLeader();
    const int num_ham_operators = ham_leader.H.size();
    for (int i_ham_op = 0; i_ham_op < num_ham_operators; ++i_ham_op)
    {
      ScopedTimer local_timer(ham_leader.my_timers_[i_ham_op]);
      const auto HC_list(extract_HC_list(ham_list, i_ham_op));

      ham_leader.H[i_ham_op]->mw_evaluateWithParameterDerivatives(HC_list, p_list, optvars, dlogpsi, dhpsioverpsi);

      for (int iw = 0; iw < ham_list.size(); iw++)
        updateComponent(HC_list[iw], ham_list[iw], p_list[iw]);
    }

    for (int iw = 0; iw < ham_list.size(); iw++)
      updateKinetic(ham_list[iw], p_list[iw]);

    for (int iw = 0; iw < ham_list.size(); ++iw)
      local_energies[iw] = ham_list[iw].getLocalEnergy();
  }

  return local_energies;
}

mw_evaluateWithToperator()

std::vector< QMCHamiltonian::FullPrecRealType > mw_evaluateWithToperator ( const RefVectorWithLeader< QMCHamiltonian > &  ham_list, const RefVectorWithLeader< TrialWaveFunction > &  wf_list, const RefVectorWithLeader< ParticleSet > &  p_list  )

static

batched version of evaluate Local energy with Toperators updated.

Definition at line 813 of file QMCHamiltonian.cpp.

References QMCHamiltonian::extract_HC_list(), QMCHamiltonian::getLocalEnergy(), qmcplusplus::ham, QMCHamiltonian::LocalEnergy, QMCHamiltonian::updateComponent(), and QMCHamiltonian::updateKinetic().

Referenced by Hdispatcher::flex_evaluateWithToperator().

{
  for (QMCHamiltonian& ham : ham_list)
    ham.LocalEnergy = 0.0;

  auto& ham_leader            = ham_list.getLeader();
  const int num_ham_operators = ham_leader.H.size();

  const int kinetic_index = 0;
  {
    ScopedTimer h_timer(ham_leader.my_timers_[kinetic_index]);
    const auto HC_list(extract_HC_list(ham_list, kinetic_index));
    if (ham_leader.mw_res_handle_.getResource().kinetic_listeners_.size() > 0)
      ham_leader.H[kinetic_index]
          ->mw_evaluatePerParticleWithToperator(HC_list, wf_list, p_list,
                                                ham_leader.mw_res_handle_.getResource().kinetic_listeners_,
                                                ham_leader.mw_res_handle_.getResource().ion_kinetic_listeners_);
    else
      ham_leader.H[kinetic_index]->mw_evaluateWithToperator(HC_list, wf_list, p_list);
    for (int iw = 0; iw < ham_list.size(); iw++)
      updateComponent(HC_list[iw], ham_list[iw], p_list[iw]);
  }

  for (int i_ham_op = 1; i_ham_op < num_ham_operators; ++i_ham_op)
  {
    ScopedTimer local_timer(ham_leader.my_timers_[i_ham_op]);
    const auto HC_list(extract_HC_list(ham_list, i_ham_op));
    if (ham_leader.mw_res_handle_.getResource().potential_listeners_.size() > 0)
      ham_leader.H[i_ham_op]
          ->mw_evaluatePerParticleWithToperator(HC_list, wf_list, p_list,
                                                ham_leader.mw_res_handle_.getResource().potential_listeners_,
                                                ham_leader.mw_res_handle_.getResource().ion_potential_listeners_);
    else
      ham_leader.H[i_ham_op]->mw_evaluateWithToperator(HC_list, wf_list, p_list);
    for (int iw = 0; iw < ham_list.size(); ++iw)
      updateComponent(HC_list[iw], ham_list[iw], p_list[iw]);
  }

  for (int iw = 0; iw < ham_list.size(); iw++)
    updateKinetic(ham_list[iw], p_list[iw]);

  std::vector<FullPrecRealType> local_energies(ham_list.size());
  for (int iw = 0; iw < ham_list.size(); ++iw)
    local_energies[iw] = ham_list[iw].getLocalEnergy();

  return local_energies;
}

mw_makeNonLocalMoves()

std::vector< int > mw_makeNonLocalMoves ( const RefVectorWithLeader< QMCHamiltonian > &  ham_list, const RefVectorWithLeader< TrialWaveFunction > &  wf_list, const RefVectorWithLeader< ParticleSet > &  p_list  )

static

Definition at line 1020 of file QMCHamiltonian.cpp.

References RefVectorWithLeader< T >::getLeader(), NonLocalECPotential::makeNonLocalMovesPbyP(), and QMCHamiltonian::nlpp_ptr.

Referenced by Hdispatcher::flex_makeNonLocalMoves().

{
  auto& ham_leader = ham_list.getLeader();

  std::vector<int> num_accepts(ham_list.size(), 0);
  if (ham_list.getLeader().nlpp_ptr)
  {
    for (int iw = 0; iw < ham_list.size(); ++iw)
      num_accepts[iw] = ham_list[iw].nlpp_ptr->makeNonLocalMovesPbyP(p_list[iw]);
  }
  return num_accepts;
}

rejectedMove()

void rejectedMove	(	ParticleSet &	P,
		Walker_t &	ThisWalker
	)

Looks like a hack see DMCBatched.cpp and DMC.cpp weight is used like temporary flag from DMC.

Definition at line 780 of file QMCHamiltonian.cpp.

References QMCHamiltonian::auxH, QMCHamiltonian::collect_walker_traces(), and ParticleSet::current_step.

Referenced by SODMCUpdatePbyPWithRejectionFast::advanceWalker(), DMCUpdatePbyPWithRejectionFast::advanceWalker(), DMCUpdatePbyPL2::advanceWalker(), DMCUpdateAllWithKill::advanceWalker(), RMCUpdatePbyPWithDrift::advanceWalkersRMC(), RMCUpdateAllWithDrift::advanceWalkersRMC(), RMCUpdatePbyPWithDrift::advanceWalkersVMC(), and RMCUpdateAllWithDrift::advanceWalkersVMC().

{
  // weight should be 0 from DMC
  //   since other traced properties will be invalid
  //   (they will be from the walker moved before this one)
#if !defined(REMOVE_TRACEMANAGER)
  collect_walker_traces(ThisWalker, P.current_step);
#endif
  //   ThisWalker.rejectedMove();
  for (int i = 0; i < auxH.size(); ++i)
  {
    auxH[i]->setHistories(ThisWalker);
    RealType sink = auxH[i]->rejectedMove(P);
  }
}

releaseResource()

void releaseResource ( ResourceCollection &  collection, const RefVectorWithLeader< QMCHamiltonian > &  ham_list  )

static

release external resource Note: use RAII ResourceCollectionLock whenever possible

Definition at line 1054 of file QMCHamiltonian.cpp.

References QMCHamiltonian::extract_HC_list(), RefVectorWithLeader< T >::getLeader(), and ResourceCollection::takebackResource().

{
  auto& ham_leader = ham_list.getLeader();
  collection.takebackResource(ham_leader.mw_res_handle_);
  for (int i_ham_op = 0; i_ham_op < ham_leader.H.size(); ++i_ham_op)
  {
    const auto HC_list(extract_HC_list(ham_list, i_ham_op));
    ham_leader.H[i_ham_op]->releaseResource(collection, HC_list);
  }
}

reportToListeners()

void reportToListeners ( )

private

resetObservables()

void resetObservables ( int  start, int  ncollects  )

private

reset Observables and counters

Parameters

start	starting index within PropertyList
ncollects	number of collectables

Definition at line 245 of file QMCHamiltonian.cpp.

References QMCHamiltonian::addObservables(), APP_ABORT, QMCHamiltonian::auxH, QMCHamiltonian::H, QMCHamiltonian::myIndex, QMCHamiltonian::numCollectables, QMCHamiltonian::Observables, PooledData< T >::rewind(), and PooledData< T >::size().

{
  Observables.clear();
  BufferType collectables;
  collectables.rewind();
  for (int i = 0; i < H.size(); ++i)
    H[i]->addObservables(Observables, collectables);
  for (int i = 0; i < auxH.size(); ++i)
    auxH[i]->addObservables(Observables, collectables);
  if (collectables.size() != ncollects)
  {
    APP_ABORT("  QMCHamiltonian::resetObservables numCollectables != ncollects");
  }
  myIndex         = start;
  numCollectables = ncollects;
}

resetTargetParticleSet()

void resetTargetParticleSet

(

ParticleSet &

P

)

Definition at line 978 of file QMCHamiltonian.cpp.

References QMCHamiltonian::auxH, and QMCHamiltonian::H.

{
  for (int i = 0; i < H.size(); i++)
    H[i]->resetTargetParticleSet(P);
  for (int i = 0; i < auxH.size(); i++)
    auxH[i]->resetTargetParticleSet(P);
}

setNonLocalMoves() [1/2]

void setNonLocalMoves

(

xmlNodePtr

cur

)

set non local moves options

Parameters

cur	the xml input

Definition at line 996 of file QMCHamiltonian.cpp.

References QMCHamiltonian::nlpp_ptr, and NonLocalECPotential::setNonLocalMoves().

Referenced by QMCUpdateBase::put(), and DMCBatched::setNonLocalMoveHandler().

{
  if (nlpp_ptr != nullptr)
    nlpp_ptr->setNonLocalMoves(cur);
}

setNonLocalMoves() [2/2]

void setNonLocalMoves	(	const std::string &	non_local_move_option,
		const double	tau,
		const double	alpha,
		const double	gamma
	)

Definition at line 1002 of file QMCHamiltonian.cpp.

References QMCHamiltonian::nlpp_ptr, and NonLocalECPotential::setNonLocalMoves().

{
  if (nlpp_ptr != nullptr)
    nlpp_ptr->setNonLocalMoves(non_local_move_option, tau, alpha, gamma);
}

setPrimary()

void setPrimary ( bool  primary )

inline

set PRIMARY bit of all the components

Definition at line 224 of file QMCHamiltonian.h.

References QMCHamiltonian::H, and OperatorBase::PRIMARY.

Referenced by QMCDriverFactory::createQMCDriver(), WaveFunctionTester::runDerivNLPPTest(), and WaveFunctionTester::runDerivTest().

  {
    for (int i = 0; i < H.size(); i++)
      H[i]->getUpdateMode().set(OperatorBase::PRIMARY, primary);
  }

setProperty()

void setProperty ( IT  first )

inline

Definition at line 203 of file QMCHamiltonian.h.

References copy(), QMCHamiltonian::myIndex, and QMCHamiltonian::Observables.

  {
    //       LocalEnergy=first[WP::LOCALENERGY];
    //       KineticEnergy=LocalEnergy-first[LOCALPOTENTIAL];
    copy(first + myIndex, first + myIndex + Observables.size(), Observables.begin());
  }

setRandomGenerator()

void setRandomGenerator

(

RandomBase< FullPrecRealType > *

rng

)

Definition at line 986 of file QMCHamiltonian.cpp.

References QMCHamiltonian::auxH, QMCHamiltonian::H, QMCHamiltonian::nlpp_ptr, and NonLocalECPotential::setRandomGenerator().

Referenced by QMCCostFunctionBatched::checkConfigurations(), QMCCostFunctionBatched::correlatedSampling(), WaveFunctionTester::run(), WaveFunctionTester::runDerivCloneTest(), Crowd::setRNGForHamiltonian(), qmcplusplus::TEST_CASE(), and qmcplusplus::test_hcpBe_rotation().

{
  for (int i = 0; i < H.size(); i++)
    H[i]->setRandomGenerator(rng);
  for (int i = 0; i < auxH.size(); i++)
    auxH[i]->setRandomGenerator(rng);
  if (nlpp_ptr)
    nlpp_ptr->setRandomGenerator(rng);
}

size()

int size ( void  ) const

inline

return the number of Hamiltonians

Definition at line 86 of file QMCHamiltonian.h.

References QMCHamiltonian::H.

Referenced by qmcplusplus::TEST_CASE(), and QMCMain::validateXML().

{ return H.size(); }

total_size()

int total_size ( ) const

inline

return the total number of Hamiltonians (physical + aux)

Definition at line 89 of file QMCHamiltonian.h.

References QMCHamiltonian::auxH, and QMCHamiltonian::H.

Referenced by qmcplusplus::TEST_CASE().

{ return H.size() + auxH.size(); }

updateComponent()

void updateComponent ( OperatorBase &  op, QMCHamiltonian &  ham, ParticleSet &  pset  )

static

accumulate local energy and update Observables and PropertyList

Definition at line 573 of file QMCHamiltonian.cpp.

References OperatorBase::getName(), OperatorBase::getValue(), qmcplusplus::ham, qmcplusplus::isnan(), QMCHamiltonian::LocalEnergy, QMCHamiltonian::myIndex, QMCHamiltonian::Observables, qmcplusplus::pset, OperatorBase::setObservables(), and OperatorBase::setParticlePropertyList().

Referenced by QMCHamiltonian::evaluate(), QMCHamiltonian::evaluateDeterministic(), QMCHamiltonian::evaluateWithToperator(), QMCHamiltonian::mw_evaluate(), QMCHamiltonian::mw_evaluateValueAndDerivatives(), and QMCHamiltonian::mw_evaluateWithToperator().

{
  // It's much better to be able to see where this is coming from.  It is caught just fine.
  if (qmcplusplus::isnan(op.getValue()))
  {
    std::ostringstream msg;
    msg << "QMCHamiltonian::updateComponent component " << op.getName() << " returns NaN." << std::endl;
    pset.print(msg);
    throw std::runtime_error(msg.str());
  }
  // The following is a ridiculous breach of encapsulation.
  ham.LocalEnergy += op.getValue();
  op.setObservables(ham.Observables);
  op.setParticlePropertyList(pset.PropertyList, ham.myIndex);
}

updateKinetic()

void updateKinetic ( QMCHamiltonian &  ham, ParticleSet &  pset  )

static

extract kinetic and potential energies.

Definition at line 589 of file QMCHamiltonian.cpp.

References QMCHamiltonian::H, qmcplusplus::ham, QMCHamiltonian::KineticEnergy, QMCHamiltonian::LocalEnergy, and qmcplusplus::pset.

Referenced by QMCHamiltonian::evaluate(), QMCHamiltonian::evaluateDeterministic(), QMCHamiltonian::evaluateWithToperator(), QMCHamiltonian::mw_evaluate(), QMCHamiltonian::mw_evaluateValueAndDerivatives(), and QMCHamiltonian::mw_evaluateWithToperator().

{
  ham.KineticEnergy                     = ham.H[0]->getValue();
  pset.PropertyList[WP::LOCALENERGY]    = ham.LocalEnergy;
  pset.PropertyList[WP::LOCALPOTENTIAL] = ham.LocalEnergy - ham.KineticEnergy;
}

updateSource()

void updateSource

(

ParticleSet &

s

)

remove a named Hamiltonian from the list

Parameters

aname

the name of the Hamiltonian

Returns

true, if the request hamiltonian exists and is removed.

Definition at line 192 of file QMCHamiltonian.cpp.

References QMCHamiltonian::auxH, QMCHamiltonian::H, and qmcplusplus::Units::time::s.

Referenced by QMCMain::executeCMCSection().

{
  for (int i = 0; i < H.size(); ++i)
    H[i]->updateSource(s);
  for (int i = 0; i < auxH.size(); ++i)
    auxH[i]->updateSource(s);
}

Friends And Related Function Documentation

HamiltonianFactory

friend class HamiltonianFactory

friend

Definition at line 51 of file QMCHamiltonian.h.

Member Data Documentation

age_sample

Array<TraceInt, 1>* age_sample

private

Definition at line 485 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::collect_walker_traces(), QMCHamiltonian::finalize_traces(), and QMCHamiltonian::initialize_traces().

auxH

std::vector<std::unique_ptr<OperatorBase> > auxH

private

vector of Hamiltonians

Definition at line 454 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::addObservables(), QMCHamiltonian::addOperator(), QMCHamiltonian::auxHevaluate(), QMCHamiltonian::finalize_traces(), QMCHamiltonian::getHamiltonian(), QMCHamiltonian::initialize_traces(), QMCHamiltonian::makeClone(), QMCHamiltonian::registerCollectables(), QMCHamiltonian::registerObservables(), QMCHamiltonian::rejectedMove(), QMCHamiltonian::resetObservables(), QMCHamiltonian::resetTargetParticleSet(), QMCHamiltonian::setRandomGenerator(), QMCHamiltonian::total_size(), and QMCHamiltonian::updateSource().

available_quantities_

constexpr std::array<std::string_view, 8> available_quantities_

staticprivate

Initial value:

{"weight", "LocalEnergy", "LocalPotential",
                                                                         "Vq",     "Vc",          "Vqq",
                                                                         "Vqc",    "Vcc"}

Definition at line 431 of file QMCHamiltonian.h.

eval_ion_derivs_fast_timer_

NewTimer& eval_ion_derivs_fast_timer_

private

Total timer for H ion deriv evaluation;.

Definition at line 460 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::evaluateIonDerivsDeterministicFast().

eval_vals_derivs_timer_

NewTimer& eval_vals_derivs_timer_

private

Total timer for H evaluation.

Definition at line 458 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::evaluateValueAndDerivatives().

gen_sample

Array<TraceInt, 1>* gen_sample

private

Definition at line 484 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::finalize_traces(), and QMCHamiltonian::initialize_traces().

H

std::vector<std::unique_ptr<OperatorBase> > H

private

vector of Hamiltonians

Definition at line 448 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::addObservables(), QMCHamiltonian::addOperator(), QMCHamiltonian::createResource(), QMCHamiltonian::evaluate(), QMCHamiltonian::evaluateDeterministic(), QMCHamiltonian::evaluateIonDerivs(), QMCHamiltonian::evaluateIonDerivsDeterministic(), QMCHamiltonian::evaluateIonDerivsDeterministicFast(), QMCHamiltonian::evaluateValueAndDerivatives(), QMCHamiltonian::evaluateVariableEnergy(), QMCHamiltonian::evaluateWithToperator(), QMCHamiltonian::extract_HC_list(), QMCHamiltonian::finalize_traces(), QMCHamiltonian::get(), QMCHamiltonian::getEnsembleAverage(), QMCHamiltonian::getHamiltonian(), QMCHamiltonian::getTWFDependentComponents(), QMCHamiltonian::informOperatorsOfListener(), QMCHamiltonian::initialize_traces(), QMCHamiltonian::makeClone(), QMCHamiltonian::registerObservables(), QMCHamiltonian::resetObservables(), QMCHamiltonian::resetTargetParticleSet(), QMCHamiltonian::setPrimary(), QMCHamiltonian::setRandomGenerator(), QMCHamiltonian::size(), QMCHamiltonian::total_size(), QMCHamiltonian::updateKinetic(), and QMCHamiltonian::updateSource().

ham_timer_

NewTimer& ham_timer_

private

Total timer for H evaluation.

Definition at line 456 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::evaluate(), QMCHamiltonian::evaluateDeterministic(), and QMCHamiltonian::evaluateWithToperator().

id_sample

Array<TraceInt, 1>* id_sample

private

Definition at line 481 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::finalize_traces(), and QMCHamiltonian::initialize_traces().

KineticEnergy

FullPrecRealType KineticEnergy

private

Current Kinetic Energy.

Definition at line 442 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::evaluateValueAndDerivatives(), QMCHamiltonian::getKineticEnergy(), QMCHamiltonian::getLocalPotential(), QMCHamiltonian::saveProperty(), and QMCHamiltonian::updateKinetic().

l2_ptr

L2Potential* l2_ptr

private

pointer to L2Potential

Definition at line 452 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::addOperator(), QMCHamiltonian::computeL2D(), QMCHamiltonian::computeL2DK(), and QMCHamiltonian::has_L2().

LocalEnergy

FullPrecRealType LocalEnergy

private

Current Local Energy.

Definition at line 440 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::evaluate(), QMCHamiltonian::evaluateDeterministic(), QMCHamiltonian::evaluateValueAndDerivatives(), QMCHamiltonian::evaluateWithToperator(), QMCHamiltonian::getLocalEnergy(), QMCHamiltonian::getLocalPotential(), QMCHamiltonian::mw_evaluate(), QMCHamiltonian::mw_evaluateValueAndDerivatives(), QMCHamiltonian::mw_evaluateWithToperator(), QMCHamiltonian::saveProperty(), QMCHamiltonian::updateComponent(), and QMCHamiltonian::updateKinetic().

mult_sample

Array<TraceInt, 1>* mult_sample

private

Definition at line 486 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::collect_walker_traces(), QMCHamiltonian::finalize_traces(), and QMCHamiltonian::initialize_traces().

mw_res_handle_

ResourceHandle<QMCHamiltonianMultiWalkerResource> mw_res_handle_

private

Definition at line 492 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::mw_registerKineticListener(), QMCHamiltonian::mw_registerLocalEnergyListener(), QMCHamiltonian::mw_registerLocalIonPotentialListener(), and QMCHamiltonian::mw_registerLocalPotentialListener().

my_timers_

std::vector<std::reference_wrapper<NewTimer> > my_timers_

private

timers for H components

Definition at line 462 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::addOperator(), QMCHamiltonian::evaluate(), QMCHamiltonian::evaluateDeterministic(), QMCHamiltonian::evaluateValueAndDerivatives(), and QMCHamiltonian::evaluateWithToperator().

myIndex

int myIndex

private

starting index

Definition at line 436 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::addObservables(), QMCHamiltonian::auxHevaluate(), QMCHamiltonian::makeClone(), QMCHamiltonian::resetObservables(), QMCHamiltonian::saveProperty(), QMCHamiltonian::setProperty(), QMCHamiltonian::startIndex(), and QMCHamiltonian::updateComponent().

myName

const std::string myName

private

getName is in the way

Definition at line 446 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::getName(), and QMCHamiltonian::makeClone().

NewLocalEnergy

FullPrecRealType NewLocalEnergy

private

Current Local Energy for the proposed move.

Definition at line 444 of file QMCHamiltonian.h.

nlpp_ptr

NonLocalECPotential* nlpp_ptr

private

pointer to NonLocalECP

Definition at line 450 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::addOperator(), QMCHamiltonian::makeNonLocalMoves(), QMCHamiltonian::mw_makeNonLocalMoves(), QMCHamiltonian::setNonLocalMoves(), and QMCHamiltonian::setRandomGenerator().

numCollectables

int numCollectables

private

starting index

Definition at line 438 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::addObservables(), QMCHamiltonian::makeClone(), QMCHamiltonian::resetObservables(), and QMCHamiltonian::sizeOfCollectables().

Observables

PropertySetType Observables

private

data

Definition at line 466 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::addObservables(), QMCHamiltonian::auxHevaluate(), QMCHamiltonian::getObservable(), QMCHamiltonian::getObservableName(), QMCHamiltonian::resetObservables(), QMCHamiltonian::saveProperty(), QMCHamiltonian::setProperty(), QMCHamiltonian::sizeOfObservables(), and QMCHamiltonian::updateComponent().

operator_types

std::map<std::string, std::string> operator_types

private

types of component operators

Definition at line 464 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::addOperatorType(), and QMCHamiltonian::getOperatorType().

pid_sample

Array<TraceInt, 1>* pid_sample

private

Definition at line 482 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::finalize_traces(), and QMCHamiltonian::initialize_traces().

position_sample

Array<TraceReal, 2>* position_sample

private

Definition at line 488 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::collect_walker_traces(), QMCHamiltonian::finalize_traces(), and QMCHamiltonian::initialize_traces().

request

TraceRequest request

private

traces variables

Definition at line 479 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::collect_walker_traces(), QMCHamiltonian::finalize_traces(), and QMCHamiltonian::initialize_traces().

step_sample

Array<TraceInt, 1>* step_sample

private

Definition at line 483 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::finalize_traces(), and QMCHamiltonian::initialize_traces().

streaming_position

bool streaming_position

private

Definition at line 480 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::collect_walker_traces(), QMCHamiltonian::finalize_traces(), and QMCHamiltonian::initialize_traces().

weight_sample

Array<TraceReal, 1>* weight_sample

private

Definition at line 487 of file QMCHamiltonian.h.

Referenced by QMCHamiltonian::collect_walker_traces(), QMCHamiltonian::finalize_traces(), and QMCHamiltonian::initialize_traces().

---

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

• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCHamiltonians/QMCHamiltonian.h
• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCHamiltonians/QMCHamiltonian.cpp