CountingGaussian Class Reference

Collaboration diagram for CountingGaussian:

Public Member Functions
	CountingGaussian (std::string fid)
	CountingGaussian (std::string fid, RealType alpha, PosType r, bool opt)
void	initialize (CountingGaussian *ref)
void	restore (int iat)
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)
std::unique_ptr< CountingGaussian >	makeClone (std::string fid) const
void	triang_to_matrix (const std::array< RealType, 6 > &triang, TensorType &matrix)
void	d_to_b (const PosType &d, const TensorType &a, PosType &b)
void	k_to_c (const RealType &k, const TensorType &a, const PosType &d, RealType &c)
bool	put (xmlNodePtr cur)
void	divide_eq (const CountingGaussian *rhs)
void	evaluate (PosType r, RealType &fval, GradType &fgrad, RealType &flap)
void	evaluateLog (PosType r, RealType &lval, GradType &lgrad, RealType &llap)
void	evaluateDerivative_A (A_vars q, PosType r, RealType &dfval, GradType &dfgrad, RealType &dflap)
void	evaluateDerivative_B (B_vars q, PosType r, RealType &dfval, GradType &dfgrad, RealType &dflap)
void	evaluateDerivatives (PosType r, std::vector< RealType > &dfval, std::vector< GradType > &dfgrad, std::vector< RealType > &dflap)
void	evaluateLogDerivatives (PosType r, std::vector< RealType > &dlval, std::vector< GradType > &dlgrad, std::vector< RealType > &dllap)
void	evaluateLogTempDerivatives (PosType r, std::vector< RealType > &dlval)
void	evaluate_print (std::ostream &os, const ParticleSet &P)

Public Attributes
TensorType	A
PosType	B
RealType	C
opt_variables_type	myVars

Private Types
enum	A_vars {   XX, XY, XZ, YY,   YZ, ZZ, NUM_A }
enum	B_vars { X, Y, Z, DIM }
using	RealType = QMCTraits::RealType
using	PosType = QMCTraits::PosType
using	GradType = QMCTraits::PosType
using	TensorType = QMCTraits::TensorType
using	real_type = optimize::VariableSet::real_type
using	opt_variables_type = optimize::VariableSet

Private Attributes
std::vector< bool >	opt_A
std::vector< bool >	opt_B
bool	opt_C
std::string	id
CountingGaussian *	gref = NULL
RealType	Fval
GradType	Fgrad
RealType	Flap

Detailed Description

Definition at line 23 of file CountingGaussian.h.

Member Typedef Documentation

GradType

using GradType = QMCTraits::PosType

private

Definition at line 27 of file CountingGaussian.h.

opt_variables_type

using opt_variables_type = optimize::VariableSet

private

Definition at line 31 of file CountingGaussian.h.

PosType

using PosType = QMCTraits::PosType

private

Definition at line 26 of file CountingGaussian.h.

real_type

using real_type = optimize::VariableSet::real_type

private

Definition at line 30 of file CountingGaussian.h.

RealType

using RealType = QMCTraits::RealType

private

Definition at line 25 of file CountingGaussian.h.

TensorType

using TensorType = QMCTraits::TensorType

private

Definition at line 28 of file CountingGaussian.h.

Member Enumeration Documentation

A_vars

enum A_vars

private

Enumerator
XX
XY
XZ
YY
YZ
ZZ
NUM_A

Definition at line 34 of file CountingGaussian.h.

  {
    XX,
    XY,
    XZ,
    YY,
    YZ,
    ZZ,
    NUM_A
  };

B_vars

enum B_vars

private

Enumerator
X
Y
Z
DIM

Definition at line 44 of file CountingGaussian.h.

  {
    X,
    Y,
    Z,
    DIM
  };

Constructor & Destructor Documentation

CountingGaussian() [1/2]

CountingGaussian ( std::string  fid )

inline

Definition at line 77 of file CountingGaussian.h.

{ id = fid; }

CountingGaussian() [2/2]

CountingGaussian ( std::string  fid, RealType  alpha, PosType  r, bool  opt  )

inline

Definition at line 80 of file CountingGaussian.h.

References CountingGaussian::A, CountingGaussian::B, CountingGaussian::C, CountingGaussian::d_to_b(), CountingGaussian::k_to_c(), CountingGaussian::opt_A, CountingGaussian::opt_B, and CountingGaussian::opt_C.

  { 
    id = fid;
    // set opt flags
    opt_A.resize(6);
    opt_B.resize(3);
    for(auto it = opt_A.begin(); it != opt_A.end(); ++it)
      *it = opt;
    for(auto it = opt_B.begin(); it != opt_B.end(); ++it)
      *it = opt;
    opt_C = opt;
    // set A
    A(0,0) = A(1,1) = A(2,2) = -1.0*alpha;
    A(0,1) = A(1,0) = A(0,2) = A(2,0) = A(1,2) = A(2,1) = 0;
    // set B
    d_to_b(r, A, B);
    // set C
    k_to_c(0, A, r, C);
  }

Member Function Documentation

checkInVariables()

void checkInVariables ( opt_variables_type &  active )

inline

Definition at line 131 of file CountingGaussian.h.

References VariableSet::insertFrom(), and CountingGaussian::myVars.

{ active.insertFrom(myVars); }

checkOutVariables()

void checkOutVariables ( const opt_variables_type &  active )

inline

Definition at line 134 of file CountingGaussian.h.

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

{ myVars.getIndex(active); }

d_to_b()

void d_to_b ( const PosType &  d, const TensorType &  a, PosType &  b  )

inline

Definition at line 256 of file CountingGaussian.h.

References qmcplusplus::dot().

Referenced by CountingGaussian::CountingGaussian(), and CountingGaussian::put().

{ b = dot(a, d); }

divide_eq()

void divide_eq ( const CountingGaussian *  rhs )

inline

Definition at line 352 of file CountingGaussian.h.

References CountingGaussian::A, CountingGaussian::B, and CountingGaussian::C.

Referenced by CountingGaussian::initialize(), and CountingGaussian::resetParameters().

  {
    A = A - rhs->A;
    B = B - rhs->B;
    C = C - rhs->C;
  }

evaluate()

void evaluate ( PosType  r, RealType &  fval, GradType &  fgrad, RealType &  flap  )

inline

Definition at line 361 of file CountingGaussian.h.

References CountingGaussian::A, CountingGaussian::B, CountingGaussian::C, qmcplusplus::dot(), qmcplusplus::exp(), and qmcplusplus::trace().

Referenced by CountingGaussian::evaluateDerivatives(), and qmcplusplus::TEST_CASE().

  {
    PosType Ar = dot(A, r);
    RealType x = dot(Ar - 2 * B, r) + C;
    fval       = std::exp(x);
    fgrad      = 2 * (Ar - B) * fval;
    flap       = 4 * dot(Ar - B, Ar - B) * fval + 2 * trace(A) * fval;
  }

evaluate_print()

void evaluate_print ( std::ostream &  os, const ParticleSet &  P  )

inline

Definition at line 648 of file CountingGaussian.h.

References CountingGaussian::A, CountingGaussian::B, CountingGaussian::C, copy(), qmcplusplus::dot(), qmcplusplus::exp(), ParticleSet::R, and qmcplusplus::trace().

  {
    // calculate all intermediates and values for electrons in a particle set
    std::vector<PosType> r_vec;
    std::vector<PosType> Ar_vec;
    std::vector<RealType> x_vec;
    std::vector<RealType> fval_vec;
    std::vector<GradType> fgrad_vec;
    std::vector<RealType> flap_vec;
    RealType x, fval, flap;
    PosType Ar, r;
    GradType fgrad;
    for (auto it = P.R.begin(); it != P.R.end(); ++it)
    {
      r     = *it;
      Ar    = dot(A, r);
      x     = dot(Ar - 2 * B, r) + C;
      fval  = std::exp(x);
      fgrad = 2 * (Ar - B) * fval;
      flap  = 4 * dot(Ar - B, Ar - B) * fval + 2 * trace(A) * fval;

      r_vec.push_back(r);
      Ar_vec.push_back(Ar);
      x_vec.push_back(x);
      fval_vec.push_back(fval);
      fgrad_vec.push_back(fgrad);
      flap_vec.push_back(flap);
    }
    os << "CountingGaussian::evaluate_print: id: " << id << std::endl;
    os << "r: ";
    std::copy(r_vec.begin(), r_vec.end(), std::ostream_iterator<PosType>(os, ", "));
    os << std::endl << "Ar: ";
    std::copy(Ar_vec.begin(), Ar_vec.end(), std::ostream_iterator<PosType>(os, ", "));
    os << std::endl << "x: ";
    std::copy(x_vec.begin(), x_vec.end(), std::ostream_iterator<RealType>(os, ", "));
    os << std::endl << "fval: ";
    std::copy(fval_vec.begin(), fval_vec.end(), std::ostream_iterator<RealType>(os, ", "));
    os << std::endl << "fgrad: ";
    std::copy(fgrad_vec.begin(), fgrad_vec.end(), std::ostream_iterator<GradType>(os, ", "));
    os << std::endl << "flap: ";
    std::copy(flap_vec.begin(), flap_vec.end(), std::ostream_iterator<RealType>(os, ", "));
    os << std::endl;
  }

evaluateDerivative_A()

void evaluateDerivative_A ( A_vars  q, PosType  r, RealType &  dfval, GradType &  dfgrad, RealType &  dflap  )

inline

Definition at line 378 of file CountingGaussian.h.

References qmcplusplus::dot(), CountingGaussian::Fgrad, CountingGaussian::Flap, CountingGaussian::Fval, CountingGaussian::X, CountingGaussian::XX, CountingGaussian::XY, CountingGaussian::XZ, CountingGaussian::Y, CountingGaussian::YY, CountingGaussian::YZ, CountingGaussian::Z, and CountingGaussian::ZZ.

Referenced by CountingGaussian::evaluateDerivatives().

  {
    // Fval, Fgrad, Flap are up-to-date function values
    // x correponds to the exponent value: x = ln f; dx are param derivs
    RealType dxval = 0, dxlap = 0;
    GradType dxgrad = 0;
    if (q == XX)
    {
      dxval  = r[X] * r[X];
      dxgrad = GradType(2 * r[X], 0, 0);
      dxlap  = 2;
    }
    if (q == YY)
    {
      dxval  = r[Y] * r[Y];
      dxgrad = GradType(0, 2 * r[Y], 0);
      dxlap  = 2;
    }
    if (q == ZZ)
    {
      dxval  = r[Z] * r[Z];
      dxgrad = GradType(0, 0, 2 * r[Z]);
      dxlap  = 2;
    }
    // off-diagonal terms: factor of two is since A is symmetric
    if (q == XY)
    {
      dxval  = 2 * r[X] * r[Y];
      dxgrad = 2 * GradType(r[Y], r[X], 0);
      dxlap  = 0;
    }
    if (q == XZ)
    {
      dxval  = 2 * r[X] * r[Z];
      dxgrad = 2 * GradType(r[Z], 0, r[X]);
      dxlap  = 0;
    }
    if (q == YZ)
    {
      dxval  = 2 * r[Y] * r[Z];
      dxgrad = 2 * GradType(0, r[Z], r[Y]);
      dxlap  = 0;
    }
    dfval  = Fval * dxval;
    dfgrad = Fgrad * dxval + Fval * dxgrad;
    dflap  = Flap * dxval + 2 * dot(Fgrad, dxgrad) + dxlap * Fval;
  }

evaluateDerivative_B()

void evaluateDerivative_B ( B_vars  q, PosType  r, RealType &  dfval, GradType &  dfgrad, RealType &  dflap  )

inline

Definition at line 426 of file CountingGaussian.h.

References qmcplusplus::dot(), CountingGaussian::Fgrad, CountingGaussian::Flap, CountingGaussian::Fval, CountingGaussian::X, CountingGaussian::Y, and CountingGaussian::Z.

Referenced by CountingGaussian::evaluateDerivatives().

  {
    RealType dxval = 0, dxlap = 0;
    GradType dxgrad = 0;
    if (q == X)
    {
      dxval  = -2 * r[X];
      dxgrad = -2 * GradType(1, 0, 0);
      dxlap  = 0;
    }
    if (q == Y)
    {
      dxval  = -2 * r[Y];
      dxgrad = -2 * GradType(0, 1, 0);
      dxlap  = 0;
    }
    if (q == Z)
    {
      dxval  = -2 * r[Z];
      dxgrad = -2 * GradType(0, 0, 1);
      dxlap  = 0;
    }
    dfval  = Fval * dxval;
    dfgrad = Fgrad * dxval + Fval * dxgrad;
    dflap  = Flap * dxval + 2 * dot(Fgrad, dxgrad) + dxlap * Fval;
  }

evaluateDerivatives()

void evaluateDerivatives ( PosType  r, std::vector< RealType > &  dfval, std::vector< GradType > &  dfgrad, std::vector< RealType > &  dflap  )

inline

Definition at line 453 of file CountingGaussian.h.

References CountingGaussian::evaluate(), CountingGaussian::evaluateDerivative_A(), CountingGaussian::evaluateDerivative_B(), CountingGaussian::Fgrad, CountingGaussian::Flap, CountingGaussian::Fval, CountingGaussian::opt_A, CountingGaussian::opt_B, CountingGaussian::opt_C, CountingGaussian::X, CountingGaussian::XX, CountingGaussian::XY, CountingGaussian::XZ, CountingGaussian::Y, CountingGaussian::YY, CountingGaussian::YZ, CountingGaussian::Z, and CountingGaussian::ZZ.

Referenced by qmcplusplus::TEST_CASE().

  {
    evaluate(r, Fval, Fgrad, Flap);
    int p = 0;
    if (opt_A[XX])
    {
      evaluateDerivative_A(XX, r, dfval[p], dfgrad[p], dflap[p]);
      ++p;
    }
    if (opt_A[XY])
    {
      evaluateDerivative_A(XY, r, dfval[p], dfgrad[p], dflap[p]);
      ++p;
    }
    if (opt_A[XZ])
    {
      evaluateDerivative_A(XZ, r, dfval[p], dfgrad[p], dflap[p]);
      ++p;
    }
    if (opt_A[YY])
    {
      evaluateDerivative_A(YY, r, dfval[p], dfgrad[p], dflap[p]);
      ++p;
    }
    if (opt_A[YZ])
    {
      evaluateDerivative_A(YZ, r, dfval[p], dfgrad[p], dflap[p]);
      ++p;
    }
    if (opt_A[ZZ])
    {
      evaluateDerivative_A(ZZ, r, dfval[p], dfgrad[p], dflap[p]);
      ++p;
    }
    if (opt_B[X])
    {
      evaluateDerivative_B(X, r, dfval[p], dfgrad[p], dflap[p]);
      ++p;
    }
    if (opt_B[Y])
    {
      evaluateDerivative_B(Y, r, dfval[p], dfgrad[p], dflap[p]);
      ++p;
    }
    if (opt_B[Z])
    {
      evaluateDerivative_B(Z, r, dfval[p], dfgrad[p], dflap[p]);
      ++p;
    }
    if (opt_C)
    {
      dfval[p]  = Fval;
      dfgrad[p] = Fgrad;
      dflap[p]  = Flap;
      ++p;
    }
  }

evaluateLog()

void evaluateLog ( PosType  r, RealType &  lval, GradType &  lgrad, RealType &  llap  )

inline

Definition at line 370 of file CountingGaussian.h.

References CountingGaussian::A, CountingGaussian::B, CountingGaussian::C, qmcplusplus::dot(), and qmcplusplus::trace().

Referenced by qmcplusplus::TEST_CASE().

  {
    PosType Ar = dot(A, r);
    lval       = dot(Ar - 2 * B, r) + C;
    lgrad      = 2 * (Ar - B);
    llap       = 2 * trace(A);
  }

evaluateLogDerivatives()

void evaluateLogDerivatives ( PosType  r, std::vector< RealType > &  dlval, std::vector< GradType > &  dlgrad, std::vector< RealType > &  dllap  )

inline

Definition at line 515 of file CountingGaussian.h.

References CountingGaussian::opt_A, CountingGaussian::opt_B, CountingGaussian::opt_C, CountingGaussian::X, CountingGaussian::XX, CountingGaussian::XY, CountingGaussian::XZ, CountingGaussian::Y, CountingGaussian::YY, CountingGaussian::YZ, CountingGaussian::Z, and CountingGaussian::ZZ.

Referenced by qmcplusplus::TEST_CASE().

  {
    int p = 0;
    if (opt_A[XX])
    {
      dlval[p]  = r[X] * r[X];
      dlgrad[p] = 2 * GradType(r[X], 0, 0);
      dllap[p]  = 2;
      ++p;
    }
    if (opt_A[XY])
    {
      dlval[p]  = 2 * r[X] * r[Y];
      dlgrad[p] = 2 * GradType(r[Y], r[X], 0);
      dllap[p]  = 0;
      ++p;
    }
    if (opt_A[XZ])
    {
      dlval[p]  = 2 * r[X] * r[Z];
      dlgrad[p] = 2 * GradType(r[Z], 0, r[X]);
      dllap[p]  = 0;
      ++p;
    }
    if (opt_A[YY])
    {
      dlval[p]  = r[Y] * r[Y];
      dlgrad[p] = 2 * GradType(0, r[Y], 0);
      dllap[p]  = 2;
      ++p;
    }
    if (opt_A[YZ])
    {
      dlval[p]  = 2 * r[Y] * r[Z];
      dlgrad[p] = 2 * GradType(0, r[Z], r[Y]);
      dllap[p]  = 0;
      ++p;
    }
    if (opt_A[ZZ])
    {
      dlval[p]  = r[Z] * r[Z];
      dlgrad[p] = 2 * GradType(0, 0, r[Z]);
      dllap[p]  = 2;
      ++p;
    }
    if (opt_B[X])
    {
      dlval[p]  = -2 * r[X];
      dlgrad[p] = -2 * GradType(1, 0, 0);
      dllap[p]  = 0;
      ++p;
    }
    if (opt_B[Y])
    {
      dlval[p]  = -2 * r[Y];
      dlgrad[p] = -2 * GradType(0, 1, 0);
      dllap[p]  = 0;
      ++p;
    }
    if (opt_B[Z])
    {
      dlval[p]  = -2 * r[Z];
      dlgrad[p] = -2 * GradType(0, 0, 1);
      dllap[p]  = 0;
      ++p;
    }
    if (opt_C)
    {
      dlval[p]  = 1;
      dlgrad[p] = 0;
      dllap[p]  = 0;
      ++p;
    }
  }

evaluateLogTempDerivatives()

void evaluateLogTempDerivatives ( PosType  r, std::vector< RealType > &  dlval  )

inline

Definition at line 593 of file CountingGaussian.h.

References CountingGaussian::opt_A, CountingGaussian::opt_B, CountingGaussian::opt_C, CountingGaussian::X, CountingGaussian::XX, CountingGaussian::XY, CountingGaussian::XZ, CountingGaussian::Y, CountingGaussian::YY, CountingGaussian::YZ, CountingGaussian::Z, and CountingGaussian::ZZ.

  {
    int p = 0;
    if (opt_A[XX])
    {
      dlval[p] = r[X] * r[X];
      ++p;
    }
    if (opt_A[XY])
    {
      dlval[p] = 2 * r[X] * r[Y];
      ++p;
    }
    if (opt_A[XZ])
    {
      dlval[p] = 2 * r[X] * r[Z];
      ++p;
    }
    if (opt_A[YY])
    {
      dlval[p] = r[Y] * r[Y];
      ++p;
    }
    if (opt_A[YZ])
    {
      dlval[p] = 2 * r[Y] * r[Z];
      ++p;
    }
    if (opt_A[ZZ])
    {
      dlval[p] = r[Z] * r[Z];
      ++p;
    }
    if (opt_B[X])
    {
      dlval[p] = -2 * r[X];
      ++p;
    }
    if (opt_B[Y])
    {
      dlval[p] = -2 * r[Y];
      ++p;
    }
    if (opt_B[Z])
    {
      dlval[p] = -2 * r[Z];
      ++p;
    }
    if (opt_C)
    {
      dlval[p] = 1;
      ++p;
    }
  }

initialize()

void initialize ( CountingGaussian *  ref )

inline

Definition at line 101 of file CountingGaussian.h.

References CountingGaussian::A, CountingGaussian::B, CountingGaussian::C, CountingGaussian::divide_eq(), CountingGaussian::gref, VariableSet::insert(), CountingGaussian::myVars, CountingGaussian::opt_A, CountingGaussian::opt_B, CountingGaussian::opt_C, optimize::OTHER_P, CountingGaussian::X, CountingGaussian::XX, CountingGaussian::XY, CountingGaussian::XZ, CountingGaussian::Y, CountingGaussian::YY, CountingGaussian::YZ, CountingGaussian::Z, and CountingGaussian::ZZ.

  {
    // register and update optimizable variables to current values
    myVars.insert(id + "_A_xx", A(X, X), opt_A[XX], optimize::OTHER_P);
    myVars[id + "_A_xx"] = A(X, X);
    myVars.insert(id + "_A_xy", A(X, Y), opt_A[XY], optimize::OTHER_P);
    myVars[id + "_A_xy"] = A(X, Y);
    myVars.insert(id + "_A_xz", A(X, Z), opt_A[XZ], optimize::OTHER_P);
    myVars[id + "_A_xz"] = A(X, Z);
    myVars.insert(id + "_A_yy", A(Y, Y), opt_A[YY], optimize::OTHER_P);
    myVars[id + "_A_yy"] = A(Y, Y);
    myVars.insert(id + "_A_yz", A(Y, Z), opt_A[YZ], optimize::OTHER_P);
    myVars[id + "_A_yz"] = A(Y, Z);
    myVars.insert(id + "_A_zz", A(Z, Z), opt_A[ZZ], optimize::OTHER_P);
    myVars[id + "_A_zz"] = A(Z, Z);
    myVars.insert(id + "_B_x", B[X], opt_B[X], optimize::OTHER_P);
    myVars[id + "_B_x"] = B[X];
    myVars.insert(id + "_B_y", B[Y], opt_B[Y], optimize::OTHER_P);
    myVars[id + "_B_y"] = B[Y];
    myVars.insert(id + "_B_z", B[Z], opt_B[Z], optimize::OTHER_P);
    myVars[id + "_B_z"] = B[Z];
    myVars.insert(id + "_C", C, opt_C, optimize::OTHER_P);
    myVars[id + "_C"] = C;
    // transform according to reference
    if(gref != NULL)
      this->divide_eq(gref);
  }

k_to_c()

void k_to_c ( const RealType &  k, const TensorType &  a, const PosType &  d, RealType &  c  )

inline

Definition at line 258 of file CountingGaussian.h.

References qmcplusplus::dot().

Referenced by CountingGaussian::CountingGaussian(), and CountingGaussian::put().

{ c = k + dot(d, dot(a, d)); }

makeClone()

std::unique_ptr<CountingGaussian> makeClone ( std::string  fid ) const

inline

Definition at line 225 of file CountingGaussian.h.

References CountingGaussian::A, CountingGaussian::B, CountingGaussian::C, qmcplusplus::for(), CountingGaussian::myVars, CountingGaussian::opt_A, CountingGaussian::opt_B, CountingGaussian::opt_C, TinyVector< T, D >::size(), and Tensor< T, D >::size().

  {
    auto rptr = std::make_unique<CountingGaussian>(fid);
    for (int i = 0; i < A.size(); ++i)
      rptr->A[i] = A[i];
    for (int i = 0; i < B.size(); ++i)
      rptr->B[i] = B[i];
    rptr->C = C;
    rptr->opt_A.resize(opt_A.size());
    rptr->opt_B.resize(opt_B.size());
    for (int i = 0; i < opt_A.size(); ++i)
      rptr->opt_A[i] = opt_A[i];
    for (int i = 0; i < opt_B.size(); ++i)
      rptr->opt_B[i] = opt_B[i];
    rptr->opt_C  = opt_C;
    rptr->myVars = myVars;
    return rptr;
  }

put()

bool put ( xmlNodePtr  cur )

inline

Definition at line 260 of file CountingGaussian.h.

References CountingGaussian::A, OhmmsAttributeSet::add(), APP_ABORT, qmcplusplus::app_log(), CountingGaussian::B, TinyVector< T, D >::begin(), CountingGaussian::C, CountingGaussian::d_to_b(), TinyVector< T, D >::end(), qmcplusplus::Units::energy::K, CountingGaussian::k_to_c(), CountingGaussian::opt_A, CountingGaussian::opt_B, CountingGaussian::opt_C, OhmmsAttributeSet::put(), putContent(), and CountingGaussian::triang_to_matrix().

Referenced by qmcplusplus::TEST_CASE().

  {
    //app_log() << "CountingGaussian::put" << std::endl;
    bool put_A = false, put_B = false, put_C = false, put_D = false, put_K = false;
    // alternate inputs
    std::array<RealType, 6> A_triang;
    PosType D  = 0;
    RealType K = 0;
    cur        = cur->xmlChildrenNode;
    while (cur != NULL)
    {
      std::string cname((const char*)(cur->name));
      if (cname == "var")
      {
        std::string opt  = "false";
        std::string name = "none";
        OhmmsAttributeSet rAttrib;
        rAttrib.add(name, "name");
        rAttrib.add(opt, "opt");
        rAttrib.add(opt, "opt_bits");
        rAttrib.put(cur);
        // check if opt is a binary string
        bool is_bitstr = std::all_of(opt.begin(), opt.end(), [&](char c) { return c == '0' || c == '1'; });
        std::transform(opt.begin(), opt.end(), opt.begin(), (int (*)(int))std::tolower);
        std::transform(name.begin(), name.end(), name.begin(), (int (*)(int))std::tolower);
        if (name == "a") // input is the upper-triangle of A
        {
          opt_A.resize(6);
          if (opt.size() == 6 && is_bitstr)
            std::transform(opt.begin(), opt.end(), opt_A.begin(), [&](char c) { return (c == '1'); });
          // default opt = true
          else
            std::fill(opt_A.begin(), opt_A.end(), (opt == "true"));
          put_A = putContent(A_triang.begin(), A_triang.end(), cur);
          // perform conversion
          triang_to_matrix(A_triang, A);
        }
        if (name == "b")
        {
          opt_B.resize(3);
          if (opt.size() == 3 && is_bitstr)
            std::transform(opt.begin(), opt.end(), opt_B.begin(), [&](char c) { return (c == '1'); });
          // default opt = true
          else
            std::fill(opt_B.begin(), opt_B.end(), (opt == "true"));
          put_B = putContent(B.begin(), B.end(), cur);
        }
        if (name == "d")
        {
          opt_B.resize(3);
          if (opt.size() == 3 && is_bitstr)
            std::transform(opt.begin(), opt.end(), opt_B.begin(), [&](char c) { return (c == '1'); });
          else
            std::fill(opt_B.begin(), opt_B.end(), (opt == "true"));
          put_D = putContent(D.begin(), D.end(), cur);
        }
        if (name == "c")
        {
          opt_C = (opt == "true");
          put_C = putContent(C, cur);
        }
        if (name == "k")
        {
          opt_C = (opt == "true");
          put_K = putContent(K, cur);
        }
      }
      cur = cur->next;
    }
    // convert B <=> D
    if (put_B && put_D)
      APP_ABORT("CountingGaussian::put: overdetermined: both B and D are specified");
    if (put_C && put_K)
      APP_ABORT("CountingGaussian::put: overdetermined: both C and K are specified");
    // convert D,B using A
    if (put_D)
      d_to_b(D, A, B);
    if (put_K)
      k_to_c(K, A, D, C);
    // check that we got everything
    if (!(put_A && (put_B || put_D) && (put_C || put_K)))
    {
      std::ostringstream err;
      err << "CountingGaussian::put:  required variable unspecified: ";
      err << "put_A: " << put_A << ", put_B: " << put_B << ", put_C: " << put_C << ", put_D: " << put_D
          << ", put_K: " << put_K << std::endl;
      //      APP_ABORT(err.str());
      app_log() << err.str();
    }
    return true;
  }

reportStatus()

void reportStatus ( std::ostream &  os )

inline

Definition at line 216 of file CountingGaussian.h.

References qmcplusplus::app_log(), CountingGaussian::myVars, and VariableSet::print().

  {
    os << "    type: CountingGaussian" << std::endl;
    os << "    id: " << id << std::endl;
    app_log() << std::endl;
    myVars.print(os, 6, true);
    app_log() << std::endl;
  }

resetParameters()

void resetParameters ( const opt_variables_type &  active )

inline

Definition at line 137 of file CountingGaussian.h.

References CountingGaussian::A, CountingGaussian::B, CountingGaussian::C, CountingGaussian::divide_eq(), VariableSet::getLoc(), CountingGaussian::gref, CountingGaussian::myVars, CountingGaussian::opt_A, CountingGaussian::opt_B, CountingGaussian::opt_C, CountingGaussian::X, CountingGaussian::XX, CountingGaussian::XY, CountingGaussian::XZ, CountingGaussian::Y, CountingGaussian::YY, CountingGaussian::YZ, CountingGaussian::Z, and CountingGaussian::ZZ.

  {
    int ia;
    std::string vid;
    if (opt_A[XX])
    {
      vid = id + "_A_xx";
      ia = active.getLoc(vid);
      myVars[vid] = active[ia];
      A(0, 0) = std::real(myVars[vid]);
    }
    if (opt_A[YY])
    {
      vid = id + "_A_yy";
      ia = active.getLoc(vid);
      myVars[vid] = active[ia];
      A(1, 1) = std::real(myVars[vid]);
    }
    if (opt_A[ZZ])
    {
      vid = id + "_A_zz";
      ia = active.getLoc(vid);
      myVars[vid] = active[ia];
      A(2, 2) = std::real(myVars[vid]);
    }
    if (opt_A[XY])
    {
      vid = id + "_A_xy";
      ia = active.getLoc(vid);
      myVars[vid] = active[ia];
      A(1, 0) = A(0, 1) = std::real(myVars[vid]);
    }
    if (opt_A[XZ])
    {
      vid = id + "_A_xz";
      ia = active.getLoc(vid);
      myVars[vid] = active[ia];
      A(2, 0) = A(0, 2) = std::real(myVars[vid]);
    }
    if (opt_A[YZ])
    {
      vid = id + "_A_yz";
      ia = active.getLoc(vid);
      myVars[vid] = active[ia];
      A(2, 1) = A(1, 2) = std::real(myVars[vid]);
    }
    if (opt_B[X])
    {
      vid = id + "_B_x";
      ia = active.getLoc(vid);
      myVars[vid] = active[ia];
      B[X] = std::real(myVars[vid]);
    }
    if (opt_B[Y])
    {
      vid = id + "_B_y";
      ia = active.getLoc(vid);
      myVars[vid] = active[ia];
      B[Y] = std::real(myVars[vid]);
    }
    if (opt_B[Z])
    {
      vid = id + "_B_z";
      ia = active.getLoc(vid);
      myVars[vid] = active[ia];
      B[Z] = std::real(myVars[vid]);
    }
    if (opt_C)
    {
      vid = id + "_C";
      ia = active.getLoc(vid);
      myVars[vid] = active[ia];
      C = std::real(myVars[vid]);
    }
    // transform according to reference
    if(gref != NULL)
      this->divide_eq(gref);
  }

restore()

void restore ( int  iat )

inline

Definition at line 129 of file CountingGaussian.h.

{}

triang_to_matrix()

void triang_to_matrix ( const std::array< RealType, 6 > &  triang, TensorType &  matrix  )

inline

Definition at line 245 of file CountingGaussian.h.

Referenced by CountingGaussian::put().

  {
    auto it = triang.begin();
    for (int i = 0; i < 3; ++i)
      for (int j = i; j < 3; ++j)
      {
        matrix(i, j) = matrix(j, i) = *it;
        ++it;
      }
  }

Member Data Documentation

A

TensorType A

Definition at line 70 of file CountingGaussian.h.

Referenced by CountingGaussian::CountingGaussian(), CountingGaussian::divide_eq(), CountingGaussian::evaluate(), CountingGaussian::evaluate_print(), CountingGaussian::evaluateLog(), CountingGaussian::initialize(), CountingGaussian::makeClone(), CountingGaussian::put(), and CountingGaussian::resetParameters().

B

PosType B

Definition at line 71 of file CountingGaussian.h.

Referenced by CountingGaussian::CountingGaussian(), CountingGaussian::divide_eq(), CountingGaussian::evaluate(), CountingGaussian::evaluate_print(), CountingGaussian::evaluateLog(), CountingGaussian::initialize(), CountingGaussian::makeClone(), CountingGaussian::put(), and CountingGaussian::resetParameters().

C

RealType C

Definition at line 72 of file CountingGaussian.h.

Referenced by CountingGaussian::CountingGaussian(), CountingGaussian::divide_eq(), CountingGaussian::evaluate(), CountingGaussian::evaluate_print(), CountingGaussian::evaluateLog(), CountingGaussian::initialize(), CountingGaussian::makeClone(), CountingGaussian::put(), and CountingGaussian::resetParameters().

Fgrad

GradType Fgrad

private

Definition at line 66 of file CountingGaussian.h.

Referenced by CountingGaussian::evaluateDerivative_A(), CountingGaussian::evaluateDerivative_B(), and CountingGaussian::evaluateDerivatives().

Flap

RealType Flap

private

Definition at line 67 of file CountingGaussian.h.

Referenced by CountingGaussian::evaluateDerivative_A(), CountingGaussian::evaluateDerivative_B(), and CountingGaussian::evaluateDerivatives().

Fval

RealType Fval

private

Definition at line 65 of file CountingGaussian.h.

Referenced by CountingGaussian::evaluateDerivative_A(), CountingGaussian::evaluateDerivative_B(), and CountingGaussian::evaluateDerivatives().

gref

CountingGaussian* gref = NULL

private

Definition at line 62 of file CountingGaussian.h.

Referenced by CountingGaussian::initialize(), and CountingGaussian::resetParameters().

id

std::string id

private

Definition at line 59 of file CountingGaussian.h.

myVars

opt_variables_type myVars

Definition at line 75 of file CountingGaussian.h.

Referenced by CountingGaussian::checkInVariables(), CountingGaussian::checkOutVariables(), CountingGaussian::initialize(), CountingGaussian::makeClone(), CountingGaussian::reportStatus(), and CountingGaussian::resetParameters().

opt_A

std::vector<bool> opt_A

private

Definition at line 54 of file CountingGaussian.h.

Referenced by CountingGaussian::CountingGaussian(), CountingGaussian::evaluateDerivatives(), CountingGaussian::evaluateLogDerivatives(), CountingGaussian::evaluateLogTempDerivatives(), CountingGaussian::initialize(), CountingGaussian::makeClone(), CountingGaussian::put(), and CountingGaussian::resetParameters().

opt_B

std::vector<bool> opt_B

private

Definition at line 55 of file CountingGaussian.h.

Referenced by CountingGaussian::CountingGaussian(), CountingGaussian::evaluateDerivatives(), CountingGaussian::evaluateLogDerivatives(), CountingGaussian::evaluateLogTempDerivatives(), CountingGaussian::initialize(), CountingGaussian::makeClone(), CountingGaussian::put(), and CountingGaussian::resetParameters().

opt_C

bool opt_C

private

Definition at line 56 of file CountingGaussian.h.

Referenced by CountingGaussian::CountingGaussian(), CountingGaussian::evaluateDerivatives(), CountingGaussian::evaluateLogDerivatives(), CountingGaussian::evaluateLogTempDerivatives(), CountingGaussian::initialize(), CountingGaussian::makeClone(), CountingGaussian::put(), and CountingGaussian::resetParameters().

---

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

• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCWaveFunctions/Jastrow/CountingGaussian.h