HamiltonianFactory Class Reference

Factory class to build a many-body wavefunction. More...

Inheritance diagram for HamiltonianFactory:

Collaboration diagram for HamiltonianFactory:

Public Types
using	PSetMap = std::map< std::string, const std::unique_ptr< ParticleSet > >
using	PsiPoolType = std::map< std::string, const std::unique_ptr< TrialWaveFunction > >
Public Types inherited from MPIObjectBase
using	mpi_comm_type = Communicate::mpi_comm_type

Public Member Functions
	HamiltonianFactory (const std::string &hName, ParticleSet &qp, const PSetMap &pset, const PsiPoolType &oset, Communicate *c)
	constructor More...
bool	put (xmlNodePtr cur)
	read from xmlNode More...
void	renameProperty (const std::string &a, const std::string &b)
	add a property whose name will be renamed by b More...
void	renameProperty (std::string &a)
	renamd a property More...
QMCHamiltonian *	getH () const
	get targetH More...
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
bool	build (xmlNodePtr cur)
	process xmlNode to populate targetPsi More...
void	addCoulombPotential (xmlNodePtr cur)
void	addForceHam (xmlNodePtr cur)
void	addPseudoPotential (xmlNodePtr cur)
void	addMPCPotential (xmlNodePtr cur, bool physical=false)

Private Attributes
int	PBCType
	type of the lattice. 0=non-periodic, 1=periodic More...
std::unique_ptr< QMCHamiltonian >	targetH
	many-body wavefunction object More...
ParticleSet &	targetPtcl
	target ParticleSet More...
const PSetMap &	ptclPool
	reference to the PSetMap More...
const PsiPoolType &	psiPool
	reference to the TrialWaveFunction Pool More...
std::string	psiName
	name of the TrialWaveFunction More...
std::map< std::string, std::string >	RenamedProperty
	list of the old to new name More...

Additional Inherited Members
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

Factory class to build a many-body wavefunction.

Definition at line 28 of file HamiltonianFactory.h.

Member Typedef Documentation

PSetMap

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

Definition at line 31 of file HamiltonianFactory.h.

PsiPoolType

using PsiPoolType = std::map<std::string, const std::unique_ptr<TrialWaveFunction> >

Definition at line 32 of file HamiltonianFactory.h.

Constructor & Destructor Documentation

HamiltonianFactory()

HamiltonianFactory	(	const std::string &	hName,
		ParticleSet &	qp,
		const PSetMap &	pset,
		const PsiPoolType &	oset,
		Communicate *	c
	)

constructor

Definition at line 56 of file HamiltonianFactory.cpp.

References MPIObjectBase::ClassName, ParticleSet::getLattice(), MPIObjectBase::myName, HamiltonianFactory::PBCType, ParticleSet::set_quantum(), and HamiltonianFactory::targetPtcl.

    : MPIObjectBase(c),
      targetH(std::make_unique<QMCHamiltonian>(hName)),
      targetPtcl(qp),
      ptclPool(pset),
      psiPool(oset),
      psiName("psi0")
{
  //PBCType is zero or 1 but should be generalized
  PBCType   = targetPtcl.getLattice().SuperCellEnum;
  ClassName = "HamiltonianFactory";
  myName    = hName;
  targetPtcl.set_quantum();
}

Member Function Documentation

addCoulombPotential()

void addCoulombPotential ( xmlNodePtr  cur )

private

Definition at line 78 of file CoulombPotentialFactory.cpp.

References OhmmsAttributeSet::add(), APP_ABORT, qmcplusplus::app_log(), qmcplusplus::app_summary(), PlatformSelector< KIND >::candidate_values(), qmcplusplus::DC_POS_OFFLOAD, ERRORMSG, ParticleSet::get(), ParticleSet::getCoordinates(), DynamicCoordinates::getKind(), OhmmsElementBase::getName(), ParticleSet::getTotalNum(), qmcplusplus::OMPTARGET, HamiltonianFactory::PBCType, HamiltonianFactory::ptclPool, OhmmsAttributeSet::put(), PlatformSelector< KIND >::selectPlatform(), HamiltonianFactory::targetH, and HamiltonianFactory::targetPtcl.

Referenced by HamiltonianFactory::build().

{
  using Return_t = QMCHamiltonian::FullPrecRealType;
  std::string targetInp(targetPtcl.getName());
  std::string sourceInp(targetPtcl.getName());
  std::string title("ElecElec"), pbc("yes");
  std::string forces("no");
  std::string use_gpu;
  bool physical = true;
  OhmmsAttributeSet hAttrib;
  hAttrib.add(title, "id");
  hAttrib.add(title, "name");
  hAttrib.add(targetInp, "target");
  hAttrib.add(sourceInp, "source");
  hAttrib.add(pbc, "pbc");
  hAttrib.add(physical, "physical");
  hAttrib.add(forces, "forces");
  hAttrib.add(use_gpu, "gpu", CPUOMPTargetSelector::candidate_values);
  hAttrib.put(cur);
  const bool applyPBC = (PBCType && pbc == "yes");
  const bool doForces = (forces == "yes") || (forces == "true");

  app_summary() << std::endl;
  app_summary() << "   Coulomb Potential" << std::endl;
  app_summary() << "   -----------------" << std::endl;
  app_summary() << "    Name: " << title << "   Type: " << (sourceInp == targetInp ? "AA" : "AB")
                << "   PBC: " << (applyPBC ? "yes" : "no") << std::endl;
  app_summary() << std::endl;

  ParticleSet* ptclA = &targetPtcl;
  if (sourceInp != targetPtcl.getName())
  {
    //renameProperty(sourceInp);
    auto pit(ptclPool.find(sourceInp));
    if (pit == ptclPool.end())
    {
      ERRORMSG("Missing source ParticleSet" << sourceInp);
      APP_ABORT("HamiltonianFactory::addCoulombPotential");
      return;
    }
    ptclA = pit->second.get();
  }

  if (sourceInp == targetInp) // AA type
  {
    if (!applyPBC && ptclA->getTotalNum() == 1)
    {
      app_log() << "  CoulombAA for " << sourceInp << " is not created.  Number of particles == 1 and nonPeriodic"
                << std::endl;
      return;
    }
    bool quantum = (sourceInp == targetPtcl.getName());
    if (applyPBC)
    {
      if (use_gpu.empty())
        use_gpu = ptclA->getCoordinates().getKind() == DynamicCoordinateKind::DC_POS_OFFLOAD ? "yes" : "no";

      const bool use_offload = CPUOMPTargetSelector::selectPlatform(use_gpu) == PlatformKind::OMPTARGET;
      if (use_offload)
        app_summary() << "    Running OpenMP offload code path." << std::endl;
      if (use_offload && ptclA->getCoordinates().getKind() != DynamicCoordinateKind::DC_POS_OFFLOAD)
        throw std::runtime_error("Requested OpenMP offload in CoulombPBCAA but the particle set has gpu=no.");

      targetH->addOperator(std::make_unique<CoulombPBCAA>(*ptclA, quantum, doForces, use_offload), title, physical);
    }
    else
    {
      targetH->addOperator(std::make_unique<CoulombPotential<Return_t>>(*ptclA, quantum, doForces), title, physical);
    }
  }
  else //X-e type, for X=some other source
  {
    if (applyPBC)
      targetH->addOperator(std::make_unique<CoulombPBCAB>(*ptclA, targetPtcl), title);
    else
      targetH->addOperator(std::make_unique<CoulombPotential<Return_t>>(*ptclA, targetPtcl, true), title);
  }
}

addForceHam()

void addForceHam ( xmlNodePtr  cur )

private

Definition at line 157 of file CoulombPotentialFactory.cpp.

References OhmmsAttributeSet::add(), APP_ABORT, qmcplusplus::app_log(), ERRORMSG, ParticleSet::get(), OhmmsElementBase::getName(), HamiltonianFactory::PBCType, HamiltonianFactory::psiPool, HamiltonianFactory::ptclPool, OhmmsAttributeSet::put(), TrialWaveFunction::put(), HamiltonianFactory::renameProperty(), HamiltonianFactory::targetH, and HamiltonianFactory::targetPtcl.

Referenced by HamiltonianFactory::build().

{
#if OHMMS_DIM == 3
  std::string a("ion0"), targetName("e"), title("ForceBase"), pbc("yes"), PsiName = "psi0";
  OhmmsAttributeSet hAttrib;
  std::string mode("bare");
  //hAttrib.add(title,"id");
  hAttrib.add(title, "name");
  hAttrib.add(a, "source");
  hAttrib.add(targetName, "target");
  hAttrib.add(pbc, "pbc");
  hAttrib.add(mode, "mode");
  hAttrib.add(PsiName, "psi");
  hAttrib.put(cur);
  app_log() << "HamFac forceBase mode " << mode << std::endl;
  bool applyPBC = (PBCType && pbc == "yes");

  bool quantum = (a == targetPtcl.getName());

  renameProperty(a);
  auto pit(ptclPool.find(a));
  if (pit == ptclPool.end())
  {
    ERRORMSG("Missing source ParticleSet" << a)
    return;
  }
  ParticleSet* source = pit->second.get();
  pit                 = ptclPool.find(targetName);
  if (pit == ptclPool.end())
  {
    ERRORMSG("Missing target ParticleSet" << targetName)
    return;
  }
  ParticleSet* target = pit->second.get();
  //bool applyPBC= (PBCType && pbc=="yes");
  if (mode == "bare")
  {
    std::unique_ptr<BareForce> bareforce = std::make_unique<BareForce>(*source, *target);
    bareforce->put(cur);
    targetH->addOperator(std::move(bareforce), title, false);
  }
  else if (mode == "cep")
  {
    if (applyPBC == true)
    {
      std::unique_ptr<ForceChiesaPBCAA> force_chi = std::make_unique<ForceChiesaPBCAA>(*source, *target, true);
      force_chi->put(cur);
      targetH->addOperator(std::move(force_chi), title, false);
    }
    else
    {
      std::unique_ptr<ForceCeperley> force_cep = std::make_unique<ForceCeperley>(*source, *target);
      force_cep->put(cur);
      targetH->addOperator(std::move(force_cep), title, false);
    }
  }
  else if (mode == "acforce")
  {
    app_log() << "Adding Assaraf-Caffarel total force.\n";
    auto psi_it(psiPool.find(PsiName));
    if (psi_it == psiPool.end())
    {
      APP_ABORT("Unknown psi \"" + PsiName + "\" for zero-variance force.");
    }
    TrialWaveFunction& psi           = *psi_it->second;
    std::unique_ptr<ACForce> acforce = std::make_unique<ACForce>(*source, *target, psi, *targetH);
    acforce->put(cur);
    targetH->addOperator(std::move(acforce), title, false);
  }
  else
  {
    ERRORMSG("Failed to recognize Force mode " << mode);
  }
#endif
}

addMPCPotential()

void addMPCPotential ( xmlNodePtr  cur, bool  physical = false  )

private

Definition at line 41 of file CoulombPotentialFactory.cpp.

References OhmmsAttributeSet::add(), APP_ABORT, qmcplusplus::app_summary(), Communicate::barrier_and_abort(), ParticleSet::Density_G, MPIObjectBase::myComm, OhmmsAttributeSet::put(), HamiltonianFactory::renameProperty(), HamiltonianFactory::targetH, and HamiltonianFactory::targetPtcl.

Referenced by HamiltonianFactory::build().

{
#if OHMMS_DIM == 3 && defined(HAVE_LIBFFTW)
  std::string a("e"), title("MPC"), physical("no");
  OhmmsAttributeSet hAttrib;
  double cutoff = 30.0;
  hAttrib.add(title, "id");
  hAttrib.add(title, "name");
  hAttrib.add(cutoff, "cutoff");
  hAttrib.add(physical, "physical");
  hAttrib.put(cur);
  renameProperty(a);
  isphysical = (physical == "yes" || physical == "true");

  app_summary() << std::endl;
  app_summary() << "   MPC Potential" << std::endl;
  app_summary() << "   -------------" << std::endl;
  app_summary() << "    Name: " << title << "   Physical : " << physical << std::endl;
  app_summary() << std::endl;

  if (targetPtcl.Density_G.size() == 0)
    myComm->barrier_and_abort("HamiltonianFactory::addMPCPotential\n"
                              "************************\n"
                              "** Error in MPC setup **\n"
                              "************************\n"
                              "    The electron density was not setup by the "
                              "wave function builder.\n");

  auto mpc = std::make_unique<MPC>(targetPtcl, cutoff);
  targetH->addOperator(std::move(mpc), "MPC", isphysical);
#else
  APP_ABORT(
      "HamiltonianFactory::addMPCPotential MPC is disabled because FFTW3 was not found during the build process.");
#endif // defined(HAVE_LIBFFTW)
}

addPseudoPotential()

void addPseudoPotential ( xmlNodePtr  cur )

private

Definition at line 233 of file CoulombPotentialFactory.cpp.

References OhmmsAttributeSet::add(), APP_ABORT, qmcplusplus::app_summary(), qmcplusplus::app_warning(), ERRORMSG, ParticleSet::get(), MPIObjectBase::myComm, HamiltonianFactory::psiName, HamiltonianFactory::psiPool, HamiltonianFactory::ptclPool, ECPotentialBuilder::put(), OhmmsAttributeSet::put(), HamiltonianFactory::renameProperty(), HamiltonianFactory::targetH, and HamiltonianFactory::targetPtcl.

Referenced by HamiltonianFactory::build().

{
#if OHMMS_DIM == 3
  std::string src("i"), title("PseudoPot"), wfname("invalid"), format("xml");
  OhmmsAttributeSet pAttrib;
  pAttrib.add(title, "name");
  pAttrib.add(src, "source");
  pAttrib.add(wfname, "wavefunction");
  pAttrib.add(format, "format"); //temperary tag to switch between format
  pAttrib.put(cur);
  if (format == "old")
  {
    APP_ABORT("pseudopotential Table format is not supported.");
  }
  renameProperty(src);
  renameProperty(wfname);
  auto pit(ptclPool.find(src));
  if (pit == ptclPool.end())
  {
    ERRORMSG("Missing source ParticleSet" << src)
    return;
  }
  ParticleSet* ion = pit->second.get();
  auto oit(psiPool.find(wfname));
  TrialWaveFunction* psi = 0;
  if (oit == psiPool.end())
  {
    if (psiPool.empty())
      return;
    app_warning() << "  Cannot find " << wfname << " in the Wavefunction pool. Using the first wavefunction."
                  << std::endl;
    psi = psiPool.begin()->second.get();
  }
  else
  {
    psi = (*oit).second.get();
  }
  //remember the TrialWaveFunction used by this pseudopotential
  psiName = wfname;

  app_summary() << std::endl;
  app_summary() << "   Pseudo Potential" << std::endl;
  app_summary() << "   ----------------" << std::endl;
  app_summary() << "    Name: " << title << "   Wavefunction : " << psiName << std::endl;
  app_summary() << std::endl;

  ECPotentialBuilder ecp(*targetH, *ion, targetPtcl, *psi, myComm);
  ecp.put(cur);
#else
  APP_ABORT("HamiltonianFactory::addPseudoPotential\n pairpot@type=\"pseudo\" is invalid if DIM != 3");
#endif
}

build()

bool build ( xmlNodePtr  cur )

private

process xmlNode to populate targetPsi

main hamiltonian build function

Parameters

cur	element node <hamiltonian>
buildtree	if true, build xml tree for a reuse

A valid hamiltonian node contains

Definition at line 88 of file HamiltonianFactory.cpp.

References OhmmsAttributeSet::add(), HamiltonianFactory::addCoulombPotential(), HamiltonianFactory::addForceHam(), HamiltonianFactory::addMPCPotential(), HamiltonianFactory::addPseudoPotential(), APP_ABORT, qmcplusplus::app_log(), qmcplusplus::app_summary(), ParticleSet::get(), OhmmsElementBase::getName(), TrialWaveFunction::getSPOMap(), getXMLAttributeValue(), MPIObjectBase::myComm, MPIObjectBase::myName, HamiltonianFactory::PBCType, processChildren(), HamiltonianFactory::psiName, HamiltonianFactory::psiPool, HamiltonianFactory::ptclPool, OhmmsAttributeSet::put(), Communicate::rank(), HamiltonianFactory::renameProperty(), HamiltonianFactory::targetH, and HamiltonianFactory::targetPtcl.

Referenced by HamiltonianFactory::put().

{
  if (cur == NULL)
    return false;

  app_summary() << std::endl;
  app_summary() << " Hamiltonian and observables" << std::endl;
  app_summary() << " ---------------------------" << std::endl;
  app_summary() << "  Name: " << myName << std::endl;
  app_summary() << std::endl;

  std::string htype("generic"), source("i"), defaultKE("yes");
  OhmmsAttributeSet hAttrib;
  hAttrib.add(htype, "type");
  hAttrib.add(source, "source");
  hAttrib.add(defaultKE, "default");
  hAttrib.put(cur);
  renameProperty(source);
  auto psi_it(psiPool.find(psiName));
  if (psi_it == psiPool.end())
    APP_ABORT("Unknown psi \"" + psiName + "\" for target Psi");
  TrialWaveFunction* targetPsi = psi_it->second.get();
  // KineticEnergy must be the first element in the hamiltonian array.
  if (defaultKE != "no")
    targetH->addOperator(std::make_unique<BareKineticEnergy>(targetPtcl, *targetPsi), "Kinetic");

  // Virtual particle sets only need to carry distance tables used by the wavefunction.
  // Other Hamiltonian elements or estimators may add distance tables in particle sets.
  // Process pseudopotentials first to minimize the needed distance tables in virtual particle sets.
  processChildren(cur, [&](const std::string& cname, const xmlNodePtr element) {
    if (cname == "pairpot" && getXMLAttributeValue(element, "type") == "pseudo")
      addPseudoPotential(element);
  });

  processChildren(cur, [&](const std::string& cname, const xmlNodePtr element) {
    std::string notype = "0";
    std::string noname = "any";
    std::string potType(notype);
    std::string potName(noname);
    std::string potUnit("hartree");
    std::string estType("coulomb");
    std::string sourceInp(targetPtcl.getName());
    std::string targetInp(targetPtcl.getName());
    OhmmsAttributeSet attrib;
    attrib.add(sourceInp, "source");
    attrib.add(sourceInp, "sources");
    attrib.add(targetInp, "target");
    attrib.add(potType, "type");
    attrib.add(potName, "name");
    attrib.add(potUnit, "units");
    attrib.add(estType, "potential");
    attrib.put(element);
    renameProperty(sourceInp);
    renameProperty(targetInp);

    int nham = targetH->total_size();
    if (cname == "pairpot")
    {
      if (potType == "coulomb")
        addCoulombPotential(element);
      else if (potType == "skpot")
      {
        std::unique_ptr<SkPot> hs = std::make_unique<SkPot>(targetPtcl);
        hs->put(element);
        targetH->addOperator(std::move(hs), "SkPot", true);
      }
#if OHMMS_DIM == 3
      else if (potType == "MPC" || potType == "mpc")
        addMPCPotential(element);
#endif
    }
    else if (cname == "constant")
    {
      //just to support old input
      if (potType == "coulomb")
        addCoulombPotential(element);
    }
    else if (cname == "extpot")
    {
      if (potType == "harmonic_ext" || potType == "HarmonicExt")
      {
        std::unique_ptr<HarmonicExternalPotential> hs = std::make_unique<HarmonicExternalPotential>(targetPtcl);
        hs->put(element);
        targetH->addOperator(std::move(hs), "HarmonicExt", true);
      }
      if (potType == "grid")
      {
        std::unique_ptr<GridExternalPotential> hs = std::make_unique<GridExternalPotential>(targetPtcl);
        hs->put(element);
        targetH->addOperator(std::move(hs), "Grid", true);
      }
    }
    else if (cname == "estimator")
    {
      if (potType == "flux")
        targetH->addOperator(std::make_unique<ConservedEnergy>(), potName, false);
      else if (potType == "specieskinetic")
      {
        std::unique_ptr<SpeciesKineticEnergy> apot = std::make_unique<SpeciesKineticEnergy>(targetPtcl);
        apot->put(element);
        targetH->addOperator(std::move(apot), potName, false);
      }
      else if (potType == "latticedeviation")
      {
        // find target particle set
        auto pit(ptclPool.find(targetInp));
        if (pit == ptclPool.end())
        {
          APP_ABORT("Unknown target \"" + targetInp + "\" for LatticeDeviation.");
        }

        // find source particle set
        auto spit(ptclPool.find(sourceInp));
        if (spit == ptclPool.end())
        {
          APP_ABORT("Unknown source \"" + sourceInp + "\" for LatticeDeviation.");
        }

        // read xml node
        OhmmsAttributeSet local_attrib;
        std::string target_group, source_group;
        local_attrib.add(target_group, "tgroup");
        local_attrib.add(source_group, "sgroup");
        local_attrib.put(element);

        std::unique_ptr<LatticeDeviationEstimator> apot =
            std::make_unique<LatticeDeviationEstimator>(*pit->second, *spit->second, target_group, source_group);
        apot->put(element);
        targetH->addOperator(std::move(apot), potName, false);
      }
      else if (potType == "Force")
        addForceHam(element);
      else if (potType == "gofr")
      {
        std::unique_ptr<PairCorrEstimator> apot = std::make_unique<PairCorrEstimator>(targetPtcl, sourceInp);
        apot->put(element);
        targetH->addOperator(std::move(apot), potName, false);
      }
      else if (potType == "density")
      {
        std::unique_ptr<DensityEstimator> apot = std::make_unique<DensityEstimator>(targetPtcl);
        apot->put(element);
        targetH->addOperator(std::move(apot), potName, false);
      }
      else if (potType == "spindensity")
      {
        app_log() << "  Adding SpinDensity" << std::endl;
        std::unique_ptr<SpinDensity> apot = std::make_unique<SpinDensity>(targetPtcl);
        apot->put(element);
        targetH->addOperator(std::move(apot), potName, false);
      }
      else if (potType == "structurefactor")
      {
        app_log() << "  Adding StaticStructureFactor" << std::endl;
        std::unique_ptr<StaticStructureFactor> apot = std::make_unique<StaticStructureFactor>(targetPtcl);
        apot->put(element);
        targetH->addOperator(std::move(apot), potName, false);
      }
      else if (potType == "selfhealingoverlap" || potType == "SelfHealingOverlap")
      {
        app_log() << "  Adding SelfHealingOverlap" << std::endl;
        std::unique_ptr<SelfHealingOverlapLegacy> apot = std::make_unique<SelfHealingOverlapLegacy>(*targetPsi);
        apot->put(element);
        targetH->addOperator(std::move(apot), potName, false);
      }
      else if (potType == "orbitalimages")
      {
        app_log() << "  Adding OrbitalImages" << std::endl;
        std::unique_ptr<OrbitalImages> apot =
            std::make_unique<OrbitalImages>(targetPtcl, ptclPool, myComm, targetPsi->getSPOMap());
        apot->put(element);
        targetH->addOperator(std::move(apot), potName, false);
      }
#if !defined(REMOVE_TRACEMANAGER)
      else if (potType == "energydensity" || potType == "EnergyDensity")
      {
        app_log() << "  Adding EnergyDensityEstimator" << std::endl;
        std::unique_ptr<EnergyDensityEstimator> apot = std::make_unique<EnergyDensityEstimator>(ptclPool, defaultKE);
        apot->put(element);
        targetH->addOperator(std::move(apot), potName, false);
      }
      else if (potType == "dm1b")
      {
        app_log() << "  Adding DensityMatrices1B" << std::endl;
        std::string source = "";
        OhmmsAttributeSet attrib;
        attrib.add(source, "source");
        attrib.put(element);
        auto pit(ptclPool.find(source));
        ParticleSet* Pc = nullptr;
        if (source == "")
          Pc = nullptr;
        else if (pit != ptclPool.end())
          Pc = pit->second.get();
        else
        {
          APP_ABORT("Unknown source \"" + source + "\" for DensityMatrices1B");
        }
        std::unique_ptr<DensityMatrices1B> apot = std::make_unique<DensityMatrices1B>(targetPtcl, *targetPsi, Pc);
        apot->put(element);
        targetH->addOperator(std::move(apot), potName, false);
      }
#endif
      else if (potType == "sk")
      {
        if (PBCType) //only if perioidic
        {
          std::unique_ptr<SkEstimator> apot = std::make_unique<SkEstimator>(targetPtcl);
          apot->put(element);
          targetH->addOperator(std::move(apot), potName, false);
          app_log() << "Adding S(k) estimator" << std::endl;
        }
      }
#if OHMMS_DIM == 3
      else if (potType == "chiesa")
      {
        std::string PsiName    = "psi0";
        std::string SourceName = "e";
        OhmmsAttributeSet hAttrib;
        hAttrib.add(PsiName, "psi");
        hAttrib.add(SourceName, "source");
        hAttrib.put(element);
        auto pit(ptclPool.find(SourceName));
        if (pit == ptclPool.end())
        {
          APP_ABORT("Unknown source \"" + SourceName + "\" for Chiesa correction.");
        }
        ParticleSet& source = *pit->second;
        auto psi_it(psiPool.find(PsiName));
        if (psi_it == psiPool.end())
        {
          APP_ABORT("Unknown psi \"" + PsiName + "\" for Chiesa correction.");
        }
        const TrialWaveFunction& psi             = *psi_it->second;
        std::unique_ptr<ChiesaCorrection> chiesa = std::make_unique<ChiesaCorrection>(source, psi);
        targetH->addOperator(std::move(chiesa), "KEcorr", false);
      }
      else if (potType == "skall")
      {
        std::string SourceName = "";
        OhmmsAttributeSet attrib;
        attrib.add(SourceName, "source");
        attrib.put(element);

        auto pit(ptclPool.find(SourceName));
        if (pit == ptclPool.end())
        {
          APP_ABORT("Unknown source \"" + SourceName + "\" for SkAll.");
        }

        if (PBCType)
        {
          std::unique_ptr<SkAllEstimator> apot = std::make_unique<SkAllEstimator>(*pit->second, targetPtcl);
          apot->put(element);
          targetH->addOperator(std::move(apot), potName, false);
          app_log() << "Adding S(k) ALL estimator" << std::endl;
        }
      }

#endif
      else if (potType == "Pressure")
      {
        if (estType == "coulomb")
        {
          std::unique_ptr<Pressure> BP = std::make_unique<Pressure>(targetPtcl);
          BP->put(element);
          targetH->addOperator(std::move(BP), "Pressure", false);
          int nlen(100);
          attrib.add(nlen, "truncateSum");
          attrib.put(element);
          //             DMCPressureCorr* DMCP = new DMCPressureCorr(targetPtcl,nlen);
          //             targetH->addOperator(DMCP,"PressureSum",false);
        }
      }
      else if (potType == "momentum")
      {
        app_log() << "  Adding Momentum Estimator" << std::endl;
        std::string PsiName = "psi0";
        OhmmsAttributeSet hAttrib;
        hAttrib.add(PsiName, "wavefunction");
        hAttrib.put(element);
        auto psi_it(psiPool.find(PsiName));
        if (psi_it == psiPool.end())
        {
          APP_ABORT("Unknown psi \"" + PsiName + "\" for momentum.");
        }
        std::unique_ptr<MomentumEstimator> ME = std::make_unique<MomentumEstimator>(targetPtcl, *psi_it->second);
        bool rt(myComm->rank() == 0);
        ME->putSpecial(element, targetPtcl, rt);
        targetH->addOperator(std::move(ME), "MomentumEstimator", false);
      }
    }

    if (nham < targetH->total_size()) //if(cname!="text" && cname !="comment")
    {
      if (potName == noname)
      {
        potName = potType;
        app_log() << "Provide name for hamiltonian element for type " << potType << std::endl;
      }
      //APP_ABORT("HamiltonianFactory::build\n  a name for operator of type "+cname+" "+potType+" must be provided in the xml input");
      targetH->addOperatorType(potName, potType);
    }
  });

  //add observables with physical and simple estimators
  targetH->addObservables(targetPtcl);
  //do correction
  bool dmc_correction = false;
  processChildren(cur, [&](const std::string& cname, const xmlNodePtr element) {
    std::string potType("0");
    OhmmsAttributeSet attrib;
    attrib.add(potType, "type");
    attrib.put(element);
    if (cname == "estimator" && potType == "ForwardWalking")
    {
      app_log() << "  Adding Forward Walking Operator" << std::endl;
      std::unique_ptr<ForwardWalking> FW = std::make_unique<ForwardWalking>();
      FW->putSpecial(element, *targetH, targetPtcl);
      targetH->addOperator(std::move(FW), "ForwardWalking", false);
      dmc_correction = true;
    }
  });
  //evaluate the observables again
  if (dmc_correction)
    targetH->addObservables(targetPtcl);
  return true;
}

getH()

QMCHamiltonian* getH ( ) const

inline

get targetH

Definition at line 58 of file HamiltonianFactory.h.

References HamiltonianFactory::targetH.

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

{ return targetH.get(); }

put()

bool put

(

xmlNodePtr

cur

)

read from xmlNode

Definition at line 429 of file HamiltonianFactory.cpp.

References HamiltonianFactory::build().

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

{
  bool success = build(cur);
  return success;
}

renameProperty() [1/2]

void renameProperty	(	const std::string &	a,
		const std::string &	b
	)

add a property whose name will be renamed by b

Parameters

a	target property whose name should be replaced by b
b	new property name

Definition at line 418 of file HamiltonianFactory.cpp.

References HamiltonianFactory::RenamedProperty.

Referenced by HamiltonianFactory::addForceHam(), HamiltonianFactory::addMPCPotential(), HamiltonianFactory::addPseudoPotential(), and HamiltonianFactory::build().

{ RenamedProperty[a] = b; }

renameProperty() [2/2]

void renameProperty

(

std::string &

a

)

renamd a property

Parameters

a	current name

If a is found among the RenamedProperty, a is replaced,

Definition at line 420 of file HamiltonianFactory.cpp.

References HamiltonianFactory::RenamedProperty.

{
  std::map<std::string, std::string>::iterator it(RenamedProperty.find(aname));
  if (it != RenamedProperty.end())
  {
    aname = (*it).second;
  }
}

Member Data Documentation

PBCType

int PBCType

private

type of the lattice. 0=non-periodic, 1=periodic

Definition at line 71 of file HamiltonianFactory.h.

Referenced by HamiltonianFactory::addCoulombPotential(), HamiltonianFactory::addForceHam(), HamiltonianFactory::build(), and HamiltonianFactory::HamiltonianFactory().

psiName

std::string psiName

private

name of the TrialWaveFunction

Definition at line 82 of file HamiltonianFactory.h.

Referenced by HamiltonianFactory::addPseudoPotential(), and HamiltonianFactory::build().

psiPool

const PsiPoolType& psiPool

private

reference to the TrialWaveFunction Pool

Definition at line 79 of file HamiltonianFactory.h.

Referenced by HamiltonianFactory::addForceHam(), HamiltonianFactory::addPseudoPotential(), and HamiltonianFactory::build().

ptclPool

const PSetMap& ptclPool

private

reference to the PSetMap

Definition at line 77 of file HamiltonianFactory.h.

Referenced by HamiltonianFactory::addCoulombPotential(), HamiltonianFactory::addForceHam(), HamiltonianFactory::addPseudoPotential(), and HamiltonianFactory::build().

RenamedProperty

std::map<std::string, std::string> RenamedProperty

private

list of the old to new name

Definition at line 85 of file HamiltonianFactory.h.

Referenced by HamiltonianFactory::renameProperty().

targetH

std::unique_ptr<QMCHamiltonian> targetH

private

many-body wavefunction object

Definition at line 73 of file HamiltonianFactory.h.

Referenced by HamiltonianFactory::addCoulombPotential(), HamiltonianFactory::addForceHam(), HamiltonianFactory::addMPCPotential(), HamiltonianFactory::addPseudoPotential(), HamiltonianFactory::build(), and HamiltonianFactory::getH().

targetPtcl

ParticleSet& targetPtcl

private

target ParticleSet

Definition at line 75 of file HamiltonianFactory.h.

Referenced by HamiltonianFactory::addCoulombPotential(), HamiltonianFactory::addForceHam(), HamiltonianFactory::addMPCPotential(), HamiltonianFactory::addPseudoPotential(), HamiltonianFactory::build(), and HamiltonianFactory::HamiltonianFactory().

---

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

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