RadialJastrowBuilder Class Reference

JastrowBuilder using an analytic 1d functor Should be able to eventually handle all one and two body jastrows although spline based ones will come later. More...

Inheritance diagram for RadialJastrowBuilder:

Collaboration diagram for RadialJastrowBuilder:

Public Types
enum	detail { CPU, CUDA, OMPTARGET }
Public Types inherited from WaveFunctionComponentBuilder
using	RealType = WaveFunctionComponent::RealType
using	ValueType = WaveFunctionComponent::ValueType
using	PosType = WaveFunctionComponent::PosType
using	GradType = WaveFunctionComponent::GradType
using	PSetMap = std::map< std::string, const std::unique_ptr< ParticleSet > >
Public Types inherited from MPIObjectBase
using	mpi_comm_type = Communicate::mpi_comm_type

Public Member Functions
	RadialJastrowBuilder (Communicate *comm, ParticleSet &target, ParticleSet &source)
	RadialJastrowBuilder (Communicate *comm, ParticleSet &target)
std::unique_ptr< WaveFunctionComponent >	buildComponent (xmlNodePtr cur) override
	process a xml node at cur More...
template<>
void	initTwoBodyFunctor (BsplineFunctor< RealType > &bfunc, double fac)
Public Member Functions inherited from WaveFunctionComponentBuilder
	WaveFunctionComponentBuilder (Communicate *comm, ParticleSet &p)
	constructor More...
virtual	~WaveFunctionComponentBuilder ()=default
Public Member Functions inherited from MPIObjectBase
	MPIObjectBase (Communicate *c)
	constructor with communicator More...
int	rank () const
	return the rank of the communicator More...
int	getGroupID () const
	return the group id of the communicator More...
Communicate *	getCommunicator () const
	return myComm More...
Communicate &	getCommRef () const
	return a TEMPORARY reference to Communicate More...
mpi_comm_type	getMPI () const
	return MPI communicator if one wants to use MPI directly More...
bool	is_manager () const
	return true if the rank == 0 More...
const std::string &	getName () const
	return the name More...
void	setName (const std::string &aname)

Private Member Functions
template<class RadFuncType , bool SPIN = false, unsigned Implementation = detail::CPU>
std::unique_ptr< WaveFunctionComponent >	createJ1 (xmlNodePtr cur)
template<class RadFuncType , unsigned Implementation = detail::CPU>
std::unique_ptr< WaveFunctionComponent >	createJ2 (xmlNodePtr cur)
template<class RadFuncType >
void	initTwoBodyFunctor (RadFuncType &functor, double fac)
template<class RadFuncType >
void	computeJ2uk (const std::vector< RadFuncType *> &functors)
void	guardAgainstOBC ()
void	guardAgainstPBC ()
template<>
std::unique_ptr< WaveFunctionComponent >	createJ2 (xmlNodePtr cur)
template<>
std::unique_ptr< WaveFunctionComponent >	createJ1 (xmlNodePtr cur)

Private Attributes
std::string	NameOpt
	<jastrow name="..."> More...
std::string	TypeOpt
	<jastrow type="..."> More...
std::string	Jastfunction
	<jastrow function="..."> More...
std::string	SpinOpt
	<jastrow spin="..."> More...
ParticleSet *	SourcePtcl
	particle set for source particle More...

Additional Inherited Members
Static Public Attributes inherited from WaveFunctionComponentBuilder
static std::string	wfs_tag = "wavefunction"
	reserved tags for the elements associated with the many-body wavefunctions More...
static std::string	param_tag = "parameter"
	the element name for a parameter More...
static std::string	dtable_tag = "distancetable"
	the element name for a distancetable More...
static std::string	jastrow_tag = "jastrow"
	the element name for jatrow More...
static std::string	detset_tag = "determinantset"
	the element name for a set of Slater determinants, contains 1..* Slater determinants More...
static std::string	sd_tag = "slaterdeterminant"
	the element name for a Slater determinant, contains 1..* determinants More...
static std::string	det_tag = "determinant"
	the element name for a determinant, may contain (0..*) orbital or parameter element More...
static std::string	rn_tag = "determinant_rn"
	the element name for a released node determinant, may contain (0..*) orbital or parameter element More...
static std::string	spo_tag = "psi"
	the element name for single-particle orbital More...
static std::string	sposet_tag = "sposet"
	the element name for single-particle orbital set More...
static std::string	ionorb_tag = "ionwf"
	the element name for an ion wavefunction More...
static std::string	backflow_tag = "backflow"
	the element name for a backflow transformation More...
static std::string	multisd_tag = "multideterminant"
	the element name for a multi slater determinant wavefunction More...
Protected Attributes inherited from WaveFunctionComponentBuilder
ParticleSet &	targetPtcl
	reference to the particle set on which targetPsi is defined More...
xmlNodePtr	myNode
	xmlNode operated by this object More...
Protected Attributes inherited from MPIObjectBase
Communicate *	myComm
	pointer to Communicate More...
std::string	ClassName
	class Name More...
std::string	myName
	name of the object More...

Detailed Description

JastrowBuilder using an analytic 1d functor Should be able to eventually handle all one and two body jastrows although spline based ones will come later.

Definition at line 33 of file RadialJastrowBuilder.h.

Member Enumeration Documentation

detail

enum detail

Enumerator
CPU
CUDA
OMPTARGET

Definition at line 36 of file RadialJastrowBuilder.h.

  {
    CPU,
    CUDA,
    OMPTARGET
  };

Constructor & Destructor Documentation

RadialJastrowBuilder() [1/2]

RadialJastrowBuilder	(	Communicate *	comm,
		ParticleSet &	target,
		ParticleSet &	source
	)

Definition at line 57 of file RadialJastrowBuilder.cpp.

References MPIObjectBase::ClassName, RadialJastrowBuilder::Jastfunction, RadialJastrowBuilder::NameOpt, RadialJastrowBuilder::SpinOpt, and RadialJastrowBuilder::TypeOpt.

    : WaveFunctionComponentBuilder(comm, target), SourcePtcl(&source)
{
  ClassName    = "RadialJastrowBuilder";
  NameOpt      = "0";
  TypeOpt      = "unknown";
  Jastfunction = "unknown";
  SpinOpt      = "no";
}

RadialJastrowBuilder() [2/2]

RadialJastrowBuilder	(	Communicate *	comm,
		ParticleSet &	target
	)

Definition at line 67 of file RadialJastrowBuilder.cpp.

References MPIObjectBase::ClassName, RadialJastrowBuilder::Jastfunction, RadialJastrowBuilder::NameOpt, RadialJastrowBuilder::SpinOpt, and RadialJastrowBuilder::TypeOpt.

    : WaveFunctionComponentBuilder(comm, target), SourcePtcl(NULL)
{
  ClassName    = "RadialJastrowBuilder";
  NameOpt      = "0";
  TypeOpt      = "unknown";
  Jastfunction = "unknown";
  SpinOpt      = "no";
}

Member Function Documentation

buildComponent()

std::unique_ptr< WaveFunctionComponent > buildComponent ( xmlNodePtr  cur )

overridevirtual

process a xml node at cur

Implements WaveFunctionComponentBuilder.

Definition at line 508 of file RadialJastrowBuilder.cpp.

References OhmmsAttributeSet::add(), SpeciesSet::addAttribute(), APP_ABORT, qmcplusplus::app_error(), qmcplusplus::app_summary(), Communicate::barrier_and_abort(), PlatformSelector< KIND >::candidate_values(), MPIObjectBase::ClassName, qmcplusplus::DC_POS_OFFLOAD, ParticleSet::getCoordinates(), DynamicCoordinates::getKind(), OhmmsElementBase::getName(), ParticleSet::getSpeciesSet(), RadialJastrowBuilder::guardAgainstOBC(), RadialJastrowBuilder::guardAgainstPBC(), qmcplusplus::is_same(), RadialJastrowBuilder::Jastfunction, qmcplusplus::lowerCase(), MPIObjectBase::myComm, RadialJastrowBuilder::NameOpt, qmcplusplus::OMPTARGET, RadialJastrowBuilder::OMPTARGET, OhmmsAttributeSet::put(), PlatformSelector< KIND >::selectPlatform(), RadialJastrowBuilder::SpinOpt, WaveFunctionComponentBuilder::targetPtcl, and RadialJastrowBuilder::TypeOpt.

Referenced by JastrowBuilder::buildOneBody(), JastrowBuilder::buildTwoBody(), qmcplusplus::doSOECPotentialTest(), qmcplusplus::TEST_CASE(), qmcplusplus::test_J1_spline(), and qmcplusplus::testTrialWaveFunction_diamondC_2x1x1().

{
  ReportEngine PRE(ClassName, "put(xmlNodePtr)");
  std::string useGPU;
  OhmmsAttributeSet aAttrib;
  aAttrib.add(NameOpt, "name");
  aAttrib.add(TypeOpt, "type");
  aAttrib.add(Jastfunction, "function");
  aAttrib.add(SpinOpt, "spin", {"no", "yes"});
  aAttrib.add(useGPU, "gpu", CPUOMPTargetSelector::candidate_values);
  aAttrib.put(cur);
  NameOpt      = lowerCase(NameOpt);
  TypeOpt      = lowerCase(TypeOpt);
  Jastfunction = lowerCase(Jastfunction);
  SpinOpt      = lowerCase(SpinOpt);

  SpeciesSet& species(targetPtcl.getSpeciesSet());
  int chargeInd = species.addAttribute("charge");

  if (TypeOpt.find("one") < TypeOpt.size())
  {
    // it's a one body jastrow factor
    if (Jastfunction == "bspline")
    {
      if (SpinOpt == "yes")
        return createJ1<BsplineFunctor<RealType>, true>(cur);
      else
        return createJ1<BsplineFunctor<RealType>>(cur);
    }
    else if (Jastfunction == "pade")
    {
      guardAgainstPBC();
      if (SpinOpt == "yes")
        return createJ1<PadeFunctor<RealType>, true>(cur);
      else
        return createJ1<PadeFunctor<RealType>>(cur);
    }
    else if (Jastfunction == "pade2")
    {
      guardAgainstPBC();
      return createJ1<Pade2ndOrderFunctor<RealType>>(cur);
    }
    else if (Jastfunction == "shortrangecusp")
    {
      //guardAgainstPBC(); // is this needed?
      if (SpinOpt == "yes")
        return createJ1<ShortRangeCuspFunctor<RealType>, true>(cur);
      else
        return createJ1<ShortRangeCuspFunctor<RealType>>(cur);
    }
    else if (Jastfunction == "user")
    {
      if (SpinOpt == "yes")
        return createJ1<UserFunctor<RealType>, true>(cur);
      else
        return createJ1<UserFunctor<RealType>>(cur);
    }
    else if (Jastfunction == "rpa")
    {
#if !(OHMMS_DIM == 3)
      app_error() << "RPA for one-body jastrow is only available for 3D\n";
#endif
      guardAgainstOBC();
      app_error() << "one body RPA jastrow is not supported at the moment\n";
      //return createJ1<RPAFunctor>(cur);
    }
    else
      app_error() << "Unknown one jastrow body function: " << Jastfunction << ".\n";
  }
  else if (TypeOpt.find("two") < TypeOpt.size())
  {
    // it's a two body jastrow factor
    if (Jastfunction == "bspline")
    {
      if (useGPU.empty())
        useGPU = targetPtcl.getCoordinates().getKind() == DynamicCoordinateKind::DC_POS_OFFLOAD ? "yes" : "no";

      if (CPUOMPTargetSelector::selectPlatform(useGPU) == PlatformKind::OMPTARGET)
      {
        static_assert(std::is_same<JastrowTypeHelper<BsplineFunctor<RealType>, OMPTARGET>::J2Type,
                                   TwoBodyJastrow<BsplineFunctor<RealType>>>::value,
                      "check consistent type");
        if (targetPtcl.getCoordinates().getKind() != DynamicCoordinateKind::DC_POS_OFFLOAD)
        {
          std::ostringstream msg;
          msg << R"(Offload enabled Jastrow needs the gpu="yes" attribute in the ")" << targetPtcl.getName()
              << "\" particleset" << std::endl;
          myComm->barrier_and_abort(msg.str());
        }
        app_summary() << "    Running OpenMP offload code path." << std::endl;
        return createJ2<BsplineFunctor<RealType>, detail::OMPTARGET>(cur);
      }
      else
        return createJ2<BsplineFunctor<RealType>>(cur);
    }
    else if (Jastfunction == "pade")
    {
      guardAgainstPBC();
      return createJ2<PadeFunctor<RealType>>(cur);
    }
    else if (Jastfunction == "user")
    {
      return createJ2<UserFunctor<RealType>>(cur);
    }
    else if (Jastfunction == "rpa" || Jastfunction == "yukawa")
    {
#if !(OHMMS_DIM == 3)
      app_error() << "RPA for one-body jastrow is only available for 3D\n";
#else
      guardAgainstOBC();
      return createJ2<RPAFunctor>(cur);
#endif
    }
    else
      app_error() << "Unknown two jastrow body function: " << Jastfunction << ".\n";
  }

  APP_ABORT("RadialJastrowBuilder::buildComponent not able to create Jastrow!\n");
  return nullptr;
}

computeJ2uk()

void computeJ2uk ( const std::vector< RadFuncType *> &  functors )

private

Definition at line 257 of file RadialJastrowBuilder.cpp.

References DEBUG, ParticleSet::first(), MPIObjectBase::getGroupID(), ParticleSet::getLattice(), ParticleSet::getSimulationCell(), ParticleSet::groups(), MPIObjectBase::is_manager(), OutputManagerClass::isActive(), ParticleSet::last(), RadialJastrowBuilder::NameOpt, outputManager, qmcplusplus::sin(), qmcplusplus::sqrt(), and WaveFunctionComponentBuilder::targetPtcl.

Referenced by RadialJastrowBuilder::createJ2().

{
  const int numPoints = 1000;
  RealType vol        = targetPtcl.getLattice().Volume;
  int nsp             = targetPtcl.groups();
  FILE* fout          = nullptr;
  if (is_manager() && outputManager.isActive(Verbosity::DEBUG))
  {
    std::array<char, 16> fname;
    if (std::snprintf(fname.data(), fname.size(), "uk.%s.g%03d.dat", NameOpt.c_str(), getGroupID()) < 0)
      throw std::runtime_error("Error generating filename");
    fout = fopen(fname.data(), "w");
  }
  for (int iG = 0; iG < targetPtcl.getSimulationCell().getKLists().ksq.size(); iG++)
  {
    RealType Gmag = std::sqrt(targetPtcl.getSimulationCell().getKLists().ksq[iG]);
    RealType sum  = 0.0;
    RealType uk   = 0.0;
    for (int i = 0; i < targetPtcl.groups(); i++)
    {
      int Ni          = targetPtcl.last(i) - targetPtcl.first(i);
      RealType aparam = 0.0;
      for (int j = 0; j < targetPtcl.groups(); j++)
      {
        int Nj = targetPtcl.last(j) - targetPtcl.first(j);
        if (functors[i * nsp + j])
        {
          auto& ufunc     = *functors[i * nsp + j];
          RealType radius = ufunc.cutoff_radius;
          RealType k      = Gmag;
          RealType dr     = radius / (RealType)(numPoints - 1);
          for (int ir = 0; ir < numPoints; ir++)
          {
            RealType r = dr * (RealType)ir;
            RealType u = ufunc.evaluate(r);
            aparam += (1.0 / 4.0) * k * k * 4.0 * M_PI * r * std::sin(k * r) / k * u * dr;
            uk += 0.5 * 4.0 * M_PI * r * std::sin(k * r) / k * u * dr * (RealType)Nj / (RealType)(Ni + Nj);
          }
        }
      }
      //app_log() << "A = " << aparam << std::endl;
      sum += Ni * aparam / vol;
    }
    if (fout)
      fprintf(fout, "%1.8f %1.12e %1.12e\n", Gmag, uk, sum);
  }
  if (fout)
    fclose(fout);
}

createJ1() [1/2]

std::unique_ptr< WaveFunctionComponent > createJ1 ( xmlNodePtr  cur )

private

Definition at line 317 of file RadialJastrowBuilder.cpp.

References OhmmsAttributeSet::add(), qmcplusplus::app_summary(), Communicate::barrier_and_abort(), PlatformSelector< KIND >::candidate_values(), castXMLCharToChar(), MPIObjectBase::ClassName, qmcplusplus::DC_POS_OFFLOAD, DEBUG, ReportEngine::error(), qmcplusplus::extractCoefficientsID(), SpeciesSet::findSpecies(), ParticleSet::getCoordinates(), MPIObjectBase::getGroupID(), DynamicCoordinates::getKind(), ParticleSet::getLattice(), OhmmsElementBase::getName(), ParticleSet::getSpeciesSet(), SpeciesSet::getTotalNum(), getXMLAttributeValue(), MPIObjectBase::is_manager(), OutputManagerClass::isActive(), RadialJastrowBuilder::Jastfunction, qmcplusplus::lowerCase(), MPIObjectBase::myComm, RadialJastrowBuilder::NameOpt, qmcplusplus::OMPTARGET, outputManager, qmcplusplus::print(), OhmmsAttributeSet::put(), PlatformSelector< KIND >::selectPlatform(), RadialJastrowBuilder::SourcePtcl, qmcplusplus::SUPERCELL_OPEN, and WaveFunctionComponentBuilder::targetPtcl.

{
  ReportEngine PRE(ClassName, "createJ1(xmlNodePtr)");
  using Real   = typename RadFuncType::real_type;
  using TH     = JastrowTypeHelper<RadFuncType, Implementation>;
  using J1Type = typename std::conditional<SPIN, typename TH::J1SpinType, typename TH::J1Type>::type;

  std::string input_name(getXMLAttributeValue(cur, "name"));
  std::string jname = input_name.empty() ? Jastfunction : input_name;

  std::string useGPU;
  OhmmsAttributeSet attr;
  attr.add(useGPU, "gpu", CPUOMPTargetSelector::candidate_values);
  attr.put(cur);

  if (useGPU.empty())
    useGPU = SourcePtcl->getCoordinates().getKind() == DynamicCoordinateKind::DC_POS_OFFLOAD ? "yes" : "no";

  bool use_offload = false;
  if (CPUOMPTargetSelector::selectPlatform(useGPU) == PlatformKind::OMPTARGET)
  {
    if (SourcePtcl->getCoordinates().getKind() != DynamicCoordinateKind::DC_POS_OFFLOAD)
    {
      std::ostringstream msg;
      msg << R"(Offload enabled Jastrow needs the gpu="yes" attribute in the ")" << SourcePtcl->getName()
          << "\" particleset" << std::endl;
      myComm->barrier_and_abort(msg.str());
    }
    app_summary() << "    Running OpenMP offload code path." << std::endl;
    use_offload = true;
  }

  auto J1 = std::make_unique<J1Type>(jname, *SourcePtcl, targetPtcl, use_offload);

  xmlNodePtr kids = cur->xmlChildrenNode;

  // Find the number of the source species
  SpeciesSet& sSet = SourcePtcl->getSpeciesSet();
  SpeciesSet& tSet = targetPtcl.getSpeciesSet();
  bool success     = false;
  while (kids != NULL)
  {
    std::string kidsname(lowerCase(castXMLCharToChar(kids->name)));
    if (kidsname == "correlation")
    {
      std::string speciesA;
      std::string speciesB;
      RealType cusp(0);
      OhmmsAttributeSet rAttrib;
      rAttrib.add(speciesA, "elementType");
      rAttrib.add(speciesA, "speciesA");
      rAttrib.add(speciesB, "speciesB");
      rAttrib.add(cusp, "cusp");
      rAttrib.put(kids);

      const auto coef_id = extractCoefficientsID(kids);
      auto functor       = std::make_unique<RadFuncType>(coef_id.empty() ? jname + "_" + speciesA + speciesB : coef_id);
      functor->setPeriodic(SourcePtcl->getLattice().SuperCellEnum != SUPERCELL_OPEN);
      functor->cutoff_radius = targetPtcl.getLattice().WignerSeitzRadius;
      functor->setCusp(cusp);
      const int ig = sSet.findSpecies(speciesA);
      const int jg = speciesB.size() ? tSet.findSpecies(speciesB) : -1;
      if (ig == sSet.getTotalNum())
      {
        PRE.error("species " + speciesA + " requested for Jastrow " + jname + " does not exist in ParticleSet " +
                      SourcePtcl->getName(),
                  true);
      }
      if (jg == tSet.getTotalNum())
      {
        PRE.error("species " + speciesB + " requested for Jastrow " + jname + " does not exist in ParticleSet " +
                      targetPtcl.getName(),
                  true);
      }
      app_summary() << "    Radial function for element: " << speciesA << " - "
                    << (speciesB.empty() ? targetPtcl.getName() : speciesB) << std::endl;
      functor->put(kids);
      app_summary() << std::endl;
      if (is_manager() && outputManager.isActive(Verbosity::DEBUG))
      {
        std::array<char, 128> fname;
        int fname_len{0};
        if (speciesB.size())
          fname_len = std::snprintf(fname.data(), fname.size(), "%s.%s.%s%s.g%03d.dat", jname.c_str(), NameOpt.c_str(),
                                    speciesA.c_str(), speciesB.c_str(), getGroupID());
        else
          fname_len = std::snprintf(fname.data(), fname.size(), "%s.%s.%s.g%03d.dat", jname.c_str(), NameOpt.c_str(),
                                    speciesA.c_str(), getGroupID());
        if (fname_len < 0)
          throw std::runtime_error("Error generating filename");
        std::ofstream os(std::string(fname.data(), fname_len));
        if constexpr (std::is_same_v<RadFuncType, PadeFunctor<RealType>> ||
                      std::is_same_v<RadFuncType, Pade2ndOrderFunctor<RealType>>)
        {
          double plotextent = 10.0;
          print(*functor.get(), os, plotextent);
        }
        else
        {
          print(*functor.get(), os);
        }
      }
      J1->addFunc(ig, std::move(functor), jg);
      success = true;
    }
    kids = kids->next;
  }

  // sanity check before returning the constructed J1
  J1->checkSanity();

  if (success)
    return J1;
  else
  {
    PRE.error("BsplineJastrowBuilder failed to add an One-Body Jastrow.");
    return std::unique_ptr<WaveFunctionComponent>();
  }
}

createJ1() [2/2]

std::unique_ptr<WaveFunctionComponent> createJ1 ( xmlNodePtr  cur )

private

Definition at line 439 of file RadialJastrowBuilder.cpp.

References OhmmsAttributeSet::add(), ParameterSet::add(), qmcplusplus::app_log(), qmcplusplus::Units::charge::e, qmcplusplus::pow(), ParameterSet::put(), OhmmsAttributeSet::put(), LinearGrid< T, CT >::set(), and ShortRangePartAdapter< T >::setRmax().

{
  using Real             = RealType;
  using SplineEngineType = CubicBspline<Real, LINEAR_1DGRID, FIRSTDERIV_CONSTRAINTS>;
  using RadFunctorType   = CubicSplineSingle<Real, SplineEngineType>;
  using GridType         = LinearGrid<Real>;
  using HandlerType      = LRHandlerBase;
  using J1Type           = J1OrbitalSoA<RadFunctorType>;

  std::string input_name;
  std::string rpafunc = "RPA";
  OhmmsAttributeSet a;
  a.add(input_name, "name");
  a.add(rpafunc, "function");
  a.put(cur);
  ParameterSet params;
  RealType Rs(-1.0);
  RealType Kc(-1.0);
  params.add(Rs, "rs");
  params.add(Kc, "kc");
  params.put(cur);

  std::string jname = input_name.empty() ? Jastfunction : input_name;

  HandlerType* myHandler = nullptr;
  if (Rs < 0)
  {
    Rs = std::pow(3.0 / 4.0 / M_PI * targetPtcl.getLattice().Volume / static_cast<RealType>(targetPtcl.getTotalNum()),
                  1.0 / 3.0);
  }
  if (Kc < 0)
  {
    Kc = 1e-6;
  }
  if (rpafunc == "RPA")
  {
    myHandler = new LRRPAHandlerTemp<EPRPABreakup<RealType>, LPQHIBasis>(targetPtcl, Kc);
    app_log() << "  using e-p RPA" << std::endl;
  }
  else if (rpafunc == "dRPA")
  {
    myHandler = new LRRPAHandlerTemp<derivEPRPABreakup<RealType>, LPQHIBasis>(targetPtcl, Kc);
    app_log() << "  using e-p derivRPA" << std::endl;
  }
  myHandler->Breakup(targetPtcl, Rs);

  Real Rcut        = myHandler->get_rc() - 0.1;
  GridType* myGrid = new GridType;
  int npts         = static_cast<int>(Rcut / 0.01) + 1;
  myGrid->set(0, Rcut, npts);

  //create the numerical functor
  auto nfunc                       = std::make_unique<RadFunctorType>();
  ShortRangePartAdapter<Real>* SRA = new ShortRangePartAdapter<Real>(myHandler);
  SRA->setRmax(Rcut);
  nfunc->initialize(SRA, myGrid);

  auto J1 = std::make_unique<J1Type>(jname, *SourcePtcl, targetPtcl, false);

  SpeciesSet& sSet = SourcePtcl->getSpeciesSet();
  for (int ig = 0; ig < sSet.getTotalNum(); ig++)
  {
    J1->addFunc(ig, std::move(nfunc));
  }

  return J1;
}

createJ2() [1/2]

std::unique_ptr< WaveFunctionComponent > createJ2 ( xmlNodePtr  cur )

private

Definition at line 133 of file RadialJastrowBuilder.cpp.

References OhmmsAttributeSet::add(), app_debug, qmcplusplus::app_summary(), MPIObjectBase::ClassName, RadialJastrowBuilder::computeJ2uk(), DEBUG, ReportEngine::error(), qmcplusplus::extractCoefficientsID(), ParticleSet::first(), MPIObjectBase::getGroupID(), ParticleSet::getLattice(), OhmmsElementBase::getName(), ParticleSet::getSpeciesSet(), getXMLAttributeValue(), RadialJastrowBuilder::initTwoBodyFunctor(), MPIObjectBase::is_manager(), OutputManagerClass::isActive(), RadialJastrowBuilder::Jastfunction, ParticleSet::last(), RadialJastrowBuilder::NameOpt, outputManager, qmcplusplus::print(), OhmmsAttributeSet::put(), qmcplusplus::SUPERCELL_OPEN, WaveFunctionComponentBuilder::targetPtcl, and ReportEngine::warning().

{
  ReportEngine PRE(ClassName, "createJ2(xmlNodePtr)");
  using Real   = typename RadFuncType::real_type;
  using J2Type = typename JastrowTypeHelper<RadFuncType, Implementation>::J2Type;

  std::string input_name(getXMLAttributeValue(cur, "name"));
  std::string j2name = input_name.empty() ? "J2_" + Jastfunction : input_name;
  const size_t ndim  = targetPtcl.getLattice().ndim;
  SpeciesSet& species(targetPtcl.getSpeciesSet());
  auto J2 = std::make_unique<J2Type>(j2name, targetPtcl, Implementation == RadialJastrowBuilder::detail::OMPTARGET);

  std::string init_mode("0");
  {
    OhmmsAttributeSet hAttrib;
    hAttrib.add(init_mode, "init");
    hAttrib.put(cur);
  }

  cur = cur->xmlChildrenNode;
  while (cur != NULL)
  {
    std::string cname((const char*)cur->name);
    if (cname == "correlation")
    {
      OhmmsAttributeSet rAttrib;
      RealType cusp = -1e10;
      std::string spA(species.speciesName[0]);
      std::string spB(species.speciesName[0]);
      std::string pairType("0");
      rAttrib.add(spA, "speciesA");
      rAttrib.add(spB, "speciesB");
      rAttrib.add(pairType, "pairType");
      rAttrib.add(cusp, "cusp");

      rAttrib.put(cur);
      if (pairType[0] == '0')
      {
        pairType = spA + spB;
      }
      else
      {
        PRE.warning("pairType is deprecated. Use speciesA/speciesB");
        //overwrite the species
        spA = pairType[0];
        spB = pairType[1];
      }

      int ia        = species.findSpecies(spA);
      int ib        = species.findSpecies(spB);
      int chargeInd = species.addAttribute("charge");
      int massInd   = species.addAttribute("mass");
      std::string illegal_species;
      if (ia == species.size())
        illegal_species = spA;
      if (ib == species.size())
      {
        if (illegal_species.size())
          illegal_species += " and ";
        illegal_species += spB;
      }
      if (illegal_species.size())
        PRE.error("species " + illegal_species + " requested for Jastrow " + j2name +
                      " does not exist in ParticleSet " + targetPtcl.getName(),
                  true);
      if (ia == ib && (targetPtcl.last(ia) - targetPtcl.first(ia) == 1))
        PRE.error("Failed to add " + spA + spB + " correlation for only 1 " + spA +
                      " particle. Please remove it from two-body Jastrow.",
                  true);
      if (cusp < -1e6)
      { // see eq. (9) in https://arxiv.org/abs/2003.06506
        RealType qq       = species(chargeInd, ia) * species(chargeInd, ib);
        RealType red_mass = species(massInd, ia) * species(massInd, ib) / (species(massInd, ia) + species(massInd, ib));
        RealType dim_factor = (ia == ib) ? 1.0 / (ndim + 1) : 1.0 / (ndim - 1);
        if (ndim == 1)
          dim_factor = 1.0 / (ndim + 1);
        cusp = -2 * qq * red_mass * dim_factor;
      }
      app_summary() << "    Radial function for species: " << spA << " - " << spB << std::endl;
      app_debug() << "    RadialJastrowBuilder adds a functor with cusp = " << cusp << std::endl;

      const auto coef_id = extractCoefficientsID(cur);
      auto functor       = std::make_unique<RadFuncType>(coef_id.empty() ? j2name + "_" + spA + spB : coef_id);
      functor->setCusp(cusp);
      functor->setPeriodic(targetPtcl.getLattice().SuperCellEnum != SUPERCELL_OPEN);
      functor->cutoff_radius   = targetPtcl.getLattice().WignerSeitzRadius;
      bool functor_initialized = functor->put(cur);
      if (!functor_initialized && init_mode == "rpa")
      {
        initTwoBodyFunctor(*functor, -cusp / 0.5);
      }

      app_summary() << std::endl;

      if (is_manager() && outputManager.isActive(Verbosity::DEBUG))
      {
        std::array<char, 32> fname;
        if (std::snprintf(fname.data(), fname.size(), "J2.%s.%s.g%03d.dat", NameOpt.c_str(), pairType.c_str(),
                          getGroupID()) < 0)
          throw std::runtime_error("Error generating filename");
        std::ofstream os(fname.data());
        print(*functor, os);
      }

      J2->addFunc(ia, ib, std::move(functor));
    }
    cur = cur->next;
  }

  // compute Chiesa Correction based on the current J2 parameters
  J2->ChiesaKEcorrection();

  // Ye: actually don't know what uk.dat is used for
  if (targetPtcl.getLattice().SuperCellEnum)
    computeJ2uk(J2->getPairFunctions());

  // sanity check before returning the constructed J2
  J2->checkSanity();

  return J2;
}

createJ2() [2/2]

std::unique_ptr<WaveFunctionComponent> createJ2 ( xmlNodePtr  cur )

private

Definition at line 309 of file RadialJastrowBuilder.cpp.

{
  auto rpajastrow = std::make_unique<RPAJastrow>(targetPtcl);
  rpajastrow->put(cur);
  return rpajastrow;
}

guardAgainstOBC()

void guardAgainstOBC ( )

private

Definition at line 78 of file RadialJastrowBuilder.cpp.

References qmcplusplus::app_error(), ParticleSet::getLattice(), RadialJastrowBuilder::Jastfunction, qmcplusplus::SUPERCELL_OPEN, and WaveFunctionComponentBuilder::targetPtcl.

Referenced by RadialJastrowBuilder::buildComponent().

{
  if (targetPtcl.getLattice().SuperCellEnum == SUPERCELL_OPEN)
  {
    app_error() << Jastfunction << " relies on the total density for its form\n";
    app_error() << "but open boundary conditions are requested.  Please choose other forms of Jastrow\n";
  }
}

guardAgainstPBC()

void guardAgainstPBC ( )

private

Definition at line 88 of file RadialJastrowBuilder.cpp.

References qmcplusplus::app_error(), ParticleSet::getLattice(), RadialJastrowBuilder::Jastfunction, qmcplusplus::SUPERCELL_OPEN, and WaveFunctionComponentBuilder::targetPtcl.

Referenced by RadialJastrowBuilder::buildComponent().

{
  if (targetPtcl.getLattice().SuperCellEnum != SUPERCELL_OPEN)
  {
    app_error() << Jastfunction << " does not support a cutoff, but is requested with\n";
    app_error() << "periodic boundary conditions, please choose other forms of Jastrow\n";
  }
}

initTwoBodyFunctor() [1/2]

void initTwoBodyFunctor ( RadFuncType &  functor, double  fac  )

private

Definition at line 98 of file RadialJastrowBuilder.cpp.

Referenced by RadialJastrowBuilder::createJ2().

{}

initTwoBodyFunctor() [2/2]

void initTwoBodyFunctor	(	BsplineFunctor< RealType > &	bfunc,
		double	fac
	)

Definition at line 102 of file RadialJastrowBuilder.cpp.

References qmcplusplus::app_log(), LRRPAHandlerTemp< Func, BreakupBasis >::Breakup(), OptimizableFunctorBase::cutoff_radius, LRRPAHandlerTemp< Func, BreakupBasis >::evaluate(), ParticleSet::getLattice(), BsplineFunctor< REAL >::NumParams, BsplineFunctor< REAL >::Parameters, BsplineFunctor< REAL >::reset(), qmcplusplus::SUPERCELL_OPEN, and WaveFunctionComponentBuilder::targetPtcl.

{
  if (targetPtcl.getLattice().SuperCellEnum == SUPERCELL_OPEN) // for open systems, do nothing
  {
    return;
  }
  app_log() << "  Initializing Two-Body with RPA Jastrow " << std::endl;
  std::vector<RealType> rpaValues;
  int npts = bfunc.NumParams;
  if (rpaValues.empty())
  {
    rpaValues.resize(npts);
    LRRPAHandlerTemp<RPABreakup<RealType>, LPQHIBasis> rpa(targetPtcl, -1.0);
    rpa.Breakup(targetPtcl, -1.0);
    RealType dr = bfunc.cutoff_radius / static_cast<RealType>(npts);
    RealType r  = 0;
    for (int i = 0; i < npts; i++)
    {
      rpaValues[i] = rpa.evaluate(r, 1.0 / r); //y[i]=fac*rpa.evaluate(r,1.0/r);
      r += dr;
    }
  }
  RealType last = rpaValues[npts - 1];

  for (int i = 0; i < npts; i++)
    bfunc.Parameters[i] = fac * (rpaValues[i] - last);
  bfunc.reset();
}

Member Data Documentation

Jastfunction

std::string Jastfunction

private

<jastrow function="...">

Definition at line 56 of file RadialJastrowBuilder.h.

Referenced by RadialJastrowBuilder::buildComponent(), RadialJastrowBuilder::createJ1(), RadialJastrowBuilder::createJ2(), RadialJastrowBuilder::guardAgainstOBC(), RadialJastrowBuilder::guardAgainstPBC(), and RadialJastrowBuilder::RadialJastrowBuilder().

NameOpt

std::string NameOpt

private

<jastrow name="...">

Definition at line 52 of file RadialJastrowBuilder.h.

Referenced by RadialJastrowBuilder::buildComponent(), RadialJastrowBuilder::computeJ2uk(), RadialJastrowBuilder::createJ1(), RadialJastrowBuilder::createJ2(), and RadialJastrowBuilder::RadialJastrowBuilder().

SourcePtcl

ParticleSet* SourcePtcl

private

particle set for source particle

Definition at line 60 of file RadialJastrowBuilder.h.

Referenced by RadialJastrowBuilder::createJ1().

SpinOpt

std::string SpinOpt

private

<jastrow spin="...">

Definition at line 58 of file RadialJastrowBuilder.h.

Referenced by RadialJastrowBuilder::buildComponent(), and RadialJastrowBuilder::RadialJastrowBuilder().

TypeOpt

std::string TypeOpt

private

<jastrow type="...">

Definition at line 54 of file RadialJastrowBuilder.h.

Referenced by RadialJastrowBuilder::buildComponent(), and RadialJastrowBuilder::RadialJastrowBuilder().

---

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

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