LCAOrbitalBuilder Class Reference

SPOSetBuilder using new LCAOrbitalSet and Soa versions. More...

Inheritance diagram for LCAOrbitalBuilder:

Collaboration diagram for LCAOrbitalBuilder:

Public Types
using	BasisSet_t = LCAOrbitalSet::basis_type
using	BasissetMap = std::map< std::string, std::unique_ptr< BasisSet_t > >
Public Types inherited from SPOSetBuilder
using	indices_t = std::vector< int >
using	energies_t = std::vector< RealType >
Public Types inherited from QMCTraits
enum	{ DIM = OHMMS_DIM, DIM_VGL = OHMMS_DIM + 2 }
using	QTBase = QMCTypes< OHMMS_PRECISION, DIM >
using	QTFull = QMCTypes< OHMMS_PRECISION_FULL, DIM >
using	RealType = QTBase::RealType
using	ComplexType = QTBase::ComplexType
using	ValueType = QTBase::ValueType
using	PosType = QTBase::PosType
using	GradType = QTBase::GradType
using	TensorType = QTBase::TensorType
using	IndexType = OHMMS_INDEXTYPE
	define other types More...
using	FullPrecRealType = QTFull::RealType
using	FullPrecValueType = QTFull::ValueType
using	PropertySetType = RecordNamedProperty< FullPrecRealType >
	define PropertyList_t More...
using	PtclGrpIndexes = std::vector< std::pair< int, int > >
Public Types inherited from MPIObjectBase
using	mpi_comm_type = Communicate::mpi_comm_type

Public Member Functions
	LCAOrbitalBuilder (ParticleSet &els, ParticleSet &ions, Communicate *comm, xmlNodePtr cur)
	constructor More...
	~LCAOrbitalBuilder () override
std::unique_ptr< SPOSet >	createSPOSetFromXML (xmlNodePtr cur) override
	create an sposet from xml (legacy) More...
const BasissetMap &	getBasissetMap () const
Public Member Functions inherited from SPOSetBuilder
	SPOSetBuilder (const std::string &type_name, Communicate *comm)
virtual	~SPOSetBuilder ()
void	reserve_states (int nsets=1)
	reserve space for states (usually only one set, multiple for e.g. spin dependent einspline) More...
void	modify_states (int index=0)
	allow modification of state information More...
void	clear_states (int index=0)
	clear state information More...
std::unique_ptr< SPOSet >	createSPOSet (xmlNodePtr cur)
	create an sposet from xml and save the resulting SPOSet More...
std::unique_ptr< SPOSet >	createRotatedSPOSet (xmlNodePtr cur)
	create orbital rotation transformation from xml and save the resulting SPOSet More...
const std::string &	getTypeName () const
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)

Protected Member Functions
template<int I, int J>
BasisSet_t *	createBasisSet (xmlNodePtr cur)
	create basis set More...
template<int I, int J>
BasisSet_t *	createBasisSetH5 ()
bool	loadMO (LCAOrbitalSet &spo, xmlNodePtr cur)
	Parse the xml file for information on the Dirac determinants. More...
bool	putOccupation (LCAOrbitalSet &spo, xmlNodePtr occ_ptr)
bool	putFromXML (LCAOrbitalSet &spo, xmlNodePtr coeff_ptr)
bool	putFromH5 (LCAOrbitalSet &spo, xmlNodePtr coeff_ptr)
	read data from a hdf5 file More...
bool	putPBCFromH5 (LCAOrbitalSet &spo, xmlNodePtr coeff_ptr)
	read data from a hdf5 file More...
void	LoadFullCoefsFromH5 (hdf_archive &hin, int setVal, PosType &SuperTwist, Matrix< std::complex< RealType >> &Ctemp, bool MultiDet)
void	LoadFullCoefsFromH5 (hdf_archive &hin, int setVal, PosType &SuperTwist, Matrix< RealType > &Creal, bool Multidet)
void	EvalPeriodicImagePhaseFactors (PosType SuperTwist, Vector< RealType, OffloadPinnedAllocator< RealType >> &LocPeriodicImagePhaseFactors, Array< RealType, 2, OffloadPinnedAllocator< RealType >> &LocPeriodicImageDisplacements)
	Periodic Image Phase Factors computation to be determined. More...
void	EvalPeriodicImagePhaseFactors (PosType SuperTwist, Vector< std::complex< RealType >, OffloadPinnedAllocator< std::complex< RealType >>> &LocPeriodicImagePhaseFactors, Array< RealType, 2, OffloadPinnedAllocator< RealType >> &LocPeriodicImageDisplacements)
void	readRealMatrixFromH5 (hdf_archive &hin, const std::string &setname, Matrix< LCAOrbitalBuilder::RealType > &Creal) const
	read matrix from h5 file More...
Protected Member Functions inherited from SPOSetBuilder
virtual std::unique_ptr< SPOSet >	createSPOSet (xmlNodePtr cur, SPOSetInputInfo &input_info)
	create an sposet from a general xml request More...

Protected Attributes
ParticleSet &	targetPtcl
	target ParticleSet More...
ParticleSet &	sourcePtcl
	source ParticleSet More...
std::map< std::string, std::unique_ptr< BasisSet_t > >	basisset_map_
	localized basis set map More...
bool	cuspCorr
	if true, add cusp correction to orbitals More...
std::string	h5_path
	Path to HDF5 Wavefunction. More...
TinyVector< int, 3 >	PBCImages
	Number of periodic Images for Orbital evaluation. More...
PosType	SuperTwist
	Coordinates Super Twist. More...
Vector< ValueType, OffloadPinnedAllocator< ValueType > >	PeriodicImagePhaseFactors
	Periodic Image Phase Factors. Correspond to the phase from the PBCImages. Computed only once. More...
Array< RealType, 2, OffloadPinnedAllocator< RealType > >	PeriodicImageDisplacements
Tensor< double, 3 >	Lattice
	Store Lattice parameters from HDF5 to use in PeriodicImagePhaseFactors. More...
bool	doCuspCorrection
	Enable cusp correction. More...
std::string	useGPU
	Captured gpu input string. More...
Vector< RealType >	Occ
	occupation number More...
Protected Attributes inherited from SPOSetBuilder
const std::string	type_name_
	type name of the SPO objects built by this builder. 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...

Private Member Functions
std::unique_ptr< BasisSet_t >	loadBasisSetFromXML (xmlNodePtr cur, xmlNodePtr parent)
	load a basis set from XML input More...
std::unique_ptr< BasisSet_t >	loadBasisSetFromH5 (xmlNodePtr parent)
	load a basis set from h5 file More...
int	determineRadialOrbType (xmlNodePtr cur) const
	determine radial orbital type based on "keyword" and "transform" attributes More...

Additional Inherited Members
Public Attributes inherited from SPOSetBuilder
bool	legacy
	whether implementation conforms only to legacy standard More...
std::vector< std::unique_ptr< SPOSetInfo > >	states
	state info of all possible states available in the basis More...

Detailed Description

SPOSetBuilder using new LCAOrbitalSet and Soa versions.

Reimplement MolecularSPOSetBuilder

• support both CartesianTensor and SphericalTensor

Definition at line 33 of file LCAOrbitalBuilder.h.

Member Typedef Documentation

BasisSet_t

using BasisSet_t = LCAOrbitalSet::basis_type

Definition at line 36 of file LCAOrbitalBuilder.h.

BasissetMap

using BasissetMap = std::map<std::string, std::unique_ptr<BasisSet_t> >

Definition at line 46 of file LCAOrbitalBuilder.h.

Constructor & Destructor Documentation

LCAOrbitalBuilder()

LCAOrbitalBuilder	(	ParticleSet &	els,
		ParticleSet &	ions,
		Communicate *	comm,
		xmlNodePtr	cur
	)

constructor

Parameters

els	reference to the electrons
ions	reference to the ions

Definition at line 120 of file LCAOrbitalBuilder.cpp.

References OhmmsAttributeSet::add(), qmcplusplus::app_warning(), LCAOrbitalBuilder::basisset_map_, PlatformSelector< KIND >::candidate_values(), MPIObjectBase::ClassName, LCAOrbitalBuilder::doCuspCorrection, LCAOrbitalBuilder::EvalPeriodicImagePhaseFactors(), getXMLAttributeValue(), LCAOrbitalBuilder::h5_path, LCAOrbitalBuilder::loadBasisSetFromH5(), LCAOrbitalBuilder::loadBasisSetFromXML(), LCAOrbitalBuilder::PBCImages, LCAOrbitalBuilder::PeriodicImageDisplacements, LCAOrbitalBuilder::PeriodicImagePhaseFactors, processChildren(), OhmmsAttributeSet::put(), LCAOrbitalBuilder::SuperTwist, and LCAOrbitalBuilder::useGPU.

    : SPOSetBuilder("LCAO", comm),
      targetPtcl(els),
      sourcePtcl(ions),
      h5_path(""),
      SuperTwist(0.0),
      doCuspCorrection(false)
{
  ClassName = "LCAOrbitalBuilder";
  ReportEngine PRE(ClassName, "createBasisSet");

  std::string cuspC("no"); // cusp correction
  OhmmsAttributeSet aAttrib;
  aAttrib.add(cuspC, "cuspCorrection");
  aAttrib.add(h5_path, "href");
  aAttrib.add(PBCImages, "PBCimages");
  aAttrib.add(SuperTwist, "twist");
  aAttrib.add(useGPU, "gpu", CPUOMPTargetSelector::candidate_values);
  aAttrib.put(cur);

  if (cuspC == "yes")
    doCuspCorrection = true;
  //Evaluate the Phase factor. Equals 1 for OBC.
  EvalPeriodicImagePhaseFactors(SuperTwist, PeriodicImagePhaseFactors, PeriodicImageDisplacements);

  // no need to wait but load the basis set
  processChildren(cur, [&](const std::string& cname, const xmlNodePtr element) {
    if (cname == "basisset")
    {
      std::string basisset_name_input(getXMLAttributeValue(element, "name"));
      std::string basisset_name(basisset_name_input.empty() ? "LCAOBSet" : basisset_name_input);
      if (basisset_map_.find(basisset_name) != basisset_map_.end())
      {
        std::ostringstream err_msg;
        err_msg << "Cannot create basisset " << basisset_name << " which already exists." << std::endl;
        throw std::runtime_error(err_msg.str());
      }
      if (h5_path != "")
        basisset_map_[basisset_name] = loadBasisSetFromH5(element);
      else
        basisset_map_[basisset_name] = loadBasisSetFromXML(element, cur);
    }
  });

  // deprecated h5 basis set handling when basisset element is missing
  if (basisset_map_.size() == 0 && h5_path != "")
  {
    app_warning() << "!!!!!!! Deprecated input style: missing basisset element. "
                  << "LCAO needs an explicit basisset XML element. " << "Fallback on loading an implicit one."
                  << std::endl;
    basisset_map_["LCAOBSet"] = loadBasisSetFromH5(cur);
  }

  if (basisset_map_.size() == 0)
    throw std::runtime_error("No basisset found in the XML input!");
}

~LCAOrbitalBuilder()

~LCAOrbitalBuilder ( )

override

Definition at line 177 of file LCAOrbitalBuilder.cpp.

{
  //properly cleanup
}

Member Function Documentation

createBasisSet()

LCAOrbitalBuilder::BasisSet_t * createBasisSet ( xmlNodePtr  cur )

protected

create basis set

Use ao_traits<T,I,J> to match (ROT)x(SH) combo

process atomicBasisSet per ion species

Definition at line 335 of file LCAOrbitalBuilder.cpp.

References OhmmsAttributeSet::add(), MPIObjectBase::ClassName, AOBasisBuilder< COT >::createAOSet(), ReportEngine::error(), SpeciesSet::findSpecies(), ParticleSet::getSpeciesSet(), MPIObjectBase::myComm, LCAOrbitalBuilder::PBCImages, LCAOrbitalBuilder::PeriodicImageDisplacements, LCAOrbitalBuilder::PeriodicImagePhaseFactors, OhmmsAttributeSet::put(), AOBasisBuilder< COT >::put(), LCAOrbitalBuilder::sourcePtcl, LCAOrbitalBuilder::SuperTwist, and LCAOrbitalBuilder::targetPtcl.

{
  ReportEngine PRE(ClassName, "createBasisSet(xmlNodePtr)");

  using ao_type    = typename ao_traits<RealType, ValueType, I, J>::ao_type;
  using basis_type = typename ao_traits<RealType, ValueType, I, J>::basis_type;

  basis_type* mBasisSet = new basis_type(sourcePtcl, targetPtcl);

  //list of built centers
  std::vector<std::string> ao_built_centers;

  /** process atomicBasisSet per ion species */
  cur = cur->xmlChildrenNode;
  while (cur != NULL) //loop over unique ioons
  {
    std::string cname((const char*)(cur->name));

    if (cname == "atomicBasisSet")
    {
      std::string elementType;
      std::string sph;
      OhmmsAttributeSet att;
      att.add(elementType, "elementType");
      att.put(cur);

      if (elementType.empty())
        PRE.error("Missing elementType attribute of atomicBasisSet.", true);

      auto it = std::find(ao_built_centers.begin(), ao_built_centers.end(), elementType);
      if (it == ao_built_centers.end())
      {
        AOBasisBuilder<ao_type> any(elementType, myComm);
        any.put(cur);
        auto aoBasis = any.createAOSet(cur);
        if (aoBasis)
        {
          //add the new atomic basis to the basis set
          int activeCenter = sourcePtcl.getSpeciesSet().findSpecies(elementType);
          mBasisSet->add(activeCenter, std::move(aoBasis));
        }
        ao_built_centers.push_back(elementType);
      }
    }
    cur = cur->next;
  } // done with basis set
  mBasisSet->setBasisSetSize(-1);
  mBasisSet->setPBCParams(PBCImages, SuperTwist, PeriodicImagePhaseFactors, PeriodicImageDisplacements);
  return mBasisSet;
}

createBasisSetH5()

LCAOrbitalBuilder::BasisSet_t * createBasisSetH5 ( )

protected

process atomicBasisSet per ion species

Definition at line 388 of file LCAOrbitalBuilder.cpp.

References qmcplusplus::app_log(), Communicate::bcast(), MPIObjectBase::ClassName, hdf_archive::close(), AOBasisBuilder< COT >::createAOSetH5(), ReportEngine::error(), SpeciesSet::findSpecies(), ParticleSet::getSpeciesSet(), LCAOrbitalBuilder::h5_path, MPIObjectBase::myComm, hdf_archive::open(), LCAOrbitalBuilder::PBCImages, LCAOrbitalBuilder::PeriodicImageDisplacements, LCAOrbitalBuilder::PeriodicImagePhaseFactors, hdf_archive::pop(), hdf_archive::push(), AOBasisBuilder< COT >::putH5(), Communicate::rank(), hdf_archive::read(), hdf_archive::readEntry(), LCAOrbitalBuilder::sourcePtcl, LCAOrbitalBuilder::SuperTwist, and LCAOrbitalBuilder::targetPtcl.

{
  ReportEngine PRE(ClassName, "createBasisSetH5(xmlNodePtr)");

  using ao_type    = typename ao_traits<RealType, ValueType, I, J>::ao_type;
  using basis_type = typename ao_traits<RealType, ValueType, I, J>::basis_type;

  basis_type* mBasisSet = new basis_type(sourcePtcl, targetPtcl);

  //list of built centers
  std::vector<std::string> ao_built_centers;

  int Nb_Elements(0);
  std::string basiset_name;

  /** process atomicBasisSet per ion species */
  app_log() << "Reading BasisSet from HDF5 file:" << h5_path << std::endl;

  hdf_archive hin(myComm);
  if (myComm->rank() == 0)
  {
    if (!hin.open(h5_path, H5F_ACC_RDONLY))
      PRE.error("Could not open H5 file", true);

    hin.push("basisset", false);

    hin.read(Nb_Elements, "NbElements");
  }

  myComm->bcast(Nb_Elements);
  if (Nb_Elements < 1)
    PRE.error("Missing elementType attribute of atomicBasisSet.", true);

  for (int i = 0; i < Nb_Elements; i++)
  {
    std::string elementType, dataset;
    std::stringstream tempElem;
    std::string ElemID0 = "atomicBasisSet", ElemType;
    tempElem << ElemID0 << i;
    ElemType = tempElem.str();

    if (myComm->rank() == 0)
    {
      hin.push(ElemType.c_str(), false);

      if (!hin.readEntry(basiset_name, "name"))
        PRE.error("Could not find name of  basisset group in H5; Probably Corrupt H5 file", true);
      if (!hin.readEntry(elementType, "elementType"))
        PRE.error("Could not read elementType in H5; Probably Corrupt H5 file", true);
    }
    myComm->bcast(basiset_name);
    myComm->bcast(elementType);

    auto it = std::find(ao_built_centers.begin(), ao_built_centers.end(), elementType);
    if (it == ao_built_centers.end())
    {
      AOBasisBuilder<ao_type> any(elementType, myComm);
      any.putH5(hin);
      auto aoBasis = any.createAOSetH5(hin);
      if (aoBasis)
      {
        //add the new atomic basis to the basis set
        int activeCenter = sourcePtcl.getSpeciesSet().findSpecies(elementType);
        mBasisSet->add(activeCenter, std::move(aoBasis));
      }
      ao_built_centers.push_back(elementType);
    }

    if (myComm->rank() == 0)
      hin.pop();
  }

  if (myComm->rank() == 0)
  {
    hin.pop();
    hin.close();
  }
  mBasisSet->setBasisSetSize(-1);
  mBasisSet->setPBCParams(PBCImages, SuperTwist, PeriodicImagePhaseFactors, PeriodicImageDisplacements);
  return mBasisSet;
}

createSPOSetFromXML()

std::unique_ptr< SPOSet > createSPOSetFromXML ( xmlNodePtr  cur )

overridevirtual

create an sposet from xml (legacy)

Implements SPOSetBuilder.

Reimplemented in LCAOSpinorBuilder.

Definition at line 471 of file LCAOrbitalBuilder.cpp.

References OhmmsAttributeSet::add(), qmcplusplus::app_log(), qmcplusplus::app_summary(), qmcplusplus::app_warning(), qmcplusplus::applyCuspCorrection(), Communicate::barrier_and_abort(), LCAOrbitalBuilder::basisset_map_, Communicate::bcast(), qmcplusplus::broadcastCuspInfo(), MPIObjectBase::ClassName, DELETED, LCAOrbitalBuilder::doCuspCorrection, file_exists(), qmcplusplus::generateCuspInfo(), SPOSet::getOrbitalSetSize(), ParticleSet::getTotalNum(), LCAOrbitalBuilder::loadMO(), MPIObjectBase::myComm, qmcplusplus::OMPTARGET, processChildren(), OhmmsAttributeSet::put(), Communicate::rank(), qmcplusplus::readCuspInfo(), qmcplusplus::saveCusp(), PlatformSelector< KIND >::selectPlatform(), LCAOrbitalBuilder::sourcePtcl, LCAOrbitalBuilder::targetPtcl, and LCAOrbitalBuilder::useGPU.

Referenced by qmcplusplus::test_LCAO_DiamondC_2x1x1_cplx(), and qmcplusplus::test_LCAO_DiamondC_2x1x1_real().

{
  ReportEngine PRE(ClassName, "createSPO(xmlNodePtr)");
  std::string spo_name(""), cusp_file(""), optimize("no");
  std::string basisset_name("LCAOBSet");
  size_t norbs(0);
  OhmmsAttributeSet spoAttrib;
  spoAttrib.add(spo_name, "name");
  spoAttrib.add(spo_name, "id");
  spoAttrib.add(cusp_file, "cuspInfo");
  spoAttrib.add(basisset_name, "basisset");
  spoAttrib.add(norbs, "size");
  spoAttrib.add(norbs, "orbitals", {}, TagStatus::DELETED);
  spoAttrib.put(cur);

  const bool useOffload = CPUOMPTargetSelector::selectPlatform(useGPU) == PlatformKind::OMPTARGET;

  // look for coefficients element. If found the MO coefficients matrix is not identity
  bool identity = true;
  processChildren(cur, [&](const std::string& cname, const xmlNodePtr element) {
    if (cname.find("coeff") < cname.size() || cname == "parameter" || cname == "Var")
      identity = false;
  });

  std::unique_ptr<BasisSet_t> myBasisSet;
  if (basisset_map_.find(basisset_name) == basisset_map_.end())
    myComm->barrier_and_abort("basisset \"" + basisset_name + "\" cannot be found\n");
  else
    myBasisSet.reset(basisset_map_[basisset_name]->makeClone());

  if (norbs == 0)
    norbs = myBasisSet->getBasisSetSize();

  std::unique_ptr<SPOSet> sposet;
  if (doCuspCorrection)
  {
#if defined(QMC_COMPLEX)
    myComm->barrier_and_abort(
        "LCAOrbitalBuilder::createSPOSetFromXML cusp correction is not supported on complex LCAO.");
#else
    app_summary() << "        Using cusp correction." << std::endl;
    if (useOffload)
      app_warning() << "    LCAO with cusp correction doesn't support OpenMP offload. Running on CPU." << std::endl;
    auto lcwc = std::make_unique<LCAOrbitalSetWithCorrection>(spo_name, std::move(myBasisSet), norbs, identity,
                                                              sourcePtcl, targetPtcl);
    if (!identity)
      loadMO(lcwc->lcao, cur);
    sposet = std::move(lcwc);
#endif
  }
  else
  {
    if (useOffload)
      app_summary() << "    Running OpenMP offload code path." << std::endl;
    else
      app_summary() << "    Running on CPU." << std::endl;
    auto lcos = std::make_unique<LCAOrbitalSet>(spo_name, std::move(myBasisSet), norbs, identity, useOffload);
    if (!identity)
      loadMO(*lcos, cur);
    sposet = std::move(lcos);
  }

#if !defined(QMC_COMPLEX)
  if (doCuspCorrection)
  {
    // Create a temporary particle set to use for cusp initialization.
    // The particle coordinates left at the end are unsuitable for further computations.
    // The coordinates get set to nuclear positions, which leads to zero e-N distance,
    // which causes a NaN in SoaAtomicBasisSet.h
    // This problem only appears when the electron positions are specified in the input.
    // The random particle placement step executes after this part of the code, overwriting
    // the leftover positions from the cusp initialization.
    ParticleSet tmp_targetPtcl(targetPtcl);

    const int num_centers = sourcePtcl.getTotalNum();
    auto& lcwc            = dynamic_cast<LCAOrbitalSetWithCorrection&>(*sposet);

    const int orbital_set_size = lcwc.getOrbitalSetSize();
    Matrix<CuspCorrectionParameters> info(num_centers, orbital_set_size);

    // set a default file name if not given
    if (cusp_file.empty())
      cusp_file = spo_name + ".cuspInfo.xml";

    bool file_exists(myComm->rank() == 0 && std::ifstream(cusp_file).good());
    myComm->bcast(file_exists);
    app_log() << "  Cusp correction file " << cusp_file << (file_exists ? " exits." : " doesn't exist.") << std::endl;

    // validate file if it exists
    if (file_exists)
    {
      bool valid = 0;
      if (myComm->rank() == 0)
        valid = readCuspInfo(cusp_file, spo_name, orbital_set_size, info);
      myComm->bcast(valid);
      if (!valid)
        myComm->barrier_and_abort("Invalid cusp correction file " + cusp_file);
#ifdef HAVE_MPI
      for (int orb_idx = 0; orb_idx < orbital_set_size; orb_idx++)
        for (int center_idx = 0; center_idx < num_centers; center_idx++)
          broadcastCuspInfo(info(center_idx, orb_idx), *myComm, 0);
#endif
    }
    else
    {
      generateCuspInfo(info, tmp_targetPtcl, sourcePtcl, lcwc.lcao, spo_name, *myComm);
      if (myComm->rank() == 0)
        saveCusp(cusp_file, info, spo_name);
    }

    applyCuspCorrection(info, tmp_targetPtcl, sourcePtcl, lcwc.lcao, lcwc.cusp, spo_name);
  }
#endif

  sposet->finalizeConstruction();
  return sposet;
}

determineRadialOrbType()

int determineRadialOrbType ( xmlNodePtr  cur ) const

private

determine radial orbital type based on "keyword" and "transform" attributes

Definition at line 182 of file LCAOrbitalBuilder.cpp.

References OhmmsAttributeSet::add(), and OhmmsAttributeSet::put().

Referenced by LCAOrbitalBuilder::loadBasisSetFromH5(), and LCAOrbitalBuilder::loadBasisSetFromXML().

{
  std::string keyOpt;
  std::string transformOpt;
  OhmmsAttributeSet aAttrib;
  aAttrib.add(keyOpt, "keyword");
  aAttrib.add(keyOpt, "key");
  aAttrib.add(transformOpt, "transform");
  aAttrib.put(cur);

  int radialOrbType = -1;
  if (transformOpt == "yes" || keyOpt == "NMO")
    radialOrbType = 0;
  else
  {
    if (keyOpt == "GTO")
      radialOrbType = 1;
    if (keyOpt == "STO")
      radialOrbType = 2;
  }
  return radialOrbType;
}

EvalPeriodicImagePhaseFactors() [1/2]

void EvalPeriodicImagePhaseFactors ( PosType  SuperTwist, Vector< RealType, OffloadPinnedAllocator< RealType >> &  LocPeriodicImagePhaseFactors, Array< RealType, 2, OffloadPinnedAllocator< RealType >> &  LocPeriodicImageDisplacements  )

protected

Periodic Image Phase Factors computation to be determined.

Exp(ik.g) where i is imaginary, k is the supertwist and g is the translation vector PBCImage.

Definition at line 1005 of file LCAOrbitalBuilder.cpp.

References APP_ABORT, Communicate::bcast(), hdf_archive::close(), LCAOrbitalBuilder::h5_path, LCAOrbitalBuilder::Lattice, MPIObjectBase::myComm, hdf_archive::open(), LCAOrbitalBuilder::PBCImages, hdf_archive::push(), Communicate::rank(), and hdf_archive::read().

Referenced by LCAOrbitalBuilder::LCAOrbitalBuilder().

{
  // Allow computation to continue with no HDF file if the system has open boundary conditions.
  // The complex build is usually only used with open BC for testing.
  bool usesOpenBC = PBCImages[0] == 0 && PBCImages[1] == 0 && PBCImages[2] == 0;

  ///Exp(ik.g) where i is imaginary, k is the supertwist and g is the translation vector PBCImage.
  if (h5_path != "" && !usesOpenBC)
  {
    hdf_archive hin(myComm);
    if (myComm->rank() == 0)
    {
      if (!hin.open(h5_path, H5F_ACC_RDONLY))
        APP_ABORT("Could not open H5 file");

      hin.push("Cell", false);

      hin.read(Lattice, "LatticeVectors");
      hin.close();
    }
    for (int i = 0; i < 3; i++)
      for (int j = 0; j < 3; j++)
        myComm->bcast(Lattice(i, j));
  }
  else if (!usesOpenBC)
  {
    APP_ABORT("Attempting to run PBC LCAO with no HDF5 support. Behaviour is unknown. Safer to exit");
  }

  const int Nx       = PBCImages[0] + 1;
  const int Ny       = PBCImages[1] + 1;
  const int Nz       = PBCImages[2] + 1;
  const int NbImages = Nx * Ny * Nz;
  LocPeriodicImagePhaseFactors.resize(NbImages);
  LocPeriodicImageDisplacements.resize(NbImages, 3);
  for (size_t ix = 0; ix < Nx; ix++)
    for (size_t iy = 0; iy < Ny; iy++)
      for (size_t iz = 0; iz < Nz; iz++)
      {
        const size_t i                  = iz + Nz * (iy + Ny * ix);
        int TransX                      = ((ix % 2) * 2 - 1) * ((ix + 1) / 2);
        int TransY                      = ((iy % 2) * 2 - 1) * ((iy + 1) / 2);
        int TransZ                      = ((iz % 2) * 2 - 1) * ((iz + 1) / 2);
        LocPeriodicImagePhaseFactors[i] = 1.0;
        for (size_t idim = 0; idim < 3; idim++)
          LocPeriodicImageDisplacements(i, idim) =
              TransX * Lattice(0, idim) + TransY * Lattice(1, idim) + TransZ * Lattice(2, idim);
      }
}

EvalPeriodicImagePhaseFactors() [2/2]

void EvalPeriodicImagePhaseFactors ( PosType  SuperTwist, Vector< std::complex< RealType >, OffloadPinnedAllocator< std::complex< RealType >>> &  LocPeriodicImagePhaseFactors, Array< RealType, 2, OffloadPinnedAllocator< RealType >> &  LocPeriodicImageDisplacements  )

protected

Exp(ik.g) where i is imaginary, k is the supertwist and g is the translation vector PBCImage.

Definition at line 1058 of file LCAOrbitalBuilder.cpp.

References APP_ABORT, Communicate::bcast(), hdf_archive::close(), qmcplusplus::dot(), LCAOrbitalBuilder::h5_path, LCAOrbitalBuilder::Lattice, MPIObjectBase::myComm, hdf_archive::open(), LCAOrbitalBuilder::PBCImages, hdf_archive::push(), Communicate::rank(), hdf_archive::read(), qmcplusplus::Units::time::s, qmcplusplus::sincos(), and LCAOrbitalBuilder::SuperTwist.

{
  // Allow computation to continue with no HDF file if the system has open boundary conditions.
  // The complex build is usually only used with open BC for testing.
  bool usesOpenBC = PBCImages[0] == 0 && PBCImages[1] == 0 && PBCImages[2] == 0;

  ///Exp(ik.g) where i is imaginary, k is the supertwist and g is the translation vector PBCImage.
  if (h5_path != "" && !usesOpenBC)
  {
    hdf_archive hin(myComm);
    if (myComm->rank() == 0)
    {
      if (!hin.open(h5_path, H5F_ACC_RDONLY))
        APP_ABORT("Could not open H5 file");

      hin.push("Cell", false);

      hin.read(Lattice, "LatticeVectors");
      hin.close();
    }
    for (int i = 0; i < 3; i++)
      for (int j = 0; j < 3; j++)
        myComm->bcast(Lattice(i, j));
  }
  else if (!usesOpenBC)
  {
    APP_ABORT("Attempting to run PBC LCAO with no HDF5 support. Behaviour is unknown. Safer to exit");
  }

  int phase_idx = 0;
  int TransX, TransY, TransZ;
  RealType phase;
  const int Nx       = PBCImages[0] + 1;
  const int Ny       = PBCImages[1] + 1;
  const int Nz       = PBCImages[2] + 1;
  const int NbImages = Nx * Ny * Nz;
  LocPeriodicImagePhaseFactors.resize(NbImages);
  LocPeriodicImageDisplacements.resize(NbImages, 3);
  for (size_t ix = 0; ix < Nx; ix++)
    for (size_t iy = 0; iy < Ny; iy++)
      for (size_t iz = 0; iz < Nz; iz++)
      {
        const size_t i = iz + Nz * (iy + Ny * ix);
        int TransX     = ((ix % 2) * 2 - 1) * ((ix + 1) / 2);
        int TransY     = ((iy % 2) * 2 - 1) * ((iy + 1) / 2);
        int TransZ     = ((iz % 2) * 2 - 1) * ((iz + 1) / 2);
        RealType s, c;
        PosType Val;
        for (size_t idim = 0; idim < 3; idim++)
        {
          Val[idim] = TransX * Lattice(0, idim) + TransY * Lattice(1, idim) + TransZ * Lattice(2, idim);
          LocPeriodicImageDisplacements(i, idim) = Val[idim];
        }

        phase = dot(SuperTwist, Val);
        qmcplusplus::sincos(phase, &s, &c);

        LocPeriodicImagePhaseFactors[i] = std::complex<RealType>(c, s);
      }
}

getBasissetMap()

const BasissetMap& getBasissetMap ( ) const

inline

Definition at line 47 of file LCAOrbitalBuilder.h.

References LCAOrbitalBuilder::basisset_map_.

Referenced by qmcplusplus::TEST_CASE().

{ return basisset_map_; }

loadBasisSetFromH5()

std::unique_ptr< BasisSet_t > loadBasisSetFromH5 ( xmlNodePtr  parent )

private

load a basis set from h5 file

process atomicBasisSet per ion species

Definition at line 272 of file LCAOrbitalBuilder.cpp.

References qmcplusplus::app_log(), Communicate::bcast(), MPIObjectBase::ClassName, hdf_archive::close(), LCAOrbitalBuilder::determineRadialOrbType(), ReportEngine::error(), LCAOrbitalBuilder::h5_path, MPIObjectBase::myComm, hdf_archive::open(), hdf_archive::push(), Communicate::rank(), and hdf_archive::readEntry().

Referenced by LCAOrbitalBuilder::LCAOrbitalBuilder().

{
  ReportEngine PRE(ClassName, "loadBasisSetFromH5()");

  hdf_archive hin(myComm);
  int ylm = -1;
  if (myComm->rank() == 0)
  {
    if (!hin.open(h5_path, H5F_ACC_RDONLY))
      PRE.error("Could not open H5 file", true);

    hin.push("basisset", false);

    std::string sph;
    std::string ElemID0 = "atomicBasisSet0";

    hin.push(ElemID0.c_str(), false);

    if (!hin.readEntry(sph, "angular"))
      PRE.error("Could not find name of  basisset group in H5; Probably Corrupt H5 file", true);
    ylm = (sph == "cartesian") ? 0 : 1;
    hin.close();
  }

  myComm->bcast(ylm);
  if (ylm < 0)
    PRE.error("Missing angular attribute of atomicBasisSet.", true);

  int radialOrbType = determineRadialOrbType(parent);
  if (radialOrbType < 0)
    PRE.error("Unknown radial function for LCAO orbitals. Specify keyword=\"NMO/GTO/STO\" .", true);

  BasisSet_t* myBasisSet = nullptr;
  /** process atomicBasisSet per ion species */
  switch (radialOrbType)
  {
  case (0): //numerical
    app_log() << "  LCAO: SoaAtomicBasisSet<MultiQuintic," << ylm << ">" << std::endl;
    if (ylm)
      myBasisSet = createBasisSetH5<0, 1>();
    else
      myBasisSet = createBasisSetH5<0, 0>();
    break;
  case (1): //gto
    app_log() << "  LCAO: SoaAtomicBasisSet<MultiGTO," << ylm << ">" << std::endl;
    if (ylm)
      myBasisSet = createBasisSetH5<1, 1>();
    else
      myBasisSet = createBasisSetH5<1, 0>();
    break;
  case (2): //sto
    app_log() << "  LCAO: SoaAtomicBasisSet<MultiSTO," << ylm << ">" << std::endl;
    myBasisSet = createBasisSetH5<2, 1>();
    break;
  default:
    PRE.error("Cannot construct SoaAtomicBasisSet<ROT,YLM>.", true);
    break;
  }
  return std::unique_ptr<BasisSet_t>(myBasisSet);
}

loadBasisSetFromXML()

std::unique_ptr< BasisSet_t > loadBasisSetFromXML ( xmlNodePtr  cur, xmlNodePtr  parent  )

private

load a basis set from XML input

process atomicBasisSet per ion species

Definition at line 205 of file LCAOrbitalBuilder.cpp.

References OhmmsAttributeSet::add(), qmcplusplus::app_log(), qmcplusplus::app_warning(), MPIObjectBase::ClassName, LCAOrbitalBuilder::determineRadialOrbType(), ReportEngine::error(), qmcplusplus::is_same(), and OhmmsAttributeSet::put().

Referenced by LCAOrbitalBuilder::LCAOrbitalBuilder().

{
  ReportEngine PRE(ClassName, "loadBasisSetFromXML(xmlNodePtr)");
  int ylm = -1;
  {
    xmlNodePtr cur1 = cur->xmlChildrenNode;
    while (cur1 != NULL && ylm < 0)
    {
      if (is_same(cur1->name, "atomicBasisSet"))
      {
        std::string sph;
        OhmmsAttributeSet att;
        att.add(sph, "angular");
        att.put(cur1);
        ylm = (sph == "cartesian") ? 0 : 1;
      }
      cur1 = cur1->next;
    }
  }

  if (ylm < 0)
    PRE.error("Missing angular attribute of atomicBasisSet.", true);

  int radialOrbType = determineRadialOrbType(cur);
  if (radialOrbType < 0)
  {
    app_warning() << "Radial orbital type cannot be determined based on the attributes of basisset line. "
                  << "Trying the parent element." << std::endl;
    radialOrbType = determineRadialOrbType(parent);
  }

  if (radialOrbType < 0)
    PRE.error("Unknown radial function for LCAO orbitals. Specify keyword=\"NMO/GTO/STO\" .", true);

  BasisSet_t* myBasisSet = nullptr;
  /** process atomicBasisSet per ion species */
  switch (radialOrbType)
  {
  case (0): //numerical
    app_log() << "  LCAO: SoaAtomicBasisSet<MultiQuintic," << ylm << ">" << std::endl;
    if (ylm)
      myBasisSet = createBasisSet<0, 1>(cur);
    else
      myBasisSet = createBasisSet<0, 0>(cur);
    break;
  case (1): //gto
    app_log() << "  LCAO: SoaAtomicBasisSet<MultiGTO," << ylm << ">" << std::endl;
    if (ylm)
      myBasisSet = createBasisSet<1, 1>(cur);
    else
      myBasisSet = createBasisSet<1, 0>(cur);
    break;
  case (2): //sto
    app_log() << "  LCAO: SoaAtomicBasisSet<MultiSTO," << ylm << ">" << std::endl;
    if (ylm)
      myBasisSet = createBasisSet<2, 1>(cur);
    else
      myBasisSet = createBasisSet<2, 0>(cur);
    break;
  default:
    PRE.error("Cannot construct SoaAtomicBasisSet<ROT,YLM>.", true);
    break;
  }

  return std::unique_ptr<BasisSet_t>(myBasisSet);
}

LoadFullCoefsFromH5() [1/2]

void LoadFullCoefsFromH5 ( hdf_archive &  hin, int  setVal, PosType &  SuperTwist, Matrix< std::complex< RealType >> &  Ctemp, bool  MultiDet  )

protected

When running Single Determinant calculations, MO coeff loaded based on occupation and lowest eingenvalue. However, for solids with multideterminants, orbitals are order by kpoints; first all MOs for kpoint 1, then 2 etc The multideterminants occupation is specified in the input/HDF5 and theefore as long as there is consistency between the order in which we read the orbitals and the occupation, we are safe. In the case of Multideterminants generated by pyscf and Quantum Package, They are stored in the same order as generated for quantum package and one should use the orbitals labelled eigenset_unsorted.

Definition at line 927 of file LCAOrbitalBuilder.cpp.

References Matrix< T, Alloc >::cols(), hdf_archive::read(), LCAOrbitalBuilder::readRealMatrixFromH5(), Matrix< T, Alloc >::resize(), and Matrix< T, Alloc >::rows().

Referenced by LCAOrbitalBuilder::putPBCFromH5().

{
  Matrix<RealType> Creal;
  Matrix<RealType> Ccmplx;

  std::array<char, 72> name;
  int name_len{0};
  ///When running Single Determinant calculations, MO coeff loaded based on occupation and lowest eingenvalue.
  ///However, for solids with multideterminants, orbitals are order by kpoints; first all MOs for kpoint 1, then 2 etc
  /// The multideterminants occupation is specified in the input/HDF5 and theefore as long as there is consistency between
  /// the order in which we read the orbitals and the occupation, we are safe. In the case of Multideterminants generated
  /// by pyscf and Quantum Package, They are stored in the same order as generated for quantum package and one should use
  /// the orbitals labelled eigenset_unsorted.

  if (MultiDet == false)
    name_len = std::snprintf(name.data(), name.size(), "%s%d", "/Super_Twist/eigenset_", setVal);
  else
    name_len = std::snprintf(name.data(), name.size(), "%s%d", "/Super_Twist/eigenset_unsorted_", setVal);
  if (name_len < 0)
    throw std::runtime_error("Error generating name");

  std::string setname(name.data(), name_len);
  readRealMatrixFromH5(hin, setname, Creal);

  bool IsComplex = true;
  hin.read(IsComplex, "/parameters/IsComplex");
  if (IsComplex == false)
  {
    Ccmplx.resize(Creal.rows(), Creal.cols());
    Ccmplx = 0.0;
  }
  else
  {
    setname += "_imag";
    readRealMatrixFromH5(hin, setname, Ccmplx);
  }

  Ctemp.resize(Creal.rows(), Creal.cols());
  for (int i = 0; i < Ctemp.rows(); i++)
    for (int j = 0; j < Ctemp.cols(); j++)
      Ctemp[i][j] = std::complex<RealType>(Creal[i][j], Ccmplx[i][j]);
}

LoadFullCoefsFromH5() [2/2]

void LoadFullCoefsFromH5 ( hdf_archive &  hin, int  setVal, PosType &  SuperTwist, Matrix< RealType > &  Creal, bool  Multidet  )

protected

Definition at line 974 of file LCAOrbitalBuilder.cpp.

References qmcplusplus::abs(), APP_ABORT, qmcplusplus::Units::charge::e, hdf_archive::read(), LCAOrbitalBuilder::readRealMatrixFromH5(), and LCAOrbitalBuilder::SuperTwist.

{
  bool IsComplex = false;
  hin.read(IsComplex, "/parameters/IsComplex");
  if (IsComplex &&
      (std::abs(SuperTwist[0]) >= 1e-6 || std::abs(SuperTwist[1]) >= 1e-6 || std::abs(SuperTwist[2]) >= 1e-6))
  {
    std::string setname("This Wavefunction is Complex and you are using the real version of QMCPACK. "
                        "Please re-run this job with the Complex build of QMCPACK.");
    APP_ABORT(setname.c_str());
  }

  std::array<char, 72> name;
  int name_len{0};
  bool PBC = false;
  hin.read(PBC, "/PBC/PBC");
  if (MultiDet && PBC)
    name_len = std::snprintf(name.data(), name.size(), "%s%d", "/Super_Twist/eigenset_unsorted_", setVal);
  else
    name_len = std::snprintf(name.data(), name.size(), "%s%d", "/Super_Twist/eigenset_", setVal);
  if (name_len < 0)
    throw std::runtime_error("Error generating name");

  readRealMatrixFromH5(hin, std::string(name.data(), name_len), Creal);
}

loadMO()

bool loadMO ( LCAOrbitalSet &  spo, xmlNodePtr  cur  )

protected

Parse the xml file for information on the Dirac determinants.

Parameters

cur	the current xmlNode

Definition at line 593 of file LCAOrbitalBuilder.cpp.

References OhmmsAttributeSet::add(), APP_ABORT, app_debug, qmcplusplus::app_log(), Communicate::bcast(), LCAOrbitalSet::C, hdf_archive::close(), qmcplusplus::Units::charge::e, LCAOrbitalBuilder::h5_path, MPIObjectBase::myComm, hdf_archive::open(), hdf_archive::push(), OhmmsAttributeSet::put(), LCAOrbitalBuilder::putFromH5(), LCAOrbitalBuilder::putFromXML(), LCAOrbitalBuilder::putOccupation(), LCAOrbitalBuilder::putPBCFromH5(), Communicate::rank(), and hdf_archive::read().

Referenced by LCAOrbitalBuilder::createSPOSetFromXML().

{
#undef FunctionName
#define FunctionName                                      \
  printf("Calling FunctionName from %s\n", __FUNCTION__); \
  FunctionNameReal
  //Check if HDF5 present
  ReportEngine PRE("LCAOrbitalBuilder", "put(xmlNodePtr)");

  //initialize the number of orbital by the basis set size
  std::string debugc("no");
  double orbital_mix_magnitude = 0.0;
  bool PBC                     = false;
  OhmmsAttributeSet aAttrib;
  aAttrib.add(debugc, "debug");
  aAttrib.add(orbital_mix_magnitude, "orbital_mix_magnitude");
  aAttrib.put(cur);
  xmlNodePtr occ_ptr   = NULL;
  xmlNodePtr coeff_ptr = NULL;
  cur                  = cur->xmlChildrenNode;
  while (cur != NULL)
  {
    std::string cname((const char*)(cur->name));
    if (cname == "occupation")
    {
      occ_ptr = cur;
    }
    else if (cname.find("coeff") < cname.size() || cname == "parameter" || cname == "Var")
    {
      coeff_ptr = cur;
    }
    cur = cur->next;
  }
  if (coeff_ptr == NULL)
  {
    app_log() << "   Using Identity for the LCOrbitalSet " << std::endl;
    return true;
  }
  bool success = putOccupation(spo, occ_ptr);
  if (h5_path == "")
    success = putFromXML(spo, coeff_ptr);
  else
  {
    hdf_archive hin(myComm);

    if (myComm->rank() == 0)
    {
      if (!hin.open(h5_path, H5F_ACC_RDONLY))
        APP_ABORT("LCAOrbitalBuilder::putFromH5 missing or incorrect path to H5 file.");

      try
      {
        hin.push("PBC", false);
        PBC = true;
      }
      catch (const std::exception& e)
      {
        app_debug() << e.what() << std::endl;
        PBC = false;
      }

      if (PBC)
        hin.read(PBC, "PBC");

      hin.close();
    }
    myComm->bcast(PBC);
    if (PBC)
      success = putPBCFromH5(spo, coeff_ptr);
    else
      success = putFromH5(spo, coeff_ptr);
  }

  // Ye: used to construct cusp correction
  //bool success2 = transformSPOSet();
  if (debugc == "yes")
  {
    app_log() << "   Single-particle orbital coefficients dims=" << spo.C->rows() << " x " << spo.C->cols()
              << std::endl;
    app_log() << *spo.C << std::endl;
  }

  return success;
}

putFromH5()

bool putFromH5 ( LCAOrbitalSet &  spo, xmlNodePtr  coeff_ptr  )

protected

read data from a hdf5 file

Parameters

norb	number of orbitals to be initialized
coeff_ptr	xmlnode for coefficients

Definition at line 716 of file LCAOrbitalBuilder.cpp.

References OhmmsAttributeSet::add(), APP_ABORT, Communicate::barrier_and_abort(), Communicate::bcast(), LCAOrbitalSet::C, hdf_archive::close(), Matrix< T, Alloc >::cols(), copy(), DELETED, DEPRECATED, LCAOrbitalSet::getBasisSetSize(), SPOSet::getOrbitalSetSize(), LCAOrbitalBuilder::h5_path, MPIObjectBase::myComm, qmcplusplus::n, LCAOrbitalBuilder::Occ, hdf_archive::open(), OhmmsAttributeSet::put(), Communicate::rank(), hdf_archive::read(), hdf_archive::readEntry(), and Matrix< T, Alloc >::rows().

Referenced by LCAOrbitalBuilder::loadMO().

{
  int setVal = -1;
  int neig;
  OhmmsAttributeSet aAttrib;
  aAttrib.add(setVal, "spindataset");
  aAttrib.add(neig, "size", {}, TagStatus::DEPRECATED);
  aAttrib.add(neig, "orbitals", {}, TagStatus::DELETED);
  aAttrib.put(coeff_ptr);
  hdf_archive hin(myComm);
  if (myComm->rank() == 0)
  {
    if (!hin.open(h5_path, H5F_ACC_RDONLY))
      APP_ABORT("LCAOrbitalBuilder::putFromH5 missing or incorrect path to H5 file.");

    Matrix<RealType> Ctemp;
    std::array<char, 72> name;


    //This is to make sure of Backward compatibility with previous tags.
    int name_len = std::snprintf(name.data(), name.size(), "%s%d", "/Super_Twist/eigenset_", setVal);
    if (name_len < 0)
      throw std::runtime_error("Error generating name");
    std::string setname(name.data(), name_len);
    if (!hin.readEntry(Ctemp, setname))
    {
      name_len = std::snprintf(name.data(), name.size(), "%s%d", "/KPTS_0/eigenset_", setVal);
      if (name_len < 0)
        throw std::runtime_error("Error generating name");
      setname = std::string(name.data(), name_len);
      hin.read(Ctemp, setname);
    }
    hin.close();

    if (Ctemp.cols() != spo.getBasisSetSize())
    {
      std::ostringstream err_msg;
      err_msg << "Basis set size " << spo.getBasisSetSize() << " mismatched the number of MO coefficients columns "
              << Ctemp.cols() << " from h5." << std::endl;
      myComm->barrier_and_abort(err_msg.str());
    }

    int norbs = spo.getOrbitalSetSize();
    if (Ctemp.rows() < norbs)
    {
      std::ostringstream err_msg;
      err_msg << "Need " << norbs << " orbitals. Insufficient rows of MO coefficients " << Ctemp.rows() << " from h5."
              << std::endl;
      myComm->barrier_and_abort(err_msg.str());
    }

    int n = 0, i = 0;
    while (i < norbs)
    {
      if (Occ[n] > 0.0)
      {
        std::copy(Ctemp[n], Ctemp[n + 1], (*spo.C)[i]);
        i++;
      }
      n++;
    }
  }
  myComm->bcast(spo.C->data(), spo.C->size());
  return true;
}

putFromXML()

bool putFromXML ( LCAOrbitalSet &  spo, xmlNodePtr  coeff_ptr  )

protected

Definition at line 678 of file LCAOrbitalBuilder.cpp.

References OhmmsAttributeSet::add(), APP_ABORT, LCAOrbitalSet::C, copy(), DELETED, LCAOrbitalSet::getBasisSetSize(), SPOSet::getOrbitalSetSize(), qmcplusplus::n, LCAOrbitalBuilder::Occ, OhmmsAttributeSet::put(), and putContent().

Referenced by LCAOrbitalBuilder::loadMO().

{
  int norbs = 0;
  OhmmsAttributeSet aAttrib;
  aAttrib.add(norbs, "size");
  aAttrib.add(norbs, "orbitals", {}, TagStatus::DELETED);
  aAttrib.put(coeff_ptr);
  if (norbs < spo.getOrbitalSetSize())
  {
    return false;
    APP_ABORT("LCAOrbitalBuilder::putFromXML missing or incorrect size");
  }
  if (norbs)
  {
    std::vector<ValueType> Ctemp;
    int BasisSetSize = spo.getBasisSetSize();
    Ctemp.resize(norbs * BasisSetSize);
    putContent(Ctemp, coeff_ptr);
    int n = 0, i = 0;
    std::vector<ValueType>::iterator cit(Ctemp.begin());
    while (i < spo.getOrbitalSetSize())
    {
      if (Occ[n] > std::numeric_limits<RealType>::epsilon())
      {
        std::copy(cit, cit + BasisSetSize, (*spo.C)[i]);
        i++;
      }
      n++;
      cit += BasisSetSize;
    }
  }
  return true;
}

putOccupation()

bool putOccupation ( LCAOrbitalSet &  spo, xmlNodePtr  occ_ptr  )

protected

Definition at line 877 of file LCAOrbitalBuilder.cpp.

References APP_ABORT, LCAOrbitalSet::getBasisSetSize(), SPOSet::getOrbitalSetSize(), getXMLAttributeValue(), LCAOrbitalBuilder::Occ, putContent(), and Vector< T, Alloc >::resize().

Referenced by LCAOrbitalBuilder::loadMO(), and LCAOSpinorBuilder::putFromH5().

{
  //die??
  if (spo.getBasisSetSize() == 0)
  {
    APP_ABORT("LCAOrbitalBuilder::putOccupation detected ZERO BasisSetSize");
    return false;
  }
  Occ.resize(std::max(spo.getBasisSetSize(), spo.getOrbitalSetSize()));
  Occ = 0.0;
  for (int i = 0; i < spo.getOrbitalSetSize(); i++)
    Occ[i] = 1.0;
  std::vector<int> occ_in;
  std::string occ_mode("table");
  if (occ_ptr == NULL)
  {
    occ_mode = "ground";
  }
  else
  {
    const std::string o(getXMLAttributeValue(occ_ptr, "mode"));
    if (!o.empty())
      occ_mode = o;
  }
  //Do nothing if mode == ground
  if (occ_mode == "excited")
  {
    putContent(occ_in, occ_ptr);
    for (int k = 0; k < occ_in.size(); k++)
    {
      if (occ_in[k] < 0) //remove this, -1 is to adjust the base
        Occ[-occ_in[k] - 1] = 0.0;
      else
        Occ[occ_in[k] - 1] = 1.0;
    }
  }
  else if (occ_mode == "table")
  {
    putContent(Occ, occ_ptr);
  }
  return true;
}

putPBCFromH5()

bool putPBCFromH5 ( LCAOrbitalSet &  spo, xmlNodePtr  coeff_ptr  )

protected

read data from a hdf5 file

Parameters

norb	number of orbitals to be initialized
coeff_ptr	xmlnode for coefficients

Used to know if running an MSD calculation - needed for order of Orbitals.

Definition at line 787 of file LCAOrbitalBuilder.cpp.

References qmcplusplus::abs(), OhmmsAttributeSet::add(), APP_ABORT, qmcplusplus::app_log(), LCAOrbitalSet::C, hdf_archive::close(), copy(), DELETED, DEPRECATED, qmcplusplus::Units::charge::e, SPOSet::getOrbitalSetSize(), LCAOrbitalBuilder::h5_path, LCAOrbitalBuilder::LoadFullCoefsFromH5(), MPIObjectBase::myComm, qmcplusplus::n, LCAOrbitalBuilder::Occ, hdf_archive::open(), hdf_archive::pop(), hdf_archive::push(), OhmmsAttributeSet::put(), Communicate::rank(), hdf_archive::read(), and LCAOrbitalBuilder::SuperTwist.

Referenced by LCAOrbitalBuilder::loadMO().

{
  ReportEngine PRE("LCAOrbitalBuilder", "LCAOrbitalBuilder::putPBCFromH5");
  int setVal     = -1;
  int neig;
  bool IsComplex = false;
  bool MultiDet  = false;
  PosType SuperTwist(0.0);
  PosType SuperTwistH5(0.0);
  OhmmsAttributeSet aAttrib;
  aAttrib.add(setVal, "spindataset");
  aAttrib.add(neig, "size", {}, TagStatus::DEPRECATED);
  aAttrib.add(neig, "orbitals", {}, TagStatus::DELETED);
  aAttrib.put(coeff_ptr);
  hdf_archive hin(myComm);

  xmlNodePtr curtemp = coeff_ptr;

  std::string xmlTag("determinantset");
  std::string MSDTag("sposet");
  std::string SDTag("determinant");
  std::string EndTag("qmcsystem");
  std::string curname;

  do
  {
    std::stringstream ss;
    curtemp = curtemp->parent;
    ss << curtemp->name;
    ss >> curname;
    if (curname == MSDTag)
      MultiDet = true; ///Used to know if running an MSD calculation - needed for order of Orbitals.
    if (curname == SDTag)
      MultiDet = false;

  } while ((xmlTag != curname) && (curname != EndTag) && curname != "sposet_collection");
  if (curname == EndTag)
  {
    APP_ABORT(
        "Could not find in wf file the \"sposet\" or \"determinant\" tags. Please verify input or contact developers");
  }

  aAttrib.add(SuperTwist, "twist");
  aAttrib.put(curtemp);

  if (myComm->rank() == 0)
  {
    if (!hin.open(h5_path, H5F_ACC_RDONLY))
      APP_ABORT("LCAOrbitalBuilder::putFromH5 missing or incorrect path to H5 file.");
    hin.push("parameters");
    hin.read(IsComplex, "IsComplex");
    hin.pop();

    std::string setname("/Super_Twist/Coord");
    hin.read(SuperTwistH5, setname);
    if (std::abs(SuperTwistH5[0] - SuperTwist[0]) >= 1e-6 || std::abs(SuperTwistH5[1] - SuperTwist[1]) >= 1e-6 ||
        std::abs(SuperTwistH5[2] - SuperTwist[2]) >= 1e-6)
    {
      app_log() << "Super Twist in XML : " << SuperTwist[0] << "    In H5:" << SuperTwistH5[0] << std::endl;
      app_log() << "                     " << SuperTwist[1] << "          " << SuperTwistH5[1] << std::endl;
      app_log() << "                     " << SuperTwist[2] << "          " << SuperTwistH5[2] << std::endl;
      app_log() << "Diff in Coord     x :" << std::abs(SuperTwistH5[0] - SuperTwist[0]) << std::endl;
      app_log() << "                  y :" << std::abs(SuperTwistH5[1] - SuperTwist[1]) << std::endl;
      app_log() << "                  z :" << std::abs(SuperTwistH5[2] - SuperTwist[2]) << std::endl;
      APP_ABORT("Requested Super Twist in XML and Super Twist in HDF5 do not Match!!! Aborting.");
    }
    //SuperTwist=SuperTwistH5;
    Matrix<ValueType> Ctemp;
    LoadFullCoefsFromH5(hin, setVal, SuperTwist, Ctemp, MultiDet);

    int n = 0, i = 0;
    while (i < spo.getOrbitalSetSize())
    {
      if (Occ[n] > 0.0)
      {
        std::copy(Ctemp[n], Ctemp[n + 1], (*spo.C)[i]);
        i++;
      }
      n++;
    }

    hin.close();
  }
#ifdef HAVE_MPI
  myComm->comm.broadcast_n(spo.C->data(), spo.C->size());
#endif
  return true;
}

readRealMatrixFromH5()

void readRealMatrixFromH5 ( hdf_archive &  hin, const std::string &  setname, Matrix< LCAOrbitalBuilder::RealType > &  Creal  ) const

protected

read matrix from h5 file

Parameters

[in]	hin	hdf5 arhive to be read from
	setname	where to read from in hdf5 archive
[out]	Creal	matrix read from h5

added in header to allow use from derived class LCAOSpinorBuilder as well

Definition at line 920 of file LCAOrbitalBuilder.cpp.

References hdf_archive::read().

Referenced by LCAOrbitalBuilder::LoadFullCoefsFromH5(), and LCAOSpinorBuilder::putFromH5().

{
  hin.read(Creal, setname);
}

Member Data Documentation

basisset_map_

std::map<std::string, std::unique_ptr<BasisSet_t> > basisset_map_

protected

localized basis set map

Definition at line 55 of file LCAOrbitalBuilder.h.

Referenced by LCAOrbitalBuilder::createSPOSetFromXML(), LCAOSpinorBuilder::createSPOSetFromXML(), LCAOrbitalBuilder::getBasissetMap(), and LCAOrbitalBuilder::LCAOrbitalBuilder().

cuspCorr

bool cuspCorr

protected

if true, add cusp correction to orbitals

Definition at line 57 of file LCAOrbitalBuilder.h.

doCuspCorrection

bool doCuspCorrection

protected

Enable cusp correction.

Definition at line 71 of file LCAOrbitalBuilder.h.

Referenced by LCAOrbitalBuilder::createSPOSetFromXML(), and LCAOrbitalBuilder::LCAOrbitalBuilder().

h5_path

std::string h5_path

protected

Path to HDF5 Wavefunction.

Definition at line 59 of file LCAOrbitalBuilder.h.

Referenced by LCAOrbitalBuilder::createBasisSetH5(), LCAOrbitalBuilder::EvalPeriodicImagePhaseFactors(), LCAOrbitalBuilder::LCAOrbitalBuilder(), LCAOSpinorBuilder::LCAOSpinorBuilder(), LCAOrbitalBuilder::loadBasisSetFromH5(), LCAOSpinorBuilder::loadMO(), LCAOrbitalBuilder::loadMO(), LCAOSpinorBuilder::putFromH5(), LCAOrbitalBuilder::putFromH5(), and LCAOrbitalBuilder::putPBCFromH5().

Lattice

Tensor<double, 3> Lattice

protected

Store Lattice parameters from HDF5 to use in PeriodicImagePhaseFactors.

Definition at line 68 of file LCAOrbitalBuilder.h.

Referenced by LCAOrbitalBuilder::EvalPeriodicImagePhaseFactors().

Occ

Vector<RealType> Occ

protected

occupation number

Definition at line 86 of file LCAOrbitalBuilder.h.

Referenced by LCAOSpinorBuilder::putFromH5(), LCAOrbitalBuilder::putFromH5(), LCAOrbitalBuilder::putFromXML(), LCAOrbitalBuilder::putOccupation(), and LCAOrbitalBuilder::putPBCFromH5().

PBCImages

TinyVector<int, 3> PBCImages

protected

Number of periodic Images for Orbital evaluation.

Definition at line 61 of file LCAOrbitalBuilder.h.

Referenced by LCAOrbitalBuilder::createBasisSet(), LCAOrbitalBuilder::createBasisSetH5(), LCAOrbitalBuilder::EvalPeriodicImagePhaseFactors(), and LCAOrbitalBuilder::LCAOrbitalBuilder().

PeriodicImageDisplacements

Array<RealType, 2, OffloadPinnedAllocator<RealType> > PeriodicImageDisplacements

protected

Definition at line 66 of file LCAOrbitalBuilder.h.

Referenced by LCAOrbitalBuilder::createBasisSet(), LCAOrbitalBuilder::createBasisSetH5(), and LCAOrbitalBuilder::LCAOrbitalBuilder().

PeriodicImagePhaseFactors

Vector<ValueType, OffloadPinnedAllocator<ValueType> > PeriodicImagePhaseFactors

protected

Periodic Image Phase Factors. Correspond to the phase from the PBCImages. Computed only once.

Definition at line 65 of file LCAOrbitalBuilder.h.

Referenced by LCAOrbitalBuilder::createBasisSet(), LCAOrbitalBuilder::createBasisSetH5(), and LCAOrbitalBuilder::LCAOrbitalBuilder().

sourcePtcl

ParticleSet& sourcePtcl

protected

source ParticleSet

Definition at line 53 of file LCAOrbitalBuilder.h.

Referenced by LCAOrbitalBuilder::createBasisSet(), LCAOrbitalBuilder::createBasisSetH5(), and LCAOrbitalBuilder::createSPOSetFromXML().

SuperTwist

PosType SuperTwist

protected

Coordinates Super Twist.

Definition at line 63 of file LCAOrbitalBuilder.h.

Referenced by LCAOrbitalBuilder::createBasisSet(), LCAOrbitalBuilder::createBasisSetH5(), LCAOrbitalBuilder::EvalPeriodicImagePhaseFactors(), LCAOrbitalBuilder::LCAOrbitalBuilder(), LCAOrbitalBuilder::LoadFullCoefsFromH5(), and LCAOrbitalBuilder::putPBCFromH5().

targetPtcl

ParticleSet& targetPtcl

protected

target ParticleSet

Definition at line 51 of file LCAOrbitalBuilder.h.

Referenced by LCAOrbitalBuilder::createBasisSet(), LCAOrbitalBuilder::createBasisSetH5(), and LCAOrbitalBuilder::createSPOSetFromXML().

useGPU

std::string useGPU

protected

Captured gpu input string.

Definition at line 73 of file LCAOrbitalBuilder.h.

Referenced by LCAOrbitalBuilder::createSPOSetFromXML(), and LCAOrbitalBuilder::LCAOrbitalBuilder().

---

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

• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCWaveFunctions/LCAO/LCAOrbitalBuilder.h
• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCWaveFunctions/LCAO/LCAOrbitalBuilder.cpp