RMGParser Class Reference

Inheritance diagram for RMGParser:

Collaboration diagram for RMGParser:

Public Member Functions
	RMGParser ()
	RMGParser (int argc, char **argv)
void	dumpPBC (const std::string &psi_tag, const std::string &ion_tag) override
void	parse (const std::string &fname) override
void	getCell (const std::string &fname)
Public Member Functions inherited from QMCGaussianParserBase
	QMCGaussianParserBase ()
	QMCGaussianParserBase (int argc, char **argv)
virtual	~QMCGaussianParserBase ()=default
void	setOccupationNumbers ()
void	createGridNode (int argc, char **argv)
void	createSPOSets (xmlNodePtr, xmlNodePtr)
void	createSPOSetsH5 (xmlNodePtr, xmlNodePtr)
void	PrepareSPOSetsFromH5 (xmlNodePtr, xmlNodePtr)
xmlNodePtr	createElectronSet (const std::string &ion_tag)
xmlNodePtr	createIonSet ()
xmlNodePtr	createCell ()
xmlNodePtr	createHamiltonian (const std::string &ion_tag, const std::string &psi_tag)
xmlNodePtr	createBasisSet ()
xmlNodePtr	createBasisSetWithHDF5 ()
xmlNodePtr	createCenter (int iat, int _off)
void	createCenterH5 (int iat, int _off, int numelem)
void	createShell (int n, int ig, int off_, xmlNodePtr abasis)
void	createShellH5 (int n, int ig, int off_, int numelem)
xmlNodePtr	createDeterminantSet ()
xmlNodePtr	createMultiDeterminantSet ()
xmlNodePtr	createDeterminantSetWithHDF5 ()
xmlNodePtr	createMultiDeterminantSetFromH5 ()
xmlNodePtr	createMultiDeterminantSetCIHDF5 ()
xmlNodePtr	PrepareDeterminantSetFromHDF5 ()
xmlNodePtr	createJ3 ()
xmlNodePtr	createJ2 ()
xmlNodePtr	createJ1 ()
xmlNodePtr	parameter (xmlNodePtr Parent, std::string Mypara, std::string a)
int	numberOfExcitationsCSF (std::string &)
virtual void	dump (const std::string &psi_tag, const std::string &ion_tag)
void	dumpStdInput (const std::string &psi_tag, const std::string &ion_tag)
void	dumpStdInputProd (const std::string &psi_tag, const std::string &ion_tag)
Public Member Functions inherited from OhmmsAsciiParser
void	skiplines (std::istream &is, int n)
template<class T >
void	getValue (std::istream &is, T &aval)
template<class T1 , class T2 >
void	getValue (std::istream &is, T1 &aval, T2 &bval)
template<class IT >
void	getValues (std::istream &is, IT first, IT last)
int	search (std::istream &is, const std::string &keyword)
int	search (std::istream &is, const std::string &keyword, std::string &the_line)
bool	lookFor (std::istream &is, const std::string &keyword)
bool	lookFor (std::istream &is, const std::string &keyword, std::string &the_line)

Public Attributes
std::vector< std::string >	ECP_names
int	NumberOfSpins
Public Attributes inherited from QMCGaussianParserBase
bool	multideterminant
bool	multidetH5
bool	BohrUnit
bool	SpinRestricted
bool	Periodicity
bool	UseHDF5
bool	PBC
bool	production
bool	zeroCI
bool	orderByExcitation
bool	addJastrow
bool	addJastrow3Body
bool	ECP
bool	debug
bool	Structure
bool	DoCusp
bool	FixValence
bool	singledetH5
bool	optDetCoeffs
bool	usingCSF
bool	isSpinor
int	IonChargeIndex
int	ValenceChargeIndex
int	AtomicNumberIndex
int	NumberOfAtoms
int	NumberOfEls
int	target_state
int	SpinMultiplicity
int	NumberOfAlpha
int	NumberOfBeta
int	SizeOfBasisSet
int	numMO
int	readNO
int	readGuess
int	numMO2print
int	ci_size
int	ci_nca
int	ci_ncb
int	ci_nea
int	ci_neb
int	ci_nstates
int	NbKpts
int	nbexcitedstates
double	ci_threshold
std::vector< double >	STwist_Coord
std::string	Title
std::string	basisType
std::string	basisName
std::string	Normalized
std::string	CurrentCenter
std::string	outputFile
std::string	angular_type
std::string	expandYlm
std::string	h5file
std::string	multih5file
std::string	WFS_name
std::string	CodeName
const SimulationCell	simulation_cell
ParticleSet	IonSystem
std::vector< std::string >	GroupName
std::vector< int >	gShell
std::vector< int >	gNumber
std::vector< int >	gBound
std::vector< int >	Occ_alpha
std::vector< int >	Occ_beta
std::vector< value_type >	Qv
std::vector< value_type >	gExp
std::vector< value_type >	gC0
std::vector< value_type >	gC1
std::vector< value_type >	EigVal_alpha
std::vector< value_type >	EigVal_beta
std::vector< value_type >	EigVec
std::unique_ptr< xmlNode, void(*)(xmlNodePtr)>	gridPtr
std::vector< std::string >	CIalpha
std::vector< std::string >	CIbeta
std::vector< std::string >	CSFocc
std::vector< std::vector< std::string > >	CSFalpha
std::vector< std::vector< std::string > >	CSFbeta
std::vector< std::vector< double > >	CSFexpansion
std::vector< double >	CIcoeff
std::vector< double >	X
std::vector< double >	Y
std::vector< double >	Z
std::vector< int >	Image
std::vector< int >	CIexcitLVL
std::vector< std::pair< int, double > >	coeff2csf
Public Attributes inherited from OhmmsAsciiParser
char	dbuffer [bufferSize]
std::vector< std::string >	currentWords

Additional Inherited Members
Public Types inherited from QMCGaussianParserBase
using	value_type = double
using	SingleParticlePos = ParticleSet::SingleParticlePos
Static Public Member Functions inherited from QMCGaussianParserBase
static void	init ()
Static Public Attributes inherited from QMCGaussianParserBase
static std::map< int, std::string >	IonName
static std::vector< std::string >	gShellType
static std::vector< int >	gShellID
static const std::vector< double >	gCoreTable
Static Public Attributes inherited from OhmmsAsciiParser
static const int	bufferSize = 200

Detailed Description

Definition at line 21 of file RMGParser.h.

Constructor & Destructor Documentation

RMGParser() [1/2]

RMGParser

(

)

Definition at line 21 of file RMGParser.cpp.

References QMCGaussianParserBase::PBC.

{ PBC = true; }

RMGParser() [2/2]

RMGParser	(	int	argc,
		char **	argv
	)

Definition at line 23 of file RMGParser.cpp.

References QMCGaussianParserBase::PBC.

: QMCGaussianParserBase(argc, argv) { PBC = true; }

Member Function Documentation

dumpPBC()

void dumpPBC ( const std::string &  psi_tag, const std::string &  ion_tag  )

overridevirtual

Reimplemented from QMCGaussianParserBase.

Definition at line 58 of file RMGParser.cpp.

References QMCGaussianParserBase::addJastrow, QMCGaussianParserBase::createCell(), QMCGaussianParserBase::createElectronSet(), QMCGaussianParserBase::createIonSet(), QMCGaussianParserBase::createJ1(), QMCGaussianParserBase::createJ2(), QMCGaussianParserBase::createJ3(), qmcplusplus::doc, QMCGaussianParserBase::h5file, QMCGaussianParserBase::NumberOfAlpha, QMCGaussianParserBase::NumberOfBeta, QMCGaussianParserBase::NumberOfEls, NumberOfSpins, QMCGaussianParserBase::PBC, QMCGaussianParserBase::Structure, QMCGaussianParserBase::Title, and QMCGaussianParserBase::WFS_name.

{
  std::cout << " RMGParser::dumpPBC " << std::endl;
  if (!Structure)
  {
    xmlDocPtr doc_p      = xmlNewDoc((const xmlChar*)"1.0");
    xmlNodePtr qm_root_p = xmlNewNode(NULL, BAD_CAST "qmcsystem");
    if (PBC)
      xmlAddChild(qm_root_p, createCell());
    xmlAddChild(qm_root_p, createIonSet());
    xmlAddChild(qm_root_p, createElectronSet(ion_tag));
    xmlDocSetRootElement(doc_p, qm_root_p);
    std::string fname = Title + ".structure.xml";
    xmlSaveFormatFile(fname.c_str(), doc_p, 1);
    xmlFreeDoc(doc_p);
    Structure = true;
  }
  xmlDocPtr doc      = xmlNewDoc((const xmlChar*)"1.0");
  xmlNodePtr qm_root = xmlNewNode(NULL, BAD_CAST "qmcsystem");
  {
    //wavefunction
    xmlNodePtr wfPtr = xmlNewNode(NULL, (const xmlChar*)"wavefunction");
    xmlNewProp(wfPtr, (const xmlChar*)"name", (const xmlChar*)psi_tag.c_str());
    xmlNewProp(wfPtr, (const xmlChar*)"target", (const xmlChar*)"e");
    {
      xmlNodePtr detsetPtr = xmlNewNode(NULL, (const xmlChar*)"determinantset");
      xmlNewProp(detsetPtr, (const xmlChar*)"type", (const xmlChar*)"bspline");
      xmlNewProp(detsetPtr, (const xmlChar*)"href", (const xmlChar*)h5file.c_str());
      xmlNewProp(detsetPtr, (const xmlChar*)"source", (const xmlChar*)ion_tag.c_str());
      // this just reproduces the behavior of pw2qmcpack
      xmlNewProp(detsetPtr, (const xmlChar*)"sort", (const xmlChar*)"1");
      xmlNewProp(detsetPtr, (const xmlChar*)"tilematrix", (const xmlChar*)"1 0 0 0 1 0 0 0 1");
      xmlNewProp(detsetPtr, (const xmlChar*)"twistnum", (const xmlChar*)"0");
      xmlNewProp(detsetPtr, (const xmlChar*)"version", (const xmlChar*)"0.10");
      {
        std::ostringstream up_size, down_size;
        up_size << NumberOfAlpha;
        down_size << NumberOfBeta;

        xmlNodePtr slaterdetPtr = xmlNewNode(NULL, (const xmlChar*)"slaterdeterminant");

        xmlNodePtr updetPtr = xmlNewNode(NULL, (const xmlChar*)"determinant");
        xmlNewProp(updetPtr, (const xmlChar*)"id", (const xmlChar*)"updet");
        xmlNewProp(updetPtr, (const xmlChar*)"size", (const xmlChar*)up_size.str().c_str());

        xmlNodePtr occUpPtr = xmlNewNode(NULL, (const xmlChar*)"occupation");
        xmlNewProp(occUpPtr, (const xmlChar*)"mode", (const xmlChar*)"ground");
        xmlNewProp(occUpPtr, (const xmlChar*)"spindataset", (const xmlChar*)"0");
        xmlAddChild(updetPtr, occUpPtr);


        xmlNodePtr downdetPtr = xmlNewNode(NULL, (const xmlChar*)"determinant");
        xmlNewProp(downdetPtr, (const xmlChar*)"id", (const xmlChar*)"downdet");
        xmlNewProp(downdetPtr, (const xmlChar*)"size", (const xmlChar*)down_size.str().c_str());

        xmlNodePtr occDownPtr = xmlNewNode(NULL, (const xmlChar*)"occupation");
        xmlNewProp(occDownPtr, (const xmlChar*)"mode", (const xmlChar*)"ground");
        if (NumberOfSpins == 2)
        {
          xmlNewProp(downdetPtr, (const xmlChar*)"ref", (const xmlChar*)"updet");
          xmlNewProp(occDownPtr, (const xmlChar*)"spindataset", (const xmlChar*)"1");
        }
        else if (NumberOfSpins == 1)
        {
          xmlNewProp(occDownPtr, (const xmlChar*)"spindataset", (const xmlChar*)"0");
        }
        else
        {
          std::cerr << "Error: Number of spins should be 1 or 2. (" << NumberOfSpins << ")" << std::endl;
          abort();
        }
        xmlAddChild(downdetPtr, occDownPtr);

        xmlAddChild(slaterdetPtr, updetPtr);
        xmlAddChild(slaterdetPtr, downdetPtr);

        xmlAddChild(detsetPtr, slaterdetPtr);
      }
      xmlAddChild(wfPtr, detsetPtr);
      if (addJastrow)
      {
        std::cout << R"(Adding Two-Body and One-Body jastrows with rcut="10" and size="10")" << std::endl;
        if (NumberOfEls > 1)
        {
          xmlAddChild(wfPtr, createJ2());
        }
        xmlAddChild(wfPtr, createJ1());
        if (NumberOfEls > 1)
        {
          std::cout << "Adding Three-Body jastrows with rcut=\"5\"" << std::endl;
          xmlAddChild(wfPtr, createJ3());
        }
      }
    }
    xmlAddChild(qm_root, wfPtr);
  }
  xmlDocSetRootElement(doc, qm_root);
  std::string fname = Title + ".wf" + WFS_name + ".xml";
  xmlSaveFormatFile(fname.c_str(), doc, 1);
  xmlFreeDoc(doc);
}

getCell()

void getCell

(

const std::string &

fname

)

Definition at line 25 of file RMGParser.cpp.

References hdf_archive::close(), hdf_archive::open(), hdf_archive::push(), hdf_archive::read(), QMCGaussianParserBase::X, QMCGaussianParserBase::Y, and QMCGaussianParserBase::Z.

Referenced by parse().

{
  // from LCAOHDFParser (maybe put into base class?)
  X.resize(3);
  Y.resize(3);
  Z.resize(3);

  hdf_archive hin;

  if (!hin.open(fname.c_str(), H5F_ACC_RDONLY))
  {
    std::cerr << "Could not open H5 file" << std::endl;
    abort();
  }
  hin.push("supercell");
  Matrix<double> LatticeVec(3, 3);
  hin.read(LatticeVec, "primitive_vectors");
  X[0] = LatticeVec[0][0];
  X[1] = LatticeVec[0][1];
  X[2] = LatticeVec[0][2];
  Y[0] = LatticeVec[1][0];
  Y[1] = LatticeVec[1][1];
  Y[2] = LatticeVec[1][2];
  Z[0] = LatticeVec[2][0];
  Z[1] = LatticeVec[2][1];
  Z[2] = LatticeVec[2][2];
  hin.close();
  std::cout << "Lattice parameters in Bohr:" << std::endl;
  std::cout << X[0] << "  " << X[1] << "  " << X[2] << std::endl;
  std::cout << Y[0] << "  " << Y[1] << "  " << Y[2] << std::endl;
  std::cout << Z[0] << "  " << Z[1] << "  " << Z[2] << std::endl;
}

parse()

void parse ( const std::string &  fname )

overridevirtual

Implements QMCGaussianParserBase.

Definition at line 160 of file RMGParser.cpp.

References QMCGaussianParserBase::AtomicNumberIndex, QMCGaussianParserBase::CodeName, ParticleSet::create(), QMCGaussianParserBase::ECP, ECP_names, getCell(), ParticleSet::getSpeciesSet(), ParticleSet::GroupID, QMCGaussianParserBase::GroupName, QMCGaussianParserBase::IonChargeIndex, QMCGaussianParserBase::IonName, QMCGaussianParserBase::IonSystem, QMCGaussianParserBase::NumberOfAlpha, QMCGaussianParserBase::NumberOfAtoms, QMCGaussianParserBase::NumberOfBeta, QMCGaussianParserBase::NumberOfEls, NumberOfSpins, hdf_archive::open(), hdf_archive::pop(), hdf_archive::push(), ParticleSet::R, hdf_archive::read(), and QMCGaussianParserBase::STwist_Coord.

{
  hdf_archive hin;

  if (!hin.open(fname.c_str(), H5F_ACC_RDONLY))
  {
    std::cerr << "Could not open H5 file" << std::endl;
    abort();
  }

  hin.push("application");
  hin.read(CodeName, "code");
  std::cout << "Converting Wavefunction from the " << CodeName << " Code" << std::endl;
  hin.pop();

  hin.push("electrons");
  std::vector<double> Nalpha_Nbeta(2);
  hin.read(Nalpha_Nbeta, "number_of_electrons");
  NumberOfAlpha = Nalpha_Nbeta[0];
  NumberOfBeta  = Nalpha_Nbeta[1];
  NumberOfEls   = NumberOfAlpha + NumberOfBeta;
  std::cout << "Number of (alpha,beta) electrons: (" << NumberOfAlpha << ", " << NumberOfBeta << ")" << std::endl;

  hin.read(NumberOfSpins, "number_of_spins");
  std::cout << "Number of spins: " << NumberOfSpins << std::endl;
  hin.pop();

  hin.push("atoms");
  hin.read(NumberOfAtoms, "number_of_atoms");
  std::cout << "Number of atoms: " << NumberOfAtoms << std::endl;
  getCell(fname);

  IonSystem.create({NumberOfAtoms});
  GroupName.resize(NumberOfAtoms);
  Matrix<double> IonPos(NumberOfAtoms, 3);
  //atomic numbers
  std::vector<int> atomic_number;
  std::vector<double> q;
  ECP_names.clear();
  //read atomic info
  //MAP: (Atom Number, Species Index)
  std::vector<int> idx(NumberOfAtoms);
  std::map<int, int> AtomIndexmap;
  hin.read(idx, "species_ids");
  for (int i = 0; i < NumberOfAtoms; i++)
  {
    AtomIndexmap.insert(std::pair<int, int>(i, idx[i]));
  }
  for (int i = 0; i < NumberOfAtoms; i++)
  {
    std::string speciesName("species_");
    speciesName = speciesName + std::to_string(AtomIndexmap[i]);
    hin.push(speciesName);
    int zint;
    double z;
    std::string Name;
    std::string ecpName = "";
    hin.read(zint, "atomic_number");
    atomic_number.push_back(zint);
    hin.read(z, "valence_charge");
    q.push_back(z);
    hin.read(Name, "name");
    try
    {
      hin.read(ecpName, "pseudopotential");
      ECP_names.push_back(ecpName);
      ECP = true;
    }
    catch (...)
    {
      std::cerr << "WARNING: no ECP found for " << speciesName << ":" << Name << std::endl;
      ECP_names.push_back(ecpName);
    }
    hin.pop();
  }
  hin.read(IonPos, "positions");

  SpeciesSet& species(IonSystem.getSpeciesSet());
  for (int i = 0; i < NumberOfAtoms; i++)
  {
    IonSystem.R[i][0]                     = IonPos[i][0];
    IonSystem.R[i][1]                     = IonPos[i][1];
    IonSystem.R[i][2]                     = IonPos[i][2];
    GroupName[i]                          = IonName[atomic_number[i]];
    int speciesID                         = species.addSpecies(GroupName[i]);
    IonSystem.GroupID[i]                  = speciesID;
    species(AtomicNumberIndex, speciesID) = atomic_number[i];
    species(IonChargeIndex, speciesID)    = q[i];
  }
  hin.pop(); // atoms


  // this is just a messy workaround to avoid modifying the behavior of convert4qmc
  // if (PBC) then convert4qmc will try to print the first 3 elements of STwist_Coord
  STwist_Coord.resize(3);
  try
  {
    hin.push("Super_Twist");
    Matrix<double> STVec(1, 3);
    hin.read(STVec, "Coord");
    hin.pop();
    STwist_Coord[0] = STVec[0][0];
    STwist_Coord[1] = STVec[0][1];
    STwist_Coord[2] = STVec[0][2];
  }
  catch (...)
  {
    std::cout << "Could not find Super_Twist, using [0,0,0] (not yet implemented in basic RMG interface)" << std::endl;
    STwist_Coord[0] = 0;
    STwist_Coord[1] = 0;
    STwist_Coord[2] = 0;
  }
}

Member Data Documentation

ECP_names

std::vector<std::string> ECP_names

Definition at line 28 of file RMGParser.h.

Referenced by parse().

NumberOfSpins

int NumberOfSpins

Definition at line 29 of file RMGParser.h.

Referenced by dumpPBC(), and parse().

---

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

• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCTools/RMGParser.h
• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCTools/RMGParser.cpp