ShortRangeCuspFunctor< T > Struct Template Reference

Inheritance diagram for ShortRangeCuspFunctor< T >:

Collaboration diagram for ShortRangeCuspFunctor< T >:

Public Member Functions
	ShortRangeCuspFunctor (const std::string &my_name)
	default constructor More...
void	setCusp (real_type cusp) override
	sets the cusp condition and disables optimization of the cusp-determining parameter More...
OptimizableFunctorBase *	makeClone () const override
	clone the functor More...
void	reset () override
	Implement the reset function, which was pure virtual in OptimizableFunctorBase, even though we don't need it. More...
real_type	evaluate (real_type r) const
	compute U(r) at a particular value of r More...
real_type	evaluate (real_type r, real_type &dudr, real_type &d2udr2) const
	compute U(r), dU/dr, and d^2U/dr^2 at a particular value of r More...
real_type	evaluate (real_type r, real_type &dudr, real_type &d2udr2, real_type &d3udr3) const
	compute U(r), dU/dr, d^2U/dr^2, and d^3U/dr^3 More...
real_type	evaluateV (const int iat, const int iStart, const int iEnd, const T *restrict _distArray, T *restrict distArrayCompressed) const
	compute U(r) at multiple distances and sum the results More...
void	evaluateVGL (const int iat, const int iStart, const int iEnd, const T *distArray, T *restrict valArray, T *restrict gradArray, T *restrict laplArray, T *restrict distArrayCompressed, int *restrict distIndices) const
	compute U(r), dU/dr, and d^2U/dr^2 at multiple values of r More...
real_type	f (real_type r) override
	compute U(r) at a particular distance or return zero if beyond the cutoff More...
real_type	df (real_type r) override
	compute dU/dr at a particular distance or return zero if beyond the cutoff More...
bool	evaluateDerivatives (real_type r, std::vector< TinyVector< real_type, 3 >> &derivs) override
	compute derivatives of U(r), dU/dr, and d^2U/dr^2 with respect to the variational parameters More...
bool	evaluateDerivatives (real_type r, std::vector< real_type > &derivs) override
	compute derivatives of U(r) with respect to the variational parameters More...
template<class U >
void	set_variable_from_xml (ReportEngine &PRE, xmlNodePtr cur, U &variable_to_set, std::string &id_to_set, bool &opt_to_set)
	set up a variational parameter using the supplied xml node More...
bool	put (xmlNodePtr cur) override
	read in information about the functor from an xml node More...
void	checkInVariablesExclusive (opt_variables_type &active) override
	check in variational parameters to the global list of parameters used by the optimizer. More...
void	checkOutVariables (const opt_variables_type &active) override
	check out variational optimizable variables More...
void	resetParametersExclusive (const opt_variables_type &active) override
	reset the parameters during optimizations. More...
Public Member Functions inherited from OptimizableFunctorBase
	OptimizableFunctorBase (const std::string &name="")
	default constructor More...
virtual	~OptimizableFunctorBase ()=default
	virtual destrutor More...
void	getIndex (const opt_variables_type &active)
virtual real_type	f (real_type r)=0
	evaluate the value at r More...
virtual real_type	df (real_type r)=0
	evaluate the first derivative More...
virtual void	setDensity (real_type n)
	empty virtual function to help builder classes More...
virtual void	setCusp (real_type cusp)
	empty virtual function to help builder classes More...
virtual void	setPeriodic (bool periodic)
	empty virtual function to help builder classes More...
virtual bool	evaluateDerivatives (real_type r, std::vector< qmcplusplus::TinyVector< real_type, 3 >> &derivs)
virtual bool	evaluateDerivatives (real_type r, std::vector< real_type > &derivs)
virtual void	setGridManager (bool willmanage)
virtual void	checkInVariablesExclusive (opt_variables_type &active)=0
	check in variational parameters to the global list of parameters used by the optimizer. More...
virtual void	resetParametersExclusive (const opt_variables_type &active)=0
	reset the parameters during optimizations More...
Public Member Functions inherited from OptimizableObject
	OptimizableObject (const std::string &name)
const std::string &	getName () const
bool	isOptimized () const
virtual void	reportStatus (std::ostream &os)
	print the state, e.g., optimizables More...
void	setOptimization (bool state)
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...

Static Public Member Functions
static void	mw_evaluateV (const int num_groups, const ShortRangeCuspFunctor *const functors[], const int n_src, const int *grp_ids, const int num_pairs, const int *ref_at, const T *mw_dist, const int dist_stride, T *mw_vals, Vector< char, OffloadPinnedAllocator< char >> &transfer_buffer)
	evaluate sum of the pair potentials FIXME More...

Public Attributes
bool	Opt_A
	true, if A is optimizable More...
bool	Opt_R0
	true, if R0 is optimizable More...
bool	Opt_B
	true, if B variables are optimizable More...
real_type	A
	variable that controls the cusp More...
real_type	R0
	the soft cutoff distance that controls how short ranged the functor is More...
std::vector< real_type >	B
	variables that add detail through an expansion in sigmoidal functions More...
std::string	ID_A
	id of A More...
std::string	ID_R0
	id of R0 More...
std::string	ID_B
	id of B More...
Public Attributes inherited from OptimizableFunctorBase
real_type	cutoff_radius = 0.0
	maximum cutoff More...
opt_variables_type	myVars
	set of variables to be optimized More...

Additional Inherited Members
Public Types inherited from OptimizableFunctorBase
using	real_type = optimize::VariableSet::real_type
	typedef for real values More...
using	opt_variables_type = optimize::VariableSet
	typedef for variableset: this is going to be replaced More...

Detailed Description

template<class T>
struct qmcplusplus::ShortRangeCuspFunctor< T >

Definition at line 57 of file ShortRangeCuspFunctor.h.

Constructor & Destructor Documentation

ShortRangeCuspFunctor()

ShortRangeCuspFunctor ( const std::string &  my_name )

inline

default constructor

Definition at line 87 of file ShortRangeCuspFunctor.h.

References OptimizableFunctorBase::cutoff_radius, and ShortRangeCuspFunctor< T >::reset().

Referenced by ShortRangeCuspFunctor< T >::makeClone().

      : OptimizableFunctorBase(my_name),
        Opt_A(false),
        Opt_R0(true),
        Opt_B(true),
        A(1.0),
        R0(0.06),
        ID_A("string_not_set"),
        ID_R0("string_not_set"),
        ID_B("string_not_set")
  {
    cutoff_radius = 1.0e4; //some big range
    reset();
  }

Member Function Documentation

checkInVariablesExclusive()

void checkInVariablesExclusive ( opt_variables_type &  active )

inlineoverridevirtual

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

Parameters

active

a super set of optimizable variables

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

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

Implements OptimizableObject.

Definition at line 636 of file ShortRangeCuspFunctor.h.

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

Referenced by qmcplusplus::TEST_CASE().

  {
    active.insertFrom(myVars);
  }

checkOutVariables()

void checkOutVariables ( const opt_variables_type &  active )

inlineoverridevirtual

check out variational optimizable variables

Parameters

active

a super set of optimizable variables

Implements OptimizableFunctorBase.

Definition at line 641 of file ShortRangeCuspFunctor.h.

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

  {
    myVars.getIndex(active);
  }

df()

real_type df ( real_type  r )

inlineoverride

compute dU/dr at a particular distance or return zero if beyond the cutoff

Definition at line 275 of file ShortRangeCuspFunctor.h.

References OptimizableFunctorBase::cutoff_radius, and ShortRangeCuspFunctor< T >::evaluate().

  {
    if (r >= cutoff_radius)
      return 0.0;
    real_type du, d2u;
    evaluate(r, du, d2u);
    return du;
  }

evaluate() [1/3]

real_type evaluate ( real_type  r ) const

inline

compute U(r) at a particular value of r

Definition at line 121 of file ShortRangeCuspFunctor.h.

References ShortRangeCuspFunctor< T >::A, ShortRangeCuspFunctor< T >::B, OptimizableFunctorBase::cutoff_radius, qmcplusplus::exp(), ShortRangeCuspFunctor< T >::R0, and qmcplusplus::Units::time::s.

Referenced by ShortRangeCuspFunctor< T >::df(), ShortRangeCuspFunctor< T >::evaluateV(), ShortRangeCuspFunctor< T >::evaluateVGL(), ShortRangeCuspFunctor< T >::f(), and qmcplusplus::TEST_CASE().

  {
    // the functor will be almost exactly zero at long range, so just return that if r is beyond the hard cutoff
    if (r >= cutoff_radius)
      return 0.0;

    // get the ratio of the distance and the soft cutoff distance
    const real_type s = r / R0;

    // sum up the sigmoidal function expansion
    real_type sig_sum = 0.0;
    real_type sn      = s * s; // s^n
    for (int i = 0; i < B.size(); i++)
    {
      sig_sum += B[i] * sn / (1.0 + sn);
      sn *= s; // update s^n
    }

    // return U(r)
    return -1.0 * std::exp(-s) * (A * R0 + sig_sum);
  }

evaluate() [2/3]

real_type evaluate ( real_type  r, real_type &  dudr, real_type &  d2udr2  ) const

inline

compute U(r), dU/dr, and d^2U/dr^2 at a particular value of r

Definition at line 144 of file ShortRangeCuspFunctor.h.

References ShortRangeCuspFunctor< T >::A, ShortRangeCuspFunctor< T >::B, OptimizableFunctorBase::cutoff_radius, qmcplusplus::exp(), qmcplusplus::n, ShortRangeCuspFunctor< T >::R0, and qmcplusplus::Units::time::s.

  {
    // the functor will be almost exactly zero at long range, so just return that if r is beyond the hard cutoff
    if (r >= cutoff_radius)
    {
      dudr   = 0.0;
      d2udr2 = 0.0;
      return 0.0;
    }

    // get the ratio of the distance and the soft cutoff distance
    const real_type s = r / R0;

    // get the exponential factor
    const real_type ex = std::exp(-s);

    // sum the terms related to the sigmoidal functions that are needed for U, dU, and d^2U
    real_type sig_sum_0 = 0.0; // contributes to U(r)
    real_type sig_sum_1 = 0.0; // contributes to dU/dr
    real_type sig_sum_2 = 0.0; // contributes to d2U/dr2
    real_type n         = 2.0;
    real_type sn        = s * s; // s^{n  }
    real_type snm1      = s;     // s^{n-1}
    real_type snm2      = 1.0;   // s^{n-2}
    for (int i = 0; i < B.size(); i++)
    {
      const real_type d       = 1.0 + sn;
      const real_type d2      = d * d;
      const real_type soverd  = s / d;
      const real_type noverd2 = n / d2;
      sig_sum_0 += B[i] * sn / d;
      sig_sum_1 += B[i] * (sn * sn + sn - n * snm1) / d2;
      sig_sum_2 += B[i] * snm2 * (d * noverd2 * noverd2 * (sn - 1.0) + noverd2 * (1.0 + 2.0 * s) - soverd * s);
      snm2 = snm1; // update s^{n-2}
      snm1 = sn;   // update s^{n-1}
      sn *= s;     // update s^{n  }
      n += 1.0;    // update n
    }

    // get some useful ratios ( ex / R0 and ex / R0^2 )
    const real_type exoverR0  = ex / R0;
    const real_type exoverR02 = exoverR0 / R0;

    // evaluate dU/dr
    dudr = A * ex + exoverR0 * sig_sum_1;

    // evaluate d^2U/dr^2
    d2udr2 = -A * exoverR0 + exoverR02 * sig_sum_2;

    // return U(r)
    return -1.0 * ex * (A * R0 + sig_sum_0);
  }

evaluate() [3/3]

real_type evaluate ( real_type  r, real_type &  dudr, real_type &  d2udr2, real_type &  d3udr3  ) const

inline

compute U(r), dU/dr, d^2U/dr^2, and d^3U/dr^3

Definition at line 198 of file ShortRangeCuspFunctor.h.

References ReportEngine::error().

  {
    ReportEngine PRE("ShortRangeCuspFunctor", "evaluate(r, dudr, d2udr2, d3udr3)");
    PRE.error("evaluate(r, dudr, d2udr2, d3udr3) not implemented for ShortRangeCuspFunctor", true);
    return 0.0;
  }

evaluateDerivatives() [1/2]

bool evaluateDerivatives ( real_type  r, std::vector< TinyVector< real_type, 3 >> &  derivs  )

inlineoverride

compute derivatives of U(r), dU/dr, and d^2U/dr^2 with respect to the variational parameters

Definition at line 285 of file ShortRangeCuspFunctor.h.

References ShortRangeCuspFunctor< T >::A, ShortRangeCuspFunctor< T >::B, qmcplusplus::exp(), qmcplusplus::n, ShortRangeCuspFunctor< T >::Opt_A, ShortRangeCuspFunctor< T >::Opt_B, ShortRangeCuspFunctor< T >::Opt_R0, ShortRangeCuspFunctor< T >::R0, and qmcplusplus::Units::time::s.

Referenced by qmcplusplus::TEST_CASE().

  {
    // get the ratio of the distance and the soft cutoff distance
    const real_type s = r / R0;

    // get the exponential factor
    const real_type ex = std::exp(-s);

    // get some useful ratios
    const real_type exoverR0  = ex / R0;
    const real_type exoverR02 = exoverR0 / R0;
    const real_type exoverR03 = exoverR02 / R0;

    // initialize the index that will track where to put different parameters' derivatives
    int i = 0;

    // evaluate derivatives with respect to the cusp condition variable A
    if (Opt_A)
    {
      derivs[i][0] = -ex * R0;  //dU/da
      derivs[i][1] = ex;        //d(dU/da)/dr
      derivs[i][2] = -exoverR0; //d^2 (dU/da)/dr^2
      ++i;
    }

    // evaluate derivatives with respect to the soft cutoff radius
    if (Opt_R0)
    {
      // sum up terms related to the sigmoidal exansion
      real_type n         = 2.0;
      real_type sn        = s * s; // s^{n  }
      real_type snm1      = s;     // s^{n-1}
      real_type snm2      = 1.0;   // s^{n-2}
      real_type sig_sum_0 = 0.0;   // contributes to dUdR0
      real_type sig_sum_1 = 0.0;   // contributes to d(dU/dR0)/dr
      real_type sig_sum_2 = 0.0;   // contributes to d^2(dU/dR0)/dr^2
      for (int j = 0; j < B.size(); j++)
      {
        const real_type d       = 1.0 + sn;
        const real_type d2      = d * d;
        const real_type soverd  = s / d;
        const real_type noverd2 = n / d2;
        sig_sum_0 += B[j] * sn * (noverd2 - soverd);
        sig_sum_1 += B[j] * snm1 * (d * noverd2 * noverd2 * (1.0 - sn) - 2.0 * noverd2 * s + soverd * (s - 1.0));
        sig_sum_2 += B[j] * snm2 *
            (s * (3.0 * s - 1.0) * noverd2 - s * (s - 2.0) * soverd +
             (n + n * sn * (sn - 4.0) + (3.0 * s + 1.0) * (sn * sn - 1.0)) * noverd2 * noverd2);
        snm2 = snm1; // update s^{n-2}
        snm1 = sn;   // update s^{n-1}
        sn *= s;     // update s^{n  }
        n += 1.0;    // update n
      }

      // compute terms related to the cusp-inducing term
      const real_type cusp_part_0 = -A * ex * (s + 1.0);        // contributes to dUdR0
      const real_type cusp_part_1 = A * exoverR0 * s;           // contributes to d(dU/dR0)/dr
      const real_type cusp_part_2 = -A * exoverR02 * (s - 1.0); // contributes to d^2(dU/dR0)/dr^2

      // compute the desired derivatives
      derivs[i][0] = cusp_part_0 + exoverR0 * sig_sum_0;  // dUdR0
      derivs[i][1] = cusp_part_1 + exoverR02 * sig_sum_1; // d(dU/dR0)/dr
      derivs[i][2] = cusp_part_2 + exoverR03 * sig_sum_2; // d^2(dU/dR0)/dr^2

      // increment the index tracking where to put derivatives
      ++i;
    }

    // evaluate derivatives with respect to the sigmoidal expansion coefficients
    if (Opt_B)
    {
      // loop over the terms in the expansion over sigmoidal functions
      real_type n    = 2.0;
      real_type sn   = s * s; // s^{n  }
      real_type snm1 = s;     // s^{n-1}
      real_type snm2 = 1.0;   // s^{n-2}
      for (int j = 0; j < B.size(); j++)
      {
        // compute some useful values
        const real_type d       = 1.0 + sn;
        const real_type d2      = d * d;
        const real_type soverd  = s / d;
        const real_type noverd2 = n / d2;

        // dU/dB_j
        derivs[i][0] = -ex * sn / d;

        // d(dU/dB_j)/dr
        derivs[i][1] = exoverR0 * (sn * sn + sn - n * snm1) / d2;

        // d^2(dU/dB_j)/dr^2
        derivs[i][2] = exoverR02 * snm2 * (d * noverd2 * noverd2 * (sn - 1.0) + noverd2 * (1.0 + 2.0 * s) - soverd * s);

        snm2 = snm1; // update s^{n-2}
        snm1 = sn;   // update s^{n-1}
        sn *= s;     // update s^{n  }
        n += 1.0;    // update n

        // increment the index tracking where to put derivatives
        ++i;
      }
    }

    return true;
  }

evaluateDerivatives() [2/2]

bool evaluateDerivatives ( real_type  r, std::vector< real_type > &  derivs  )

inlineoverride

compute derivatives of U(r) with respect to the variational parameters

Definition at line 391 of file ShortRangeCuspFunctor.h.

References ShortRangeCuspFunctor< T >::A, ShortRangeCuspFunctor< T >::B, qmcplusplus::exp(), qmcplusplus::n, ShortRangeCuspFunctor< T >::Opt_A, ShortRangeCuspFunctor< T >::Opt_B, ShortRangeCuspFunctor< T >::Opt_R0, ShortRangeCuspFunctor< T >::R0, and qmcplusplus::Units::time::s.

  {
    // get the ratio of the distance and the soft cutoff distance
    const real_type s = r / R0;

    // get the exponential factor
    const real_type ex = std::exp(-s);

    // get some useful ratios
    const real_type exoverR0 = ex / R0;

    // initialize the index that will track where to put different parameters' derivatives
    int i = 0;

    // evaluate derivatives with respect to the cusp condition variable A
    if (Opt_A)
    {
      derivs[i] = -ex * R0; //dU/da
      ++i;
    }

    // evaluate derivatives with respect to the soft cutoff radius
    if (Opt_R0)
    {
      // sum up terms related to the sigmoidal exansion
      real_type n       = 2.0;
      real_type sn      = s * s; // s^n
      real_type sig_sum = 0.0;
      for (int j = 0; j < B.size(); j++)
      {
        const real_type d       = 1.0 + sn;
        const real_type d2      = d * d;
        const real_type soverd  = s / d;
        const real_type noverd2 = n / d2;
        sig_sum += B[j] * sn * (noverd2 - soverd);
        sn *= s;  // update s^n
        n += 1.0; // update n
      }

      // compute term related to the cusp-inducing term
      const real_type cusp_part = -A * ex * (s + 1.0);

      // compute dU/dR0
      derivs[i] = cusp_part + exoverR0 * sig_sum;

      // increment the index tracking where to put derivatives
      ++i;
    }

    // evaluate derivatives with respect to the sigmoidal expansion coefficients
    if (Opt_B)
    {
      real_type sn = s * s; // s^n
      for (int j = 0; j < B.size(); j++)
      {
        derivs[i] = -ex * sn / (1.0 + sn); // dU/dB_j
        sn *= s;                           // update s^n
        ++i;                               // increment the index tracking where to put derivatives
      }
    }

    return true;
  }

evaluateV()

real_type evaluateV ( const int  iat, const int  iStart, const int  iEnd, const T *restrict  _distArray, T *restrict  distArrayCompressed  ) const

inline

compute U(r) at multiple distances and sum the results

Definition at line 206 of file ShortRangeCuspFunctor.h.

References ShortRangeCuspFunctor< T >::evaluate().

  {
    real_type sum(0);
    for (int idx = iStart; idx < iEnd; idx++)
      if (idx != iat)
        sum += evaluate(_distArray[idx]);
    return sum;
  }

evaluateVGL()

void evaluateVGL ( const int  iat, const int  iStart, const int  iEnd, const T *  distArray, T *restrict  valArray, T *restrict  gradArray, T *restrict  laplArray, T *restrict  distArrayCompressed, int *restrict  distIndices  ) const

inline

compute U(r), dU/dr, and d^2U/dr^2 at multiple values of r

Definition at line 247 of file ShortRangeCuspFunctor.h.

References ShortRangeCuspFunctor< T >::evaluate().

  {
    for (int idx = iStart; idx < iEnd; idx++)
    {
      valArray[idx] = evaluate(distArray[idx], gradArray[idx], laplArray[idx]);
      gradArray[idx] /= distArray[idx];
    }
    if (iat >= iStart && iat < iEnd)
      valArray[iat] = gradArray[iat] = laplArray[iat] = T(0);
  }

f()

real_type f ( real_type  r )

inlineoverride

compute U(r) at a particular distance or return zero if beyond the cutoff

Definition at line 267 of file ShortRangeCuspFunctor.h.

References OptimizableFunctorBase::cutoff_radius, and ShortRangeCuspFunctor< T >::evaluate().

  {
    if (r >= cutoff_radius)
      return 0.0;
    return evaluate(r);
  }

makeClone()

OptimizableFunctorBase* makeClone ( ) const

inlineoverridevirtual

clone the functor

Implements OptimizableFunctorBase.

Definition at line 112 of file ShortRangeCuspFunctor.h.

References ShortRangeCuspFunctor< T >::ShortRangeCuspFunctor().

{ return new ShortRangeCuspFunctor(*this); }

mw_evaluateV()

static void mw_evaluateV ( const int  num_groups, const ShortRangeCuspFunctor< T > *const  functors[], const int  n_src, const int *  grp_ids, const int  num_pairs, const int *  ref_at, const T *  mw_dist, const int  dist_stride, T *  mw_vals, Vector< char, OffloadPinnedAllocator< char >> &  transfer_buffer  )

inlinestatic

evaluate sum of the pair potentials FIXME

Returns

for r_j < cutoff_radius

Definition at line 222 of file ShortRangeCuspFunctor.h.

  {
    for (int ip = 0; ip < num_pairs; ip++)
    {
      mw_vals[ip] = 0;
      for (int j = 0; j < n_src; j++)
      {
        const int ig = grp_ids[j];
        auto& functor(*functors[ig]);
        if (j != ref_at[ip])
          mw_vals[ip] += functor.evaluate(mw_dist[ip * dist_stride + j]);
      }
    }
  }

put()

bool put ( xmlNodePtr  cur )

inlineoverridevirtual

read in information about the functor from an xml node

Implements OptimizableFunctorBase.

Definition at line 500 of file ShortRangeCuspFunctor.h.

References ShortRangeCuspFunctor< T >::A, OhmmsAttributeSet::add(), qmcplusplus::app_summary(), ShortRangeCuspFunctor< T >::B, castXMLCharToChar(), OptimizableFunctorBase::cutoff_radius, ReportEngine::error(), ShortRangeCuspFunctor< T >::ID_A, ShortRangeCuspFunctor< T >::ID_B, ShortRangeCuspFunctor< T >::ID_R0, VariableSet::insert(), qmcplusplus::lowerCase(), OptimizableFunctorBase::myVars, ShortRangeCuspFunctor< T >::Opt_A, ShortRangeCuspFunctor< T >::Opt_B, ShortRangeCuspFunctor< T >::Opt_R0, optimize::OTHER_P, OhmmsAttributeSet::put(), putContent(), ShortRangeCuspFunctor< T >::R0, ShortRangeCuspFunctor< T >::reset(), ShortRangeCuspFunctor< T >::set_variable_from_xml(), and ShortRangeCuspFunctor< T >::setCusp().

Referenced by qmcplusplus::TEST_CASE().

  {
    // set up an object for info / warning / error reporting
    ReportEngine PRE("ShortRangeCuspFunctor", "put(xmlNodePtr)");

    // create some variables to read information in to
    real_type radius  = -1.0; // hard cutoff radius
    real_type cusp_in = -1.0; // cusp condition

    // read from the xml node
    OhmmsAttributeSet rAttrib;
    rAttrib.add(radius, "rcut");
    rAttrib.add(radius, "cutoff");
    rAttrib.add(cusp_in, "cusp");
    rAttrib.put(cur);

    // set the hard cutoff radius if we have it
    if (radius > 0.0)
      cutoff_radius = radius;

    // set the cusp if we have it
    if (cusp_in > 0.0)
      setCusp(cusp_in);

    // loop over this node's children to read in variational parameter information
    xmlNodePtr childPtr = cur->xmlChildrenNode;
    while (childPtr != NULL)
    {
      // skip blank nodes
      if (xmlIsBlankNode(childPtr))
      {
        childPtr = childPtr->next;
        continue;
      }

      // get the name of the child node
      std::string cname(lowerCase(castXMLCharToChar(childPtr->name)));
      // read in a variable
      if (cname == "var")
      {
        // read in the name of the variable
        std::string v_name("string_not_set");
        OhmmsAttributeSet att;
        att.add(v_name, "name");
        att.put(childPtr);

        // read in the variable's info
        if (v_name == "A")
          set_variable_from_xml(PRE, childPtr, A, ID_A, Opt_A);
        else if (v_name == "R0")
          set_variable_from_xml(PRE, childPtr, R0, ID_R0, Opt_R0);
        else if (v_name == "string_not_set")
          PRE.error("variable name not set", true);
        else
          PRE.error("unrecognized variable name: " + v_name, true);
      }

      // read in the B coefficients
      else if (cname == "coefficients")
      {
        // read in the id, whether to optimize, and the node type
        std::string id("string_not_set");
        std::string type("string_not_set");
        std::string optimize("string_not_set");
        OhmmsAttributeSet att;
        att.add(id, "id");
        att.add(type, "type");
        att.add(optimize, "optimize");
        att.put(childPtr);

        // sanity check that this node has been specified as an array type
        if (type != "Array")
          PRE.error("ShortRangeCuspFunctor expected coefficients parameter array type to be \"Array\"", true);

        // read in the vector of coefficients
        putContent(B, childPtr);

        // set the id if we have it
        if (id != "string_not_set")
          ID_B = id;

        // if the coefficients are to be optimized, add them to the variable set
        optimize = lowerCase(optimize);
        if (optimize == "yes")
        {
          if (id == "string_not_set")
            PRE.error("\"id\" must be set if we are going to optimize B coefficients", true);
          Opt_B = true;
          for (int i = 0; i < B.size(); i++)
          {
            std::stringstream sstr;
            sstr << ID_B << "_" << i;
            myVars.insert(sstr.str(), B.at(i), Opt_B, optimize::OTHER_P);
          }
        }
        else if (optimize == "no")
        {
          Opt_B = false;
        }
        else if (optimize != "string_not_set")
        {
          PRE.error("Unrecognized value for \"optimize\". Should be either yes or no", true);
        }
      }

      // error if cname is not recognized
      else
      {
        PRE.error("\"" + cname +
                      "\" is not a recognized value for \"cname\". Allowed values are \"var\" and \"coefficients\"",
                  true);
      }

      // go to the next node
      childPtr = childPtr->next;
    }

    // summarize what was read in
    app_summary() << "    ---------------------------------------------------------" << std::endl;
    app_summary() << "                       cusp variable A: " << A << std::endl;
    app_summary() << "                        soft cutoff R0: " << R0 << std::endl;
    app_summary() << "    sigmoidal expansion coefficients B:";
    for (int i = 0; i < B.size(); i++)
      app_summary() << " " << B.at(i);
    app_summary() << std::endl;
    app_summary() << "                    hard cutoff radius: " << cutoff_radius << std::endl;
    app_summary() << "                                 Opt_A: " << (Opt_A ? "yes" : "no") << std::endl;
    app_summary() << "                                Opt_R0: " << (Opt_R0 ? "yes" : "no") << std::endl;
    app_summary() << "                                 Opt_B: " << (Opt_B ? "yes" : "no") << std::endl;

    // reset the functor now that we've read its info in (currently does nothing)
    reset();

    return true;
  }

reset()

void reset ( )

inlineoverridevirtual

Implement the reset function, which was pure virtual in OptimizableFunctorBase, even though we don't need it.

Implements OptimizableFunctorBase.

Definition at line 115 of file ShortRangeCuspFunctor.h.

Referenced by ShortRangeCuspFunctor< T >::put(), ShortRangeCuspFunctor< T >::resetParametersExclusive(), ShortRangeCuspFunctor< T >::setCusp(), and ShortRangeCuspFunctor< T >::ShortRangeCuspFunctor().

  {
    //cutoff_radius = 1.0e4; //some big range
  }

resetParametersExclusive()

void resetParametersExclusive ( const opt_variables_type &  active )

inlineoverridevirtual

reset the parameters during optimizations.

Exclusive, see checkInVariablesExclusive

Implements OptimizableObject.

Definition at line 646 of file ShortRangeCuspFunctor.h.

References ShortRangeCuspFunctor< T >::A, ShortRangeCuspFunctor< T >::B, OptimizableFunctorBase::myVars, ShortRangeCuspFunctor< T >::Opt_A, ShortRangeCuspFunctor< T >::Opt_B, ShortRangeCuspFunctor< T >::Opt_R0, ShortRangeCuspFunctor< T >::R0, ShortRangeCuspFunctor< T >::reset(), VariableSet::size(), and VariableSet::where().

Referenced by qmcplusplus::TEST_CASE().

  {
    if (myVars.size())
    {
      int ia = myVars.where(0);
      if (ia > -1)
      {
        int i = 0;
        if (Opt_A)
          A = std::real(myVars[i++] = active[ia++]);
        if (Opt_R0)
          R0 = std::real(myVars[i++] = active[ia++]);
        for (int j = 0; Opt_B && j < B.size(); j++)
          B.at(j) = std::real(myVars[i++] = active[ia++]);
      }
      reset();
    }
  }

set_variable_from_xml()

void set_variable_from_xml ( ReportEngine &  PRE, xmlNodePtr  cur, U &  variable_to_set, std::string &  id_to_set, bool &  opt_to_set  )

inline

set up a variational parameter using the supplied xml node

Definition at line 457 of file ShortRangeCuspFunctor.h.

References OhmmsAttributeSet::add(), ReportEngine::error(), VariableSet::insert(), qmcplusplus::lowerCase(), OptimizableFunctorBase::myVars, optimize::OTHER_P, OhmmsAttributeSet::put(), and putContent().

Referenced by ShortRangeCuspFunctor< T >::put().

  {
    // get id, name, and optimize info
    std::string id("string_not_set");
    std::string name("string_not_set");
    std::string optimize("string_not_set");
    OhmmsAttributeSet rAttrib;
    rAttrib.add(id, "id");
    rAttrib.add(name, "name");
    rAttrib.add(optimize, "optimize");
    rAttrib.put(cur);

    // read in the variable
    putContent(variable_to_set, cur);

    // set the id if we have it
    if (id != "string_not_set")
      id_to_set = id;

    // if we are to optimize the variable, add it to the optimizable variable set
    optimize = lowerCase(optimize);
    if (optimize == "yes")
    {
      if (id == "string_not_set")
        PRE.error("\"id\" must be set if we are going to optimize variable " + name, true);
      opt_to_set = true;
      myVars.insert(id, variable_to_set, opt_to_set, optimize::OTHER_P);
    }
    else if (optimize == "no")
    {
      opt_to_set = false;
    }
    else if (optimize != "string_not_set")
    {
      PRE.error("Unrecognized value for \"optimize\". Should be either yes or no", true);
    }
  }

setCusp()

void setCusp ( real_type  cusp )

inlineoverride

sets the cusp condition and disables optimization of the cusp-determining parameter

Definition at line 103 of file ShortRangeCuspFunctor.h.

References ShortRangeCuspFunctor< T >::A, ShortRangeCuspFunctor< T >::Opt_A, and ShortRangeCuspFunctor< T >::reset().

Referenced by ShortRangeCuspFunctor< T >::put().

  {
    //throw std::runtime_error("ShortRangeCuspFunctor::setCusp was called");
    A     = cusp;
    Opt_A = false;
    reset();
  }

Member Data Documentation

A

real_type A

variable that controls the cusp

Definition at line 70 of file ShortRangeCuspFunctor.h.

Referenced by ShortRangeCuspFunctor< T >::evaluate(), ShortRangeCuspFunctor< T >::evaluateDerivatives(), ShortRangeCuspFunctor< T >::put(), ShortRangeCuspFunctor< T >::resetParametersExclusive(), ShortRangeCuspFunctor< T >::setCusp(), and qmcplusplus::TEST_CASE().

B

std::vector<real_type> B

variables that add detail through an expansion in sigmoidal functions

Definition at line 74 of file ShortRangeCuspFunctor.h.

Referenced by ShortRangeCuspFunctor< T >::evaluate(), ShortRangeCuspFunctor< T >::evaluateDerivatives(), ShortRangeCuspFunctor< T >::put(), ShortRangeCuspFunctor< T >::resetParametersExclusive(), and qmcplusplus::TEST_CASE().

ID_A

std::string ID_A

id of A

Definition at line 76 of file ShortRangeCuspFunctor.h.

Referenced by ShortRangeCuspFunctor< T >::put(), and qmcplusplus::TEST_CASE().

ID_B

std::string ID_B

id of B

Definition at line 80 of file ShortRangeCuspFunctor.h.

Referenced by ShortRangeCuspFunctor< T >::put(), and qmcplusplus::TEST_CASE().

ID_R0

std::string ID_R0

id of R0

Definition at line 78 of file ShortRangeCuspFunctor.h.

Referenced by ShortRangeCuspFunctor< T >::put(), and qmcplusplus::TEST_CASE().

Opt_A

bool Opt_A

true, if A is optimizable

Definition at line 64 of file ShortRangeCuspFunctor.h.

Referenced by ShortRangeCuspFunctor< T >::evaluateDerivatives(), ShortRangeCuspFunctor< T >::put(), ShortRangeCuspFunctor< T >::resetParametersExclusive(), ShortRangeCuspFunctor< T >::setCusp(), and qmcplusplus::TEST_CASE().

Opt_B

bool Opt_B

true, if B variables are optimizable

Definition at line 68 of file ShortRangeCuspFunctor.h.

Referenced by ShortRangeCuspFunctor< T >::evaluateDerivatives(), ShortRangeCuspFunctor< T >::put(), ShortRangeCuspFunctor< T >::resetParametersExclusive(), and qmcplusplus::TEST_CASE().

Opt_R0

bool Opt_R0

true, if R0 is optimizable

Definition at line 66 of file ShortRangeCuspFunctor.h.

Referenced by ShortRangeCuspFunctor< T >::evaluateDerivatives(), ShortRangeCuspFunctor< T >::put(), ShortRangeCuspFunctor< T >::resetParametersExclusive(), and qmcplusplus::TEST_CASE().

R0

real_type R0

the soft cutoff distance that controls how short ranged the functor is

Definition at line 72 of file ShortRangeCuspFunctor.h.

Referenced by ShortRangeCuspFunctor< T >::evaluate(), ShortRangeCuspFunctor< T >::evaluateDerivatives(), ShortRangeCuspFunctor< T >::put(), ShortRangeCuspFunctor< T >::resetParametersExclusive(), and qmcplusplus::TEST_CASE().

---

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

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