BackflowTransformation Class Reference

Inheritance diagram for BackflowTransformation:

Collaboration diagram for BackflowTransformation:

Public Types
enum	{ DIM = OHMMS_DIM }
enum	{   ORB_PBYP_RATIO, ORB_PBYP_ALL, ORB_PBYP_PARTIAL, ORB_WALKER,   ORB_ALLWALKER }
	enum for a update mode More...
using	WFBufferType = BackflowFunctionBase::WFBufferType
using	RealType = OHMMS_PRECISION
using	IndexType = int
using	PosType = TinyVector< RealType, DIM >
using	GradType = TinyVector< RealType, DIM >
using	HessType = Tensor< RealType, DIM >
using	IndexVector = Vector< IndexType >
using	GradVector = Vector< GradType >
using	GradMatrix = Matrix< GradType >
using	HessVector = Vector< HessType >
using	HessMatrix = Matrix< HessType >
using	HessArray = Array< HessType, 3 >
using	PSetMap = std::map< std::string, const std::unique_ptr< ParticleSet > >

Public Member Functions
	BackflowTransformation (ParticleSet &els)
void	copyFrom (const BackflowTransformation &tr, ParticleSet &targetPtcl)
std::unique_ptr< BackflowTransformation >	makeClone (ParticleSet &tqp) const
	~BackflowTransformation ()
bool	put (xmlNodePtr cur)
void	acceptMove (const ParticleSet &P, int iat)
void	restore (int iat=0)
bool	isOptimizable () const
void	checkInVariables (opt_variables_type &active)
void	checkOutVariables (const opt_variables_type &active)
void	resetParameters (const opt_variables_type &active)
void	reportStatus (std::ostream &os) final
	print the state, e.g., optimizables More...
void	checkInVariablesExclusive (opt_variables_type &active) final
	check in variational parameters to the global list of parameters used by the optimizer. More...
void	resetParametersExclusive (const opt_variables_type &active) final
	reset the parameters during optimizations. More...
void	registerData (ParticleSet &P, WFBufferType &buf)
void	updateBuffer (ParticleSet &P, WFBufferType &buf, bool redo)
void	copyFromBuffer (ParticleSet &P, WFBufferType &buf)
void	transformOnly (const ParticleSet &P)
	calculate quasi-particle coordinates only More...
void	evaluatePbyP (const ParticleSet &P, int iat)
	calculate new quasi-particle coordinates after pbyp move More...
void	evaluatePbyPWithGrad (const ParticleSet &P, int iat)
	calculate new quasi-particle coordinates after pbyp move More...
void	evaluatePbyPAll (const ParticleSet &P, int iat)
	calculate new quasi-particle coordinates after pbyp move More...
void	evaluateBmatOnly (const ParticleSet &P, int iat)
	calculate only Bmat. More...
void	evaluate (const ParticleSet &P)
	calculate quasi-particle coordinates, Bmat and Amat More...
void	evaluate (const ParticleSet &P, ParticleSet &Pnew)
	calculate quasi-particle coordinates and store in Pnew More...
void	evaluateDerivatives (const ParticleSet &P)
void	testDeriv (const ParticleSet &P)
void	testPbyP (ParticleSet &P)
Public Member Functions inherited from OptimizableObject
	OptimizableObject (const std::string &name)
const std::string &	getName () const
bool	isOptimized () const
void	setOptimization (bool state)
virtual void	writeVariationalParameters (hdf_archive &hout)
	Write the variational parameters for this object to the VP HDF file. More...
virtual void	readVariationalParameters (hdf_archive &hin)
	Read the variational parameters for this object from the VP HDF file. More...

Public Attributes
int	NumTargets
	number of quantum particles More...
int	activeParticle
	active particle in pbyp moves More...
ParticleSet	QP
	quasiparticle coordinates More...
int	numParams
int	UpdateMode
	current update mode More...
std::map< int, int >	optIndexMap
RealType	cutOff
int	numVarBefore
const int	myTableIndex_
	Distance Table. More...
GradVector	Bmat
GradMatrix	Bmat_full
GradMatrix	Bmat_temp
HessMatrix	Amat
HessMatrix	Amat_temp
HessArray	Xmat
GradMatrix	Ymat
GradMatrix	Cmat
RealType *	FirstOfP
RealType *	LastOfP
RealType *	FirstOfA
RealType *	LastOfA
RealType *	FirstOfB
RealType *	LastOfB
RealType *	FirstOfA_temp
RealType *	LastOfA_temp
RealType *	FirstOfB_temp
RealType *	LastOfB_temp
HessType	HESS_ID
HessType	DummyHess
std::vector< std::unique_ptr< BackflowFunctionBase > >	bfFuns
std::map< std::string, int >	sources
std::vector< std::string >	names
ParticleSet::ParticlePos	newQP
	new qp coordinates for pbyp moves. More...
ParticleSet::ParticlePos	oldQP
Vector< PosType >	storeQP
std::vector< int >	indexQP
	store index of qp coordinates that changed during pbyp move More...
std::vector< int >	index
opt_variables_type	myVars

Detailed Description

Definition at line 31 of file BackflowTransformation.h.

Member Typedef Documentation

GradMatrix

using GradMatrix = Matrix<GradType>

Definition at line 48 of file BackflowTransformation.h.

GradType

using GradType = TinyVector<RealType, DIM>

Definition at line 44 of file BackflowTransformation.h.

GradVector

using GradVector = Vector<GradType>

Definition at line 47 of file BackflowTransformation.h.

HessArray

using HessArray = Array<HessType, 3>

Definition at line 52 of file BackflowTransformation.h.

HessMatrix

using HessMatrix = Matrix<HessType>

Definition at line 50 of file BackflowTransformation.h.

HessType

using HessType = Tensor<RealType, DIM>

Definition at line 45 of file BackflowTransformation.h.

HessVector

using HessVector = Vector<HessType>

Definition at line 49 of file BackflowTransformation.h.

IndexType

using IndexType = int

Definition at line 42 of file BackflowTransformation.h.

IndexVector

using IndexVector = Vector<IndexType>

Definition at line 46 of file BackflowTransformation.h.

PosType

using PosType = TinyVector<RealType, DIM>

Definition at line 43 of file BackflowTransformation.h.

PSetMap

using PSetMap = std::map<std::string, const std::unique_ptr<ParticleSet> >

Definition at line 54 of file BackflowTransformation.h.

RealType

using RealType = OHMMS_PRECISION

Definition at line 41 of file BackflowTransformation.h.

WFBufferType

using WFBufferType = BackflowFunctionBase::WFBufferType

Definition at line 34 of file BackflowTransformation.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
DIM

Definition at line 37 of file BackflowTransformation.h.

  {
    DIM = OHMMS_DIM
  };

anonymous enum

anonymous enum

enum for a update mode

Enumerator
ORB_PBYP_RATIO	particle-by-particle ratio only
ORB_PBYP_ALL	particle-by-particle, update Value-Gradient-Laplacian
ORB_PBYP_PARTIAL	particle-by-particle, update Value and Grdient
ORB_WALKER	walker update
ORB_ALLWALKER	all walkers update

Definition at line 74 of file BackflowTransformation.h.

  {
    ORB_PBYP_RATIO,   /*!< particle-by-particle ratio only */
    ORB_PBYP_ALL,     /*!< particle-by-particle, update Value-Gradient-Laplacian */
    ORB_PBYP_PARTIAL, /*!< particle-by-particle, update Value and Grdient */
    ORB_WALKER,       /*!< walker update */
    ORB_ALLWALKER     /*!< all walkers update */
  };

Constructor & Destructor Documentation

BackflowTransformation()

BackflowTransformation

(

ParticleSet &

els

)

Definition at line 23 of file BackflowTransformation.cpp.

References BackflowTransformation::Amat, BackflowTransformation::Bmat, BackflowTransformation::Bmat_full, Tensor< T, D >::diagonal(), BackflowTransformation::DummyHess, ParticleSet::getTotalNum(), BackflowTransformation::HESS_ID, BackflowTransformation::indexQP, BackflowTransformation::newQP, BackflowTransformation::NumTargets, BackflowTransformation::numVarBefore, BackflowTransformation::oldQP, Matrix< T, Alloc >::resize(), and Vector< T, Alloc >::resize().

    : OptimizableObject("bf"), QP(els), cutOff(0.0), myTableIndex_(els.addTable(els))
{
  NumTargets = els.getTotalNum();
  Bmat.resize(NumTargets);
  Bmat_full.resize(NumTargets, NumTargets);
  Amat.resize(NumTargets, NumTargets);
  newQP.resize(NumTargets);
  oldQP.resize(NumTargets);
  indexQP.resize(NumTargets);
  HESS_ID.diagonal(1.0);
  DummyHess    = 0.0;
  numVarBefore = 0;
}

~BackflowTransformation()

~BackflowTransformation ( )

default

Member Function Documentation

acceptMove()

void acceptMove	(	const ParticleSet &	P,
		int	iat
	)

Definition at line 65 of file BackflowTransformation.cpp.

References BackflowTransformation::bfFuns, copy(), BackflowTransformation::FirstOfA, BackflowTransformation::FirstOfA_temp, BackflowTransformation::FirstOfB, BackflowTransformation::FirstOfB_temp, BackflowTransformation::indexQP, BackflowTransformation::LastOfA_temp, BackflowTransformation::LastOfB_temp, BackflowTransformation::newQP, BackflowTransformation::NumTargets, BackflowTransformation::ORB_PBYP_ALL, BackflowTransformation::ORB_PBYP_PARTIAL, BackflowTransformation::ORB_PBYP_RATIO, BackflowTransformation::QP, ParticleSet::R, ParticleSet::update(), and BackflowTransformation::UpdateMode.

Referenced by BackflowTransformation::testPbyP().

{
  // update QP table
  // may be faster if I do this one qp at a time, for now do full update
  for (int i = 0; i < NumTargets; i++)
    QP.R[i] = newQP[i];
  QP.update(0);
  indexQP.clear();
  switch (UpdateMode)
  {
  case ORB_PBYP_RATIO:
    break;
  case ORB_PBYP_PARTIAL:
    std::copy(FirstOfA_temp, LastOfA_temp, FirstOfA);
    break;
  case ORB_PBYP_ALL:
    std::copy(FirstOfA_temp, LastOfA_temp, FirstOfA);
    std::copy(FirstOfB_temp, LastOfB_temp, FirstOfB);
    break;
  default:
    std::copy(FirstOfA_temp, LastOfA_temp, FirstOfA);
    std::copy(FirstOfB_temp, LastOfB_temp, FirstOfB);
    break;
  }
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->acceptMove(iat, UpdateMode);
}

checkInVariables()

void checkInVariables

(

opt_variables_type &

active

)

Definition at line 100 of file BackflowTransformation.cpp.

References BackflowTransformation::bfFuns.

Referenced by BackflowTransformation::checkInVariablesExclusive(), BackflowTransformation::testDeriv(), DiracDeterminantWithBackflow::testDerivFjj(), and DiracDeterminantWithBackflow::testDerivLi().

{
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->checkInVariables(active);
}

checkInVariablesExclusive()

void checkInVariablesExclusive ( opt_variables_type &  active )

inlinefinalvirtual

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 168 of file BackflowTransformation.h.

References BackflowTransformation::checkInVariables().

{ checkInVariables(active); }

checkOutVariables()

void checkOutVariables

(

const opt_variables_type &

active

)

Definition at line 112 of file BackflowTransformation.cpp.

References BackflowTransformation::bfFuns.

Referenced by BackflowTransformation::testDeriv(), DiracDeterminantWithBackflow::testDerivFjj(), and DiracDeterminantWithBackflow::testDerivLi().

{
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->checkOutVariables(active);
}

copyFrom()

void copyFrom	(	const BackflowTransformation &	tr,
		ParticleSet &	targetPtcl
	)

Definition at line 38 of file BackflowTransformation.cpp.

References BackflowTransformation::bfFuns, BackflowTransformation::cutOff, BackflowTransformation::numParams, BackflowTransformation::numVarBefore, and BackflowTransformation::optIndexMap.

{
  cutOff       = tr.cutOff;
  numParams    = tr.numParams;
  numVarBefore = tr.numVarBefore;
  optIndexMap  = tr.optIndexMap;
  bfFuns.resize(tr.bfFuns.size());
  auto it(tr.bfFuns.begin());
  for (int i = 0; i < (tr.bfFuns).size(); i++, it++)
    bfFuns[i] = (*it)->makeClone(targetPtcl);
}

copyFromBuffer()

void copyFromBuffer	(	ParticleSet &	P,
		WFBufferType &	buf
	)

Definition at line 175 of file BackflowTransformation.cpp.

References BackflowTransformation::bfFuns, BackflowTransformation::FirstOfA, BackflowTransformation::FirstOfB, BackflowTransformation::FirstOfP, PooledMemory< T_scalar, Alloc >::get(), BackflowTransformation::LastOfA, BackflowTransformation::LastOfB, BackflowTransformation::LastOfP, BackflowTransformation::NumTargets, BackflowTransformation::QP, ParticleSet::R, BackflowTransformation::storeQP, and ParticleSet::update().

{
  buf.get(FirstOfP, LastOfP);
  buf.get(FirstOfA, LastOfA);
  buf.get(FirstOfB, LastOfB);
  for (int i = 0; i < NumTargets; i++)
    QP.R[i] = storeQP[i];
  QP.update(0);
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->copyFromBuffer(buf);
}

evaluate() [1/2]

void evaluate

(

const ParticleSet &

P

)

calculate quasi-particle coordinates, Bmat and Amat

Definition at line 312 of file BackflowTransformation.cpp.

References BackflowTransformation::Amat, BackflowTransformation::bfFuns, BackflowTransformation::Bmat, BackflowTransformation::Bmat_full, BackflowTransformation::NumTargets, BackflowTransformation::QP, ParticleSet::R, and ParticleSet::update().

Referenced by BackflowTransformation::evaluate(), BackflowTransformation::registerData(), BackflowTransformation::testDeriv(), DiracDeterminantWithBackflow::testDerivLi(), DiracDeterminantWithBackflow::testL(), BackflowTransformation::testPbyP(), BackflowTransformation::transformOnly(), and BackflowTransformation::updateBuffer().

{
  Bmat      = 0.0;
  Amat      = 0.0;
  Bmat_full = 0.0;
  QP.R      = P.R;
  for (int i = 0; i < NumTargets; i++)
  {
    //QP.R[i] = P.R[i];
    Amat(i, i).diagonal(1.0);
  }
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->evaluate(P, QP, Bmat_full, Amat);
  //      std::cerr <<"P.R \n";
  //      std::cerr <<P.R[0] << std::endl;
  //      std::cerr <<"QP.R " << std::endl;
  //      std::cerr <<QP.R[0] << std::endl;
  //      std::cerr <<omp_get_thread_num()<<" "<<P.R[0]-QP.R[0] << std::endl;
  //      APP_ABORT("TESTING BF \n");
  /*Bmat=0.0;
    Amat=0.0;
    Bmat_full=0.0;
    for(int i=0; i<NumTargets; i++) {
      Amat(i,i).diagonal(1.0);
    }*/
  /*
          // testing bf
          for(int i=0; i<NumTargets; i++) {
            std::cout <<"i: " <<i << std::endl;
            std::cout <<P.R[i] << std::endl;
            std::cout <<QP.R[i] << std::endl;
            std::cout <<P.R[i]-QP.R[i] << std::endl;
          }
          //
    */
  QP.update(0); // update distance tables
}

evaluate() [2/2]

void evaluate	(	const ParticleSet &	P,
		ParticleSet &	Pnew
	)

calculate quasi-particle coordinates and store in Pnew

Definition at line 352 of file BackflowTransformation.cpp.

References BackflowTransformation::bfFuns, BackflowTransformation::evaluate(), ParticleSet::R, and ParticleSet::update().

{
  Pnew.R = P.R;
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->evaluate(P, Pnew);
  Pnew.update(0);
}

evaluateBmatOnly()

void evaluateBmatOnly	(	const ParticleSet &	P,
		int	iat
	)

calculate only Bmat.

Assume that QP and Amat are current This is used in pbyp moves, in updateBuffer()

Definition at line 303 of file BackflowTransformation.cpp.

References BackflowTransformation::bfFuns, and BackflowTransformation::Bmat_full.

{
  Bmat_full = 0.0;
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->evaluateBmatOnly(P, Bmat_full);
}

evaluateDerivatives()

void evaluateDerivatives

(

const ParticleSet &

P

)

Definition at line 360 of file BackflowTransformation.cpp.

References BackflowTransformation::Amat, BackflowTransformation::bfFuns, BackflowTransformation::Bmat, BackflowTransformation::Bmat_full, BackflowTransformation::Cmat, Array< T, D, ALLOC >::data(), OMPstd::fill_n(), BackflowTransformation::numParams, BackflowTransformation::NumTargets, BackflowTransformation::numVarBefore, BackflowTransformation::optIndexMap, BackflowTransformation::QP, ParticleSet::R, Array< T, D, ALLOC >::resize(), Matrix< T, Alloc >::resize(), Array< T, D, ALLOC >::size(), Matrix< T, Alloc >::size(), ParticleSet::update(), BackflowTransformation::Xmat, and BackflowTransformation::Ymat.

Referenced by DiracDeterminantWithBackflow::testDerivFjj(), and DiracDeterminantWithBackflow::testDerivLi().

{
  if (Cmat.size() == 0)
  // initialize in the first call
  {
    // assumes that all BF parameters are packed together in
    // active variable set. is this always correct???
    numParams = 0;
    for (int i = 0; i < bfFuns.size(); i++)
    {
      int tmp = bfFuns[i]->setParamIndex(numParams);
      numParams += tmp;
    }
    numVarBefore = bfFuns[0]->indexOffset();
    //app_log() <<"numVarBefore: " <<numVarBefore << std::endl;
    for (int i = 0; i < numParams; i++)
    {
      optIndexMap[i] = i + numVarBefore;
      //app_log() <<"prm, map: " <<i <<"  " <<optIndexMap[i] << std::endl;
    }
    Cmat.resize(numParams, NumTargets);
    Xmat.resize(numParams, NumTargets, NumTargets);
    Ymat.resize(numParams, NumTargets);
  }
  // Uncomment to test calculation of Cmat,Xmat,Ymat
  //testDeriv(P);
  Bmat      = 0.0;
  Amat      = 0.0;
  Bmat_full = 0.0;
  Cmat      = 0.0;
  Ymat      = 0.0;
  std::fill_n(Xmat.data(), Xmat.size(), 0);
  for (int i = 0; i < NumTargets; i++)
  {
    QP.R[i] = P.R[i];
    Amat(i, i).diagonal(1.0);
  }
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->evaluateWithDerivatives(P, QP, Bmat_full, Amat, Cmat, Ymat, Xmat);
  QP.update(0);
}

evaluatePbyP()

void evaluatePbyP	(	const ParticleSet &	P,
		int	iat
	)

calculate new quasi-particle coordinates after pbyp move

Definition at line 200 of file BackflowTransformation.cpp.

References BackflowTransformation::activeParticle, BackflowTransformation::bfFuns, qmcplusplus::dot(), qmcplusplus::Units::charge::e, ParticleSet::getDistTableAA(), BackflowTransformation::indexQP, BackflowTransformation::myTableIndex_, BackflowTransformation::newQP, BackflowTransformation::NumTargets, BackflowTransformation::oldQP, BackflowTransformation::ORB_PBYP_RATIO, BackflowTransformation::QP, ParticleSet::R, BackflowTransformation::restore(), qmcplusplus::sqrt(), and BackflowTransformation::UpdateMode.

Referenced by BackflowTransformation::evaluatePbyPAll(), and BackflowTransformation::evaluatePbyPWithGrad().

{
  UpdateMode = ORB_PBYP_RATIO;
  // there should be no need for this, but there is (missing calls in QMCHam...)
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->restore(iat, UpdateMode);
  activeParticle = iat;
  for (int i = 0; i < NumTargets; i++)
    oldQP[i] = newQP[i] = QP.R[i];
  const auto& myTable = P.getDistTableAA(myTableIndex_);
  newQP[iat] -= myTable.getTempDispls()[iat];
  indexQP.clear();
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->evaluatePbyP(P, iat, newQP);
  for (int jat = 0; jat < NumTargets; jat++)
  {
    // make direct routine in OhmmsPETE later
    RealType dr = std::sqrt(dot(newQP[jat] - QP.R[jat], newQP[jat] - QP.R[jat]));
    if (dr > 1e-10)
      indexQP.push_back(jat);
  }
  //debug
  /*
    dummyQP2.R = P.R;
    dummyQP2.update();
    evaluate(P,dummyQP);
    std::cout <<"index: ";
    for(int i=0; i<indexQP.size(); i++) std::cout <<indexQP[i] <<" ";
    std::cout << std::endl;
    for(int jat=0; jat<NumTargets; jat++)
      std::cout <<jat <<"  "
      <<(newQP[jat]-dummyQP.R[jat]) <<" " <<newQP[jat] <<" " <<QP.R[jat] <<"\n";
    for(int i=0; i<NumTargets; i++) newQP[i] = dummyQP.R[i];
    * /
    indexQP.clear();
    indexQP.push_back(iat); // set in the beginning by default
    for(int jat=0; jat<NumTargets; jat++) {
      if(jat!=iat) // && myTable.Temp[jat].r1 < cutOff )
        indexQP.push_back(jat);
    }
    */
}

evaluatePbyPAll()

void evaluatePbyPAll	(	const ParticleSet &	P,
		int	iat
	)

calculate new quasi-particle coordinates after pbyp move

Definition at line 271 of file BackflowTransformation.cpp.

References BackflowTransformation::activeParticle, BackflowTransformation::Amat_temp, BackflowTransformation::bfFuns, BackflowTransformation::Bmat_temp, copy(), qmcplusplus::dot(), qmcplusplus::Units::charge::e, BackflowTransformation::evaluatePbyP(), BackflowTransformation::FirstOfA, BackflowTransformation::FirstOfA_temp, BackflowTransformation::FirstOfB, BackflowTransformation::FirstOfB_temp, ParticleSet::getDistTableAA(), BackflowTransformation::indexQP, BackflowTransformation::LastOfA, BackflowTransformation::LastOfB, BackflowTransformation::myTableIndex_, BackflowTransformation::newQP, BackflowTransformation::NumTargets, BackflowTransformation::oldQP, BackflowTransformation::ORB_PBYP_ALL, BackflowTransformation::QP, ParticleSet::R, BackflowTransformation::restore(), qmcplusplus::sqrt(), and BackflowTransformation::UpdateMode.

{
  UpdateMode = ORB_PBYP_ALL;
  // there should be no need for this, but there is (missing calls in QMCHam...)
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->restore(iat, UpdateMode);
  activeParticle = iat;
  for (int i = 0; i < NumTargets; i++)
    oldQP[i] = newQP[i] = QP.R[i];
  const auto& myTable = P.getDistTableAA(myTableIndex_);

  // this is from AoS, is it needed or not?
  //newQP[iat] += myTable.Temp[iat].dr1;

  indexQP.clear();
  std::copy(FirstOfA, LastOfA, FirstOfA_temp);
  std::copy(FirstOfB, LastOfB, FirstOfB_temp);
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->evaluatePbyP(P, iat, newQP, Bmat_temp, Amat_temp);
  for (int jat = 0; jat < NumTargets; jat++)
  {
    // make direct routine in OhmmsPETE later
    RealType dr = std::sqrt(dot(newQP[jat] - QP.R[jat], newQP[jat] - QP.R[jat]));
    if (dr > 1e-10)
      indexQP.push_back(jat);
  }
}

evaluatePbyPWithGrad()

void evaluatePbyPWithGrad	(	const ParticleSet &	P,
		int	iat
	)

calculate new quasi-particle coordinates after pbyp move

Definition at line 246 of file BackflowTransformation.cpp.

References BackflowTransformation::activeParticle, BackflowTransformation::Amat_temp, BackflowTransformation::bfFuns, copy(), qmcplusplus::dot(), qmcplusplus::Units::charge::e, BackflowTransformation::evaluatePbyP(), BackflowTransformation::FirstOfA, BackflowTransformation::FirstOfA_temp, ParticleSet::getDistTableAA(), BackflowTransformation::indexQP, BackflowTransformation::LastOfA, BackflowTransformation::myTableIndex_, BackflowTransformation::newQP, BackflowTransformation::NumTargets, BackflowTransformation::oldQP, BackflowTransformation::ORB_PBYP_PARTIAL, BackflowTransformation::QP, ParticleSet::R, BackflowTransformation::restore(), qmcplusplus::sqrt(), and BackflowTransformation::UpdateMode.

Referenced by BackflowTransformation::testPbyP().

{
  UpdateMode = ORB_PBYP_PARTIAL;
  // there should be no need for this, but there is (missing calls in QMCHam...)
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->restore(iat, UpdateMode);
  activeParticle = iat;
  for (int i = 0; i < NumTargets; i++)
    oldQP[i] = newQP[i] = QP.R[i];
  const auto& myTable = P.getDistTableAA(myTableIndex_);
  newQP[iat] -= myTable.getTempDispls()[iat];
  indexQP.clear();
  std::copy(FirstOfA, LastOfA, FirstOfA_temp);
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->evaluatePbyP(P, iat, newQP, Amat_temp);
  for (int jat = 0; jat < NumTargets; jat++)
  {
    RealType dr = std::sqrt(dot(newQP[jat] - QP.R[jat], newQP[jat] - QP.R[jat]));
    if (dr > 1e-10)
      indexQP.push_back(jat);
  }
}

isOptimizable()

bool isOptimizable

(

)

const

Definition at line 118 of file BackflowTransformation.cpp.

References BackflowTransformation::bfFuns.

Referenced by BackflowTransformation::resetParameters().

{
  for (int i = 0; i < bfFuns.size(); i++)
    if (bfFuns[i]->isOptimizable())
      return true;
  return false;
}

makeClone()

std::unique_ptr< BackflowTransformation > makeClone

(

ParticleSet &

tqp

)

const

Definition at line 51 of file BackflowTransformation.cpp.

References qmcplusplus::clone.

{
  auto clone = std::make_unique<BackflowTransformation>(tqp);
  clone->copyFrom(*this, tqp);
  //       std::vector<BackflowFunctionBase*>::iterator it((bfFuns).begin());
  //       for(int i=0; i<(bfFuns).size() ; i++,it++)
  //       {
  //         clone->bfFuns[i]->reportStatus(cerr);
  //       }
  return clone;
}

put()

bool put ( xmlNodePtr  cur )

inline

Definition at line 153 of file BackflowTransformation.h.

{ return true; }

registerData()

void registerData	(	ParticleSet &	P,
		WFBufferType &	buf
	)

Definition at line 134 of file BackflowTransformation.cpp.

References PooledMemory< T_scalar, Alloc >::add(), BackflowTransformation::Amat, BackflowTransformation::Amat_temp, BackflowTransformation::bfFuns, BackflowTransformation::Bmat_full, BackflowTransformation::Bmat_temp, BackflowTransformation::evaluate(), BackflowTransformation::FirstOfA, BackflowTransformation::FirstOfA_temp, BackflowTransformation::FirstOfB, BackflowTransformation::FirstOfB_temp, BackflowTransformation::FirstOfP, BackflowTransformation::LastOfA, BackflowTransformation::LastOfA_temp, BackflowTransformation::LastOfB, BackflowTransformation::LastOfB_temp, BackflowTransformation::LastOfP, BackflowTransformation::NumTargets, OHMMS_DIM, BackflowTransformation::QP, ParticleSet::R, Matrix< T, Alloc >::resize(), and BackflowTransformation::storeQP.

Referenced by BackflowTransformation::testPbyP().

{
  if (storeQP.size() == 0)
  {
    Bmat_temp.resize(NumTargets, NumTargets);
    Amat_temp.resize(NumTargets, NumTargets);
    storeQP.resize(NumTargets);
  }
  evaluate(P);
  FirstOfP      = &(storeQP[0][0]);
  LastOfP       = FirstOfP + OHMMS_DIM * NumTargets;
  FirstOfA      = &(Amat(0, 0)[0]);
  LastOfA       = FirstOfA + OHMMS_DIM * OHMMS_DIM * NumTargets * NumTargets;
  FirstOfB      = &(Bmat_full(0, 0)[0]);
  LastOfB       = FirstOfB + OHMMS_DIM * NumTargets * NumTargets;
  FirstOfA_temp = &(Amat_temp(0, 0)[0]);
  LastOfA_temp  = FirstOfA_temp + OHMMS_DIM * OHMMS_DIM * NumTargets * NumTargets;
  FirstOfB_temp = &(Bmat_temp(0, 0)[0]);
  LastOfB_temp  = FirstOfB_temp + OHMMS_DIM * NumTargets * NumTargets;
  for (int i = 0; i < NumTargets; i++)
    storeQP[i] = QP.R[i];
  buf.add(FirstOfP, LastOfP);
  buf.add(FirstOfA, LastOfA);
  buf.add(FirstOfB, LastOfB);
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->registerData(buf);
}

reportStatus()

void reportStatus ( std::ostream &  os )

finalvirtual

print the state, e.g., optimizables

Reimplemented from OptimizableObject.

Definition at line 106 of file BackflowTransformation.cpp.

References BackflowTransformation::bfFuns.

{
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->reportStatus(os);
}

resetParameters()

void resetParameters

(

const opt_variables_type &

active

)

Definition at line 126 of file BackflowTransformation.cpp.

References BackflowTransformation::bfFuns, and BackflowTransformation::isOptimizable().

Referenced by BackflowTransformation::resetParametersExclusive(), BackflowTransformation::testDeriv(), DiracDeterminantWithBackflow::testDerivFjj(), and DiracDeterminantWithBackflow::testDerivLi().

{
  //reset each unique basis functions
  for (int i = 0; i < bfFuns.size(); i++)
    if (bfFuns[i]->isOptimizable())
      bfFuns[i]->resetParameters(active);
}

resetParametersExclusive()

void resetParametersExclusive ( const opt_variables_type &  active )

inlinefinalvirtual

reset the parameters during optimizations.

Exclusive, see checkInVariablesExclusive

Implements OptimizableObject.

Definition at line 169 of file BackflowTransformation.h.

References BackflowTransformation::resetParameters().

{ resetParameters(active); }

restore()

void restore

(

int

iat = 0

)

Definition at line 93 of file BackflowTransformation.cpp.

References BackflowTransformation::bfFuns, BackflowTransformation::indexQP, and BackflowTransformation::UpdateMode.

Referenced by BackflowTransformation::evaluatePbyP(), BackflowTransformation::evaluatePbyPAll(), and BackflowTransformation::evaluatePbyPWithGrad().

{
  indexQP.clear();
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->restore(iat, UpdateMode);
}

testDeriv()

void testDeriv

(

const ParticleSet &

P

)

Definition at line 402 of file BackflowTransformation.cpp.

References qmcplusplus::abs(), BackflowTransformation::Amat, qmcplusplus::app_log(), BackflowTransformation::bfFuns, BackflowTransformation::Bmat, BackflowTransformation::Bmat_full, BackflowTransformation::checkInVariables(), BackflowTransformation::checkOutVariables(), BackflowTransformation::Cmat, Array< T, D, ALLOC >::data(), BackflowTransformation::evaluate(), OMPstd::fill_n(), qmcplusplus::for(), BackflowTransformation::numParams, BackflowTransformation::NumTargets, OHMMS_DIM, VariableSet::print(), BackflowTransformation::QP, ParticleSet::R, BackflowTransformation::resetParameters(), Array< T, D, ALLOC >::resize(), Matrix< T, Alloc >::resize(), Vector< T, Alloc >::resize(), Array< T, D, ALLOC >::size(), Matrix< T, Alloc >::size(), VariableSet::size(), BackflowTransformation::Xmat, and BackflowTransformation::Ymat.

{
  if (Cmat.size() == 0)
  // initialize in the first call
  {
    Cmat.resize(numParams, NumTargets);
    Xmat.resize(numParams, NumTargets, NumTargets);
    Ymat.resize(numParams, NumTargets);
  }
  Bmat      = 0.0;
  Amat      = 0.0;
  Bmat_full = 0.0;
  Cmat      = 0.0;
  Ymat      = 0.0;
  std::fill_n(Xmat.data(), Xmat.size(), 0);
  for (int i = 0; i < NumTargets; i++)
  {
    QP.R[i] = P.R[i];
    Amat(i, i).diagonal(1.0);
  }
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->evaluateWithDerivatives(P, QP, Bmat_full, Amat, Cmat, Ymat, Xmat);
  ParticleSet::ParticlePos qp_0;
  ParticleSet::ParticlePos qp_1;
  ParticleSet::ParticlePos qp_2;
  GradMatrix Bmat_full_1;
  HessMatrix Amat_1;
  GradMatrix Bmat_full_2;
  HessMatrix Amat_2;
  RealType dh = 0.00001;
  qp_0.resize(NumTargets);
  qp_1.resize(NumTargets);
  qp_2.resize(NumTargets);
  Bmat_full_1.resize(NumTargets, NumTargets);
  Bmat_full_2.resize(NumTargets, NumTargets);
  Amat_1.resize(NumTargets, NumTargets);
  Amat_2.resize(NumTargets, NumTargets);
  for (int i = 0; i < NumTargets; i++)
  {
    qp_0[i] = QP.R[i];
  }
  app_log() << " Testing derivatives of backflow transformation. \n";
  app_log() << " Numtargets: " << NumTargets << std::endl;
  opt_variables_type wfVars, wfvar_prime;
  checkInVariables(wfVars);
  checkOutVariables(wfVars);
  int Nvars   = wfVars.size();
  wfvar_prime = wfVars;
  wfVars.print(std::cout);
  for (int i = 0; i < Nvars; i++)
  {
    for (int j = 0; j < Nvars; j++)
      wfvar_prime[j] = wfVars[j];
    wfvar_prime[i] = wfVars[i] + dh;
    resetParameters(wfvar_prime);
    Bmat_full_1 = 0.0;
    Amat_1      = 0.0;
    for (int k = 0; k < NumTargets; k++)
    {
      QP.R[k] = P.R[k];
      Amat_1(k, k).diagonal(1.0);
    }
    for (int k = 0; k < bfFuns.size(); k++)
      bfFuns[k]->evaluate(P, QP, Bmat_full_1, Amat_1);
    for (int k = 0; k < NumTargets; k++)
      qp_1[k] = QP.R[k];
    for (int j = 0; j < Nvars; j++)
      wfvar_prime[j] = wfVars[j];
    wfvar_prime[i] = wfVars[i] - dh;
    resetParameters(wfvar_prime);
    Bmat_full_2 = 0.0;
    Amat_2      = 0.0;
    for (int k = 0; k < NumTargets; k++)
    {
      QP.R[k] = P.R[k];
      Amat_2(k, k).diagonal(1.0);
    }
    for (int k = 0; k < bfFuns.size(); k++)
      bfFuns[k]->evaluate(P, QP, Bmat_full_2, Amat_2);
    for (int k = 0; k < NumTargets; k++)
      qp_2[k] = QP.R[k];
    app_log() << "Cmat: \n"
              << "i, AvDiff, max: \n";
    //2011-07-17: what is the proper data type?
    RealType df, av = 0.0, cnt = 0.0;
    RealType maxD = -100.0;
    const RealType ConstOne(1.0);
    for (int k = 0; k < NumTargets; k++)
    {
      for (int q = 0; q < OHMMS_DIM; q++)
      {
        cnt += ConstOne;
        df = (((qp_1[k])[q] - (qp_2[k])[q]) / (2.0 * dh) - Cmat(i, k)[q]);
        av += df;
        if (std::abs(df) > maxD)
          maxD = std::abs(df);
        //app_log() <<k <<"  " <<q <<"   "
        //          <<( (qp_1[k])[q] - (qp_2[k])[0] )/(2.0*dh)   <<"  "
        //          <<Cmat(i,k)[q] <<"  " <<(( (qp_1[k])[q] - (qp_2[k])[q] )/(2.0*dh)-Cmat(i,k)[q]) << std::endl;
      }
    }
    app_log() << i << "  " << av / cnt << "  " << maxD << std::endl;
    av = cnt = maxD = 0.0;
    app_log() << "Ymat: \n";
    for (int k = 0; k < NumTargets; k++)
    {
      for (int q = 0; q < 3; q++)
      {
        RealType dB = 0.0;
        for (int j = 0; j < NumTargets; j++)
          dB += (Bmat_full_1(j, k)[q] - Bmat_full_2(j, k)[q]);
        cnt += ConstOne;
        df = (dB / (2.0 * dh) - Ymat(i, k)[q]);
        av += df;
        if (std::abs(df) > maxD)
          maxD = std::abs(df);
        //app_log() <<k <<"  " <<q <<"   "
        //        <<dB/(2.0*dh)   <<"  "
        //        <<Ymat(i,k)[q] <<"  " <<(dB/(2.0*dh)-Ymat(i,k)[q]) << std::endl;
      }
    }
    app_log() << i << "  " << av / cnt << "  " << maxD << std::endl;
    av = cnt = maxD = 0.0;
    app_log() << "Xmat: \n";
    for (int k1 = 0; k1 < NumTargets; k1++)
      for (int k2 = 0; k2 < NumTargets; k2++)
      {
        for (int q1 = 0; q1 < 3; q1++)
        {
          for (int q2 = 0; q2 < 3; q2++)
          {
            RealType dB = (Amat_1(k1, k2))(q1, q2) - (Amat_2(k1, k2))(q1, q2);
            cnt += ConstOne;
            df = (dB / (2.0 * dh) - (Xmat(i, k1, k2))(q1, q2));
            av += df;
            if (std::abs(df) > maxD)
              maxD = std::abs(df);
            //app_log() <<k1 <<"  " <<k2 <<"  " <<q1 <<"  " <<q2 <<"   "
            //        <<(Xmat(i,k1,k2))(q1,q2) <<"  " <<(dB/(2.0*dh)-(Xmat(i,k1,k2))(q1,q2)) << std::endl;
          }
        }
      }
    app_log() << i << "  " << av / cnt << "  " << maxD << std::endl;
    av = cnt = maxD = 0.0;
  }
}

testPbyP()

void testPbyP

(

ParticleSet &

P

)

Definition at line 549 of file BackflowTransformation.cpp.

References BackflowTransformation::acceptMove(), ParticleSet::acceptMove(), BackflowTransformation::Amat, APP_ABORT, qmcplusplus::app_log(), PooledMemory< T_scalar, Alloc >::current(), BackflowTransformation::cutOff, qmcplusplus::Dot(), BackflowTransformation::evaluate(), BackflowTransformation::evaluatePbyPWithGrad(), ParticleSet::getDistTableAA(), BackflowTransformation::indexQP, ParticleSet::makeMove(), BackflowTransformation::myTableIndex_, BackflowTransformation::NumTargets, OHMMS_DIM, BackflowTransformation::QP, ParticleSet::R, BackflowTransformation::registerData(), Matrix< T, Alloc >::resize(), Vector< T, Alloc >::resize(), PooledMemory< T_scalar, Alloc >::rewind(), ParticleSet::update(), and BackflowTransformation::updateBuffer().

{
  GradMatrix Bmat_full_0;
  HessMatrix Amat_0;
  GradMatrix Bmat_full_1;
  HessMatrix Amat_1;
  ParticleSet::ParticlePos qp_0;
  ParticleSet::ParticlePos qp_1;
  ParticleSet::ParticlePos qp_2, qp_3;
  qp_0.resize(NumTargets);
  qp_1.resize(NumTargets);
  qp_2.resize(NumTargets);
  qp_3.resize(NumTargets);
  Bmat_full_0.resize(NumTargets, NumTargets);
  Bmat_full_1.resize(NumTargets, NumTargets);
  Amat_0.resize(NumTargets, NumTargets);
  Amat_1.resize(NumTargets, NumTargets);
  P.update();
  WFBufferType tbuffer;
  size_t BufferCursor = tbuffer.current();
  registerData(P, tbuffer);
  tbuffer.rewind(BufferCursor);
  updateBuffer(P, tbuffer, true);
  qp_3 = P.R;
  evaluate(P);
  qp_2 = QP.R;
  app_log() << "after 1st eval: " << cutOff << std::endl;
  for (int jat = 0; jat < NumTargets; jat++)
    app_log() << jat << "  " << P.R[jat] - QP.R[jat] << std::endl;
  //for(int  iat=0; iat<NumTargets; iat++) {
  for (int iat = 0; iat < 1; iat++)
  {
    PosType dr;
    dr[0] = 0.1;
    dr[1] = 0.05;
    dr[2] = -0.3;
    P.makeMove(iat, dr);
    const auto& myTable = P.getDistTableAA(myTableIndex_);

    //app_log() << "Move: " << myTable.Temp[iat].dr1 << std::endl;
    //app_log() << "cutOff: " << cutOff << std::endl;
    //for (int jat = 0; jat < NumTargets; jat++)
    //  app_log() << jat << "  " << myTable.Temp[jat].r1 << std::endl;

    //evaluatePbyP(P,iat);
    evaluatePbyPWithGrad(P, iat);
    app_log() << "Moving: ";
    for (int i = 0; i < indexQP.size(); i++)
      app_log() << indexQP[i] << " ";
    app_log() << std::endl;
    acceptMove(P, iat);
    P.acceptMove(iat);
  }
  qp_0   = QP.R;
  Amat_0 = Amat;
  tbuffer.rewind(BufferCursor);
  updateBuffer(P, tbuffer, false);
  P.update();
  evaluate(P);
  Amat_1          = Amat_0 - Amat;
  qp_1            = QP.R - qp_0;
  RealType qpdiff = Dot(qp_1, qp_1);
  RealType Amdiff = 0.0;
  for (int i = 0; i < NumTargets; i++)
    for (int k = 0; k < NumTargets; k++)
      for (int j = 0; j < OHMMS_DIM * OHMMS_DIM; j++)
        Amdiff += Amat_1(i, k)[j] * Amat_1(i, k)[j];
  app_log() << "Error in pbyp QP transformation: " << qpdiff << std::endl;
  app_log() << "Error in pbyp QP Amat: " << Amdiff << std::endl;
  app_log() << "i, diff, newPbyP, newEval: \n";
  for (int i = 0; i < NumTargets; i++)
    app_log() << i << "\n" << qp_0[i] - QP.R[i] << "\n" << qp_0[i] << "\n" << QP.R[i] << std::endl << std::endl;
  APP_ABORT("Finished BackflowTransformation::testPbyP() \n.");
}

transformOnly()

void transformOnly

(

const ParticleSet &

P

)

calculate quasi-particle coordinates only

Definition at line 189 of file BackflowTransformation.cpp.

References BackflowTransformation::bfFuns, BackflowTransformation::evaluate(), qmcplusplus::for(), BackflowTransformation::NumTargets, BackflowTransformation::QP, ParticleSet::R, and ParticleSet::update().

{
  for (int i = 0; i < NumTargets; i++)
    QP.R[i] = P.R[i];
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->evaluate(P, QP);
  QP.update(0); // update distance tables
}

updateBuffer()

void updateBuffer	(	ParticleSet &	P,
		WFBufferType &	buf,
		bool	redo
	)

Definition at line 162 of file BackflowTransformation.cpp.

References BackflowTransformation::bfFuns, BackflowTransformation::evaluate(), BackflowTransformation::FirstOfA, BackflowTransformation::FirstOfB, BackflowTransformation::FirstOfP, BackflowTransformation::LastOfA, BackflowTransformation::LastOfB, BackflowTransformation::LastOfP, BackflowTransformation::NumTargets, PooledMemory< T_scalar, Alloc >::put(), BackflowTransformation::QP, ParticleSet::R, and BackflowTransformation::storeQP.

Referenced by BackflowTransformation::testPbyP().

{
  //if(redo) evaluate(P);
  evaluate(P);
  for (int i = 0; i < NumTargets; i++)
    storeQP[i] = QP.R[i];
  buf.put(FirstOfP, LastOfP);
  buf.put(FirstOfA, LastOfA);
  buf.put(FirstOfB, LastOfB);
  for (int i = 0; i < bfFuns.size(); i++)
    bfFuns[i]->updateBuffer(buf);
}

Member Data Documentation

activeParticle

int activeParticle

active particle in pbyp moves

Definition at line 62 of file BackflowTransformation.h.

Referenced by BackflowTransformation::evaluatePbyP(), BackflowTransformation::evaluatePbyPAll(), and BackflowTransformation::evaluatePbyPWithGrad().

Amat

HessMatrix Amat

Definition at line 106 of file BackflowTransformation.h.

Referenced by BackflowTransformation::BackflowTransformation(), DiracDeterminantWithBackflow::dummyEvalLi(), DiracDeterminantWithBackflow::evalGrad(), BackflowTransformation::evaluate(), DiracDeterminantWithBackflow::evaluateDerivatives(), BackflowTransformation::evaluateDerivatives(), DiracDeterminantWithBackflow::evaluateLog(), BackflowTransformation::registerData(), BackflowTransformation::testDeriv(), DiracDeterminantWithBackflow::testL(), and BackflowTransformation::testPbyP().

Amat_temp

HessMatrix Amat_temp

Definition at line 106 of file BackflowTransformation.h.

Referenced by BackflowTransformation::evaluatePbyPAll(), BackflowTransformation::evaluatePbyPWithGrad(), DiracDeterminantWithBackflow::ratioGrad(), and BackflowTransformation::registerData().

bfFuns

std::vector<std::unique_ptr<BackflowFunctionBase> > bfFuns

Definition at line 128 of file BackflowTransformation.h.

Referenced by BackflowTransformation::acceptMove(), BackflowTransformation::checkInVariables(), BackflowTransformation::checkOutVariables(), BackflowTransformation::copyFrom(), BackflowTransformation::copyFromBuffer(), BackflowTransformation::evaluate(), BackflowTransformation::evaluateBmatOnly(), BackflowTransformation::evaluateDerivatives(), BackflowTransformation::evaluatePbyP(), BackflowTransformation::evaluatePbyPAll(), BackflowTransformation::evaluatePbyPWithGrad(), BackflowTransformation::isOptimizable(), BackflowTransformation::registerData(), BackflowTransformation::reportStatus(), BackflowTransformation::resetParameters(), BackflowTransformation::restore(), BackflowTransformation::testDeriv(), BackflowTransformation::transformOnly(), and BackflowTransformation::updateBuffer().

Bmat

GradVector Bmat

Definition at line 97 of file BackflowTransformation.h.

Referenced by BackflowTransformation::BackflowTransformation(), BackflowTransformation::evaluate(), BackflowTransformation::evaluateDerivatives(), and BackflowTransformation::testDeriv().

Bmat_full

GradMatrix Bmat_full

Definition at line 99 of file BackflowTransformation.h.

Referenced by BackflowTransformation::BackflowTransformation(), DiracDeterminantWithBackflow::dummyEvalLi(), BackflowTransformation::evaluate(), BackflowTransformation::evaluateBmatOnly(), DiracDeterminantWithBackflow::evaluateDerivatives(), BackflowTransformation::evaluateDerivatives(), DiracDeterminantWithBackflow::evaluateLog(), BackflowTransformation::registerData(), BackflowTransformation::testDeriv(), and DiracDeterminantWithBackflow::testL().

Bmat_temp

GradMatrix Bmat_temp

Definition at line 99 of file BackflowTransformation.h.

Referenced by BackflowTransformation::evaluatePbyPAll(), and BackflowTransformation::registerData().

Cmat

GradMatrix Cmat

Definition at line 116 of file BackflowTransformation.h.

Referenced by DiracDeterminantWithBackflow::evaluateDerivatives(), BackflowTransformation::evaluateDerivatives(), BackflowTransformation::testDeriv(), and DiracDeterminantWithBackflow::testDerivFjj().

cutOff

RealType cutOff

Definition at line 87 of file BackflowTransformation.h.

Referenced by BackflowTransformation::copyFrom(), and BackflowTransformation::testPbyP().

DummyHess

HessType DummyHess

Definition at line 126 of file BackflowTransformation.h.

Referenced by BackflowTransformation::BackflowTransformation().

FirstOfA

RealType* FirstOfA

Definition at line 119 of file BackflowTransformation.h.

Referenced by BackflowTransformation::acceptMove(), BackflowTransformation::copyFromBuffer(), BackflowTransformation::evaluatePbyPAll(), BackflowTransformation::evaluatePbyPWithGrad(), BackflowTransformation::registerData(), and BackflowTransformation::updateBuffer().

FirstOfA_temp

RealType* FirstOfA_temp

Definition at line 121 of file BackflowTransformation.h.

Referenced by BackflowTransformation::acceptMove(), BackflowTransformation::evaluatePbyPAll(), BackflowTransformation::evaluatePbyPWithGrad(), and BackflowTransformation::registerData().

FirstOfB

RealType* FirstOfB

Definition at line 120 of file BackflowTransformation.h.

Referenced by BackflowTransformation::acceptMove(), BackflowTransformation::copyFromBuffer(), BackflowTransformation::evaluatePbyPAll(), BackflowTransformation::registerData(), and BackflowTransformation::updateBuffer().

FirstOfB_temp

RealType* FirstOfB_temp

Definition at line 122 of file BackflowTransformation.h.

Referenced by BackflowTransformation::acceptMove(), BackflowTransformation::evaluatePbyPAll(), and BackflowTransformation::registerData().

FirstOfP

RealType* FirstOfP

Definition at line 118 of file BackflowTransformation.h.

Referenced by BackflowTransformation::copyFromBuffer(), BackflowTransformation::registerData(), and BackflowTransformation::updateBuffer().

HESS_ID

HessType HESS_ID

Definition at line 125 of file BackflowTransformation.h.

Referenced by BackflowTransformation::BackflowTransformation().

index

std::vector<int> index

Definition at line 141 of file BackflowTransformation.h.

indexQP

std::vector<int> indexQP

store index of qp coordinates that changed during pbyp move

Definition at line 141 of file BackflowTransformation.h.

Referenced by BackflowTransformation::acceptMove(), BackflowTransformation::BackflowTransformation(), BackflowTransformation::evaluatePbyP(), BackflowTransformation::evaluatePbyPAll(), BackflowTransformation::evaluatePbyPWithGrad(), DiracDeterminantWithBackflow::ratio(), DiracDeterminantWithBackflow::ratioGrad(), BackflowTransformation::restore(), and BackflowTransformation::testPbyP().

LastOfA

RealType * LastOfA

Definition at line 119 of file BackflowTransformation.h.

Referenced by BackflowTransformation::copyFromBuffer(), BackflowTransformation::evaluatePbyPAll(), BackflowTransformation::evaluatePbyPWithGrad(), BackflowTransformation::registerData(), and BackflowTransformation::updateBuffer().

LastOfA_temp

RealType * LastOfA_temp

Definition at line 121 of file BackflowTransformation.h.

Referenced by BackflowTransformation::acceptMove(), and BackflowTransformation::registerData().

LastOfB

RealType * LastOfB

Definition at line 120 of file BackflowTransformation.h.

Referenced by BackflowTransformation::copyFromBuffer(), BackflowTransformation::evaluatePbyPAll(), BackflowTransformation::registerData(), and BackflowTransformation::updateBuffer().

LastOfB_temp

RealType * LastOfB_temp

Definition at line 122 of file BackflowTransformation.h.

Referenced by BackflowTransformation::acceptMove(), and BackflowTransformation::registerData().

LastOfP

RealType * LastOfP

Definition at line 118 of file BackflowTransformation.h.

Referenced by BackflowTransformation::copyFromBuffer(), BackflowTransformation::registerData(), and BackflowTransformation::updateBuffer().

myTableIndex_

const int myTableIndex_

Distance Table.

Definition at line 93 of file BackflowTransformation.h.

Referenced by BackflowTransformation::evaluatePbyP(), BackflowTransformation::evaluatePbyPAll(), BackflowTransformation::evaluatePbyPWithGrad(), and BackflowTransformation::testPbyP().

myVars

opt_variables_type myVars

Definition at line 143 of file BackflowTransformation.h.

names

std::vector<std::string> names

Definition at line 131 of file BackflowTransformation.h.

newQP

ParticleSet::ParticlePos newQP

new qp coordinates for pbyp moves.

Definition at line 134 of file BackflowTransformation.h.

Referenced by BackflowTransformation::acceptMove(), BackflowTransformation::BackflowTransformation(), BackflowTransformation::evaluatePbyP(), BackflowTransformation::evaluatePbyPAll(), BackflowTransformation::evaluatePbyPWithGrad(), DiracDeterminantWithBackflow::ratio(), and DiracDeterminantWithBackflow::ratioGrad().

numParams

int numParams

Definition at line 68 of file BackflowTransformation.h.

Referenced by BackflowTransformation::copyFrom(), BackflowTransformation::evaluateDerivatives(), and BackflowTransformation::testDeriv().

NumTargets

int NumTargets

number of quantum particles

Definition at line 59 of file BackflowTransformation.h.

Referenced by BackflowTransformation::acceptMove(), BackflowTransformation::BackflowTransformation(), BackflowTransformation::copyFromBuffer(), BackflowTransformation::evaluate(), BackflowTransformation::evaluateDerivatives(), BackflowTransformation::evaluatePbyP(), BackflowTransformation::evaluatePbyPAll(), BackflowTransformation::evaluatePbyPWithGrad(), BackflowTransformation::registerData(), BackflowTransformation::testDeriv(), BackflowTransformation::testPbyP(), BackflowTransformation::transformOnly(), and BackflowTransformation::updateBuffer().

numVarBefore

int numVarBefore

Definition at line 90 of file BackflowTransformation.h.

Referenced by BackflowTransformation::BackflowTransformation(), BackflowTransformation::copyFrom(), and BackflowTransformation::evaluateDerivatives().

oldQP

ParticleSet::ParticlePos oldQP

Definition at line 135 of file BackflowTransformation.h.

Referenced by BackflowTransformation::BackflowTransformation(), BackflowTransformation::evaluatePbyP(), BackflowTransformation::evaluatePbyPAll(), and BackflowTransformation::evaluatePbyPWithGrad().

optIndexMap

std::map<int, int> optIndexMap

Definition at line 84 of file BackflowTransformation.h.

Referenced by BackflowTransformation::copyFrom(), DiracDeterminantWithBackflow::evaluateDerivatives(), and BackflowTransformation::evaluateDerivatives().

QP

ParticleSet QP

quasiparticle coordinates

Definition at line 65 of file BackflowTransformation.h.

Referenced by BackflowTransformation::acceptMove(), BackflowTransformation::copyFromBuffer(), DiracDeterminantWithBackflow::DiracDeterminantWithBackflow(), DiracDeterminantWithBackflow::dummyEvalLi(), BackflowTransformation::evaluate(), DiracDeterminantWithBackflow::evaluate_SPO(), BackflowTransformation::evaluateDerivatives(), BackflowTransformation::evaluatePbyP(), BackflowTransformation::evaluatePbyPAll(), BackflowTransformation::evaluatePbyPWithGrad(), DiracDeterminantWithBackflow::ratio(), DiracDeterminantWithBackflow::ratioGrad(), BackflowTransformation::registerData(), BackflowTransformation::testDeriv(), DiracDeterminantWithBackflow::testGG(), DiracDeterminantWithBackflow::testGGG(), BackflowTransformation::testPbyP(), BackflowTransformation::transformOnly(), and BackflowTransformation::updateBuffer().

sources

std::map<std::string, int> sources

Definition at line 130 of file BackflowTransformation.h.

storeQP

Vector<PosType> storeQP

Definition at line 138 of file BackflowTransformation.h.

Referenced by BackflowTransformation::copyFromBuffer(), BackflowTransformation::registerData(), and BackflowTransformation::updateBuffer().

UpdateMode

int UpdateMode

current update mode

Definition at line 71 of file BackflowTransformation.h.

Referenced by BackflowTransformation::acceptMove(), BackflowTransformation::evaluatePbyP(), BackflowTransformation::evaluatePbyPAll(), BackflowTransformation::evaluatePbyPWithGrad(), and BackflowTransformation::restore().

Xmat

HessArray Xmat

Definition at line 110 of file BackflowTransformation.h.

Referenced by DiracDeterminantWithBackflow::evaluateDerivatives(), BackflowTransformation::evaluateDerivatives(), and BackflowTransformation::testDeriv().

Ymat

GradMatrix Ymat

Definition at line 113 of file BackflowTransformation.h.

Referenced by DiracDeterminantWithBackflow::evaluateDerivatives(), BackflowTransformation::evaluateDerivatives(), and BackflowTransformation::testDeriv().

---

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

• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCWaveFunctions/Fermion/BackflowTransformation.h
• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCWaveFunctions/Fermion/BackflowTransformation.cpp