QPParser Class Reference

Inheritance diagram for QPParser:

Collaboration diagram for QPParser:

Public Member Functions
	QPParser ()
	QPParser (int argc, char **argv)
void	parse (const std::string &fname)
void	getGeometry (std::istream &is)
void	getGaussianCenters (std::istream &is)
void	getMO (std::istream &is)
void	getMO_single_set (std::istream &is, Matrix< double > &CartMat, std::vector< value_type > &EigVal_alpha)
void	getQPCI (std::istream &is)
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	dumpPBC (const std::string &psi_tag, const std::string &ion_tag)
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::streampos	pivot_begin
std::vector< std::string >	tags
std::string	MOtype
int	readtype
int	numAO
int	NFZC
int	NEXT
int	NTOT
int	NAC
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 24 of file QPParser.h.

Constructor & Destructor Documentation

QPParser() [1/2]

QPParser

(

)

Definition at line 22 of file QPParser.cpp.

References QMCGaussianParserBase::angular_type, QMCGaussianParserBase::basisName, QMCGaussianParserBase::BohrUnit, MOtype, NFZC, QMCGaussianParserBase::Normalized, numAO, and readtype.

{
  basisName    = "Gaussian";
  Normalized   = "no";
  BohrUnit     = true;
  MOtype       = "Canonical";
  angular_type = "cartesian";
  readtype     = 0;
  NFZC         = 0;
  numAO        = 0;
}

QPParser() [2/2]

QPParser	(	int	argc,
		char **	argv
	)

Definition at line 34 of file QPParser.cpp.

References QMCGaussianParserBase::angular_type, QMCGaussianParserBase::basisName, QMCGaussianParserBase::BohrUnit, MOtype, NFZC, QMCGaussianParserBase::Normalized, numAO, readtype, and QMCGaussianParserBase::SpinRestricted.

                                        : QMCGaussianParserBase(argc, argv)
{
  basisName      = "Gaussian";
  Normalized     = "no";
  BohrUnit       = true;
  MOtype         = "Canonical";
  angular_type   = "cartesian";
  SpinRestricted = true;
  readtype       = 0;
  NFZC           = 0;
  numAO          = 0;
}

Member Function Documentation

getGaussianCenters()

void getGaussianCenters

(

std::istream &

is

)

Definition at line 321 of file QPParser.cpp.

References OhmmsAsciiParser::currentWords, QMCGaussianParserBase::debug, QMCGaussianParserBase::gBound, QMCGaussianParserBase::gC0, QMCGaussianParserBase::gC1, getwords(), QMCGaussianParserBase::gExp, QMCGaussianParserBase::gNumber, QMCGaussianParserBase::gShell, OhmmsAsciiParser::lookFor(), QMCGaussianParserBase::NumberOfAtoms, pivot_begin, QMCGaussianParserBase::SizeOfBasisSet, and tags.

Referenced by parse().

{
  std::string Shell_temp;
  gBound.resize(NumberOfAtoms + 1);
  int ng;
  std::string aline;
  std::map<std::string, int> basisDataMap;
  int nUniqAt = 0;
  for (int i = 0; i < NumberOfAtoms; i++)
  {
    std::map<std::string, int>::iterator it(basisDataMap.find(tags[i]));
    if (it == basisDataMap.end())
    {
      basisDataMap[tags[i]] = nUniqAt++;
    }
  }
  std::vector<std::vector<double>> expo(nUniqAt), coef(nUniqAt), coef2(nUniqAt);
  std::vector<int> nshll(nUniqAt, 0); //use this to
  std::vector<std::vector<int>> ncoeffpershell(nUniqAt);
  std::vector<std::vector<std::string>> shID(nUniqAt);
  std::map<std::string, int> gsMap;
  gsMap[std::string("S")]  = 1;
  gsMap[std::string("SP")] = 2;
  gsMap[std::string("P")]  = 3;
  gsMap[std::string("D")]  = 4;
  gsMap[std::string("F")]  = 5;
  gsMap[std::string("G")]  = 6;
  gsMap[std::string("H")]  = 7;
  gsMap[std::string("I")]  = 8;
  is.seekg(pivot_begin);
  bool found = false;
  while (!found)
  {
    if (is.eof())
    {
      std::cerr << "Problem with basis set data.\n";
      abort();
    }
    getwords(currentWords, is);
    if (currentWords.size() > 2)
      continue;
    if (currentWords[0] == "BEGIN_BASIS_SET")
      found = true;
  }


  is.seekg(pivot_begin);


  int currPos = -1;
  lookFor(is, "BEGIN_BASIS_SET");
  int NbCoeffperShell = 0;
  getwords(currentWords, is);
  bool allbase = true;
  while (allbase == true)
  {
    if (currentWords.empty())
      getwords(currentWords, is);
    if (currentWords.size() == 1)
    {
      std::map<std::string, int>::iterator it(basisDataMap.find(currentWords[0]));
      if (it == basisDataMap.end())
      {
        std::cerr << "Error in parser.\n";
        abort();
      }
      currPos        = it->second;
      nshll[currPos] = 0;
      ncoeffpershell[currPos].clear();
      ncoeffpershell[currPos].push_back(0);
      shID[currPos].clear();
      shID[currPos].push_back("NONE");

      bool group = true;
      do
      {
        getwords(currentWords, is);
        if (currentWords[0] == "S" || currentWords[0] == "P" || currentWords[0] == "D" || currentWords[0] == "F" ||
            currentWords[0] == "G" || currentWords[0] == "H" || currentWords[0] == "I") //empty line after the shell
        {
          shID[currPos].push_back(currentWords[0]);
          Shell_temp                              = currentWords[0];
          NbCoeffperShell                         = atoi(currentWords[1].c_str());
          ncoeffpershell[currPos][nshll[currPos]] = NbCoeffperShell;
          for (int nbcoef = 0; nbcoef < NbCoeffperShell; nbcoef++)
          {
            getwords(currentWords, is);
            expo[currPos].push_back(atof(currentWords[1].c_str()));
            coef[currPos].push_back(atof(currentWords[2].c_str()));
            shID[currPos][nshll[currPos]] = Shell_temp;
            if (debug)
            {
              std::cout << currPos << ":" << expo[currPos].back() << " " << coef[currPos].back() << " "
                        << ncoeffpershell[currPos][nshll[currPos]] << " " << shID[currPos][nshll[currPos]] << std::endl;
            }
          }
          nshll[currPos]++;
          ncoeffpershell[currPos].push_back(0);
          shID[currPos].push_back("NONE");
        }
        else
        {
          if (currentWords[0] == "END_BASIS_SET")
          {
            ng      = SizeOfBasisSet;
            group   = false;
            allbase = false;
            break;
          }
          else
          {
            break;
          }
        }
      } while (group == true);
    }
    else
    {
      std::cerr << "error in parser" << std::endl;
      abort();
    }
  }

  gShell.clear();
  gNumber.clear();
  gExp.clear();
  gC0.clear();
  gC1.clear();
  int gtot = 0;

  for (int i = 0; i < NumberOfAtoms; i++)
  {
    std::map<std::string, int>::iterator it(basisDataMap.find(tags[i]));
    if (it == basisDataMap.end())
    {
      std::cerr << "Error in parser.\n";
      abort();
    }
    gBound[i] = gtot;
    int indx  = it->second;
    gtot += nshll[indx];
    for (int k = 0; k < nshll[indx]; k++)
    {
      gShell.push_back(gsMap[shID[indx][k]]);
    }
    for (int k = 0; k < nshll[indx]; k++)
      gNumber.push_back(ncoeffpershell[indx][k]);
    for (int k = 0; k < expo[indx].size(); k++)
      gExp.push_back(expo[indx][k]);
    for (int k = 0; k < coef[indx].size(); k++)
      gC0.push_back(coef[indx][k]);
  }
  gBound[NumberOfAtoms] = gtot;
}

getGeometry()

void getGeometry

(

std::istream &

is

)

Definition at line 153 of file QPParser.cpp.

References QMCGaussianParserBase::AtomicNumberIndex, OhmmsAsciiParser::currentWords, BLAS::done, QMCGaussianParserBase::ECP, ParticleSet::getSpeciesSet(), getwords(), ParticleSet::GroupID, QMCGaussianParserBase::GroupName, QMCGaussianParserBase::IonChargeIndex, QMCGaussianParserBase::IonName, QMCGaussianParserBase::IonSystem, QMCGaussianParserBase::NumberOfAtoms, pivot_begin, ParticleSet::R, and tags.

Referenced by parse().

{
  //atomic numbers
  std::vector<int> atomic_number, core;
  std::vector<double> q, pos;
  int natms = 0;
  tags.clear();
  is.seekg(pivot_begin);
  //read atomic info
  bool notfound = true;

  do
  {
    if (is.eof())
    {
      std::cerr << "Could not find atomic coordinates. \n";
      abort();
    }
    getwords(currentWords, is);
    if (currentWords.size() < 4)
      continue;
    if (currentWords.size() == 4)
      if (currentWords[0] == "Atomic" && currentWords[1] == "coord" && currentWords[2] == "in" &&
          currentWords[3] == "Bohr")
      {
        notfound = false;
        getwords(currentWords, is);
        while (currentWords.size() != 0)
        {
          if (currentWords[0] == "BEGIN_BASIS_SET")
            break;
          natms++;
          double z = atof(currentWords[1].c_str());
          int zint = (int)z; // is this dangerous???
          atomic_number.push_back(zint);
          q.push_back(z); // if using ECPs, change below
          tags.push_back(currentWords[0]);
          pos.push_back(atof(currentWords[2].c_str()));
          pos.push_back(atof(currentWords[3].c_str()));
          pos.push_back(atof(currentWords[4].c_str()));
          getwords(currentWords, is);
        }
      }
  } while (notfound);
  if (natms != NumberOfAtoms)
  {
    std::cerr << "Could not find atomic coordinates for all atoms. \n";
    abort();
  }
  //ECP PART!!!
  if (ECP == true)
  {
    is.seekg(pivot_begin);
    notfound = true;

    while (notfound)
    {
      if (is.eof())
      {
        std::cerr << "Problem looking for ECPs, this should not happen. Contact developers for help. \n";
        abort();
      }
      getwords(currentWords, is);
      // this should appear below the ECP section in the output file
      // so use this to avoid going all the way to the bottom
      if (currentWords.size() == 0)
        continue;
      if (currentWords[0] == "BEGIN_PSEUDO")
      {
        core.resize(NumberOfAtoms);
        //    getwords(currentWords,is); // -------------
        bool done = false;
        while (!done)
        {
          if (is.eof())
          {
            std::cerr << "2 Found ECPs, but problem looking ZCORE data.\n";
            abort();
          }
          getwords(currentWords, is);
          if (currentWords.size() == 0)
            continue;
          if (currentWords.size() == 1)
          {
            if (currentWords[0] == "END_PSEUDO")
              done = true;
          }
          if (currentWords[0] == "PARAMETERS" && currentWords[1] == "FOR")
          {
            //done=true;
            std::vector<std::string>::iterator it, it0;
            it  = find(currentWords.begin(), currentWords.end(), "ZCORE");
            it0 = find(currentWords.begin(), currentWords.end(), "ATOM");
            if (it0 == currentWords.end())
            {
              std::cerr << "Problem with ECP data. Didn't found ATOM tag\n";
              std::cerr << is.rdbuf() << std::endl;
              abort();
            }
            it0++;
            int nq0 = atoi(it0->c_str()) - 1;
            if (it != currentWords.end())
            {
              it++;
              core[nq0] = atoi(it->c_str());
              q[nq0] -= core[nq0];

              std::cout << "1 Found ECP for atom " << nq0 << " with zcore " << core[nq0] << std::endl;
            }
            else
            {
              it = find(currentWords.begin(), currentWords.end(), "ATOM");
              if (it == currentWords.end())
              {
                std::cerr << "Problem with ECP data. Didn't found ATOM tag\n";
                std::cerr << "Atom: " << nq0 << std::endl;
                abort();
              }
              std::vector<std::string>::iterator it2 = it;
              it2++;
              int nq = atoi(it2->c_str());
              if (nq != nq0 + 1)
              {
                std::cerr << "Problem with ECP data. ID's don't agree\n";
                std::cerr << "Atom: " << nq0 << std::endl;
                abort();
              }
              it = find(it2, currentWords.end(), "ATOM");
              if (it == currentWords.end())
              {
                std::cerr << "Problem with ECP data (2).\n";
                std::cerr << "Atom: " << nq0 << std::endl;
                abort();
              }
              nq        = atoi((it + 1)->c_str());
              core[nq0] = core[nq - 1];
              q[nq0] -= core[nq0];
              std::cout << "2 Found ECP for atom " << nq0 << " with zcore " << core[nq0] << std::endl;
            }
          }
        }
        notfound = false;
      }
      else
      {
        if (currentWords.size() < 2)
          continue;
        if (currentWords[0] == "END_PSEUDO")
          break;
      }
    }
  }


  SpeciesSet& species(IonSystem.getSpeciesSet());
  for (int i = 0, ii = 0; i < NumberOfAtoms; i++)
  {
    IonSystem.R[i][0]                     = pos[ii++];
    IonSystem.R[i][1]                     = pos[ii++];
    IonSystem.R[i][2]                     = pos[ii++];
    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];
  }
}

getMO()

void getMO

(

std::istream &

is

)

Definition at line 476 of file QPParser.cpp.

References OhmmsAsciiParser::currentWords, QMCGaussianParserBase::EigVal_alpha, QMCGaussianParserBase::EigVal_beta, QMCGaussianParserBase::EigVec, getMO_single_set(), getwords(), QMCGaussianParserBase::numMO, OhmmsAsciiParser::search(), QMCGaussianParserBase::SizeOfBasisSet, and QMCGaussianParserBase::SpinRestricted.

Referenced by parse().

{
  EigVal_alpha.resize(numMO);
  EigVal_beta.resize(numMO);
  EigVec.resize(2 * SizeOfBasisSet * numMO);
  std::string aline;
  search(is, "BEGIN_MO");
  getwords(currentWords, is); // empty line

  std::vector<double> dummy(50);
  Matrix<double> CartMat(numMO, SizeOfBasisSet);
  std::streampos pivot;
  pivot = is.tellg();
  std::vector<std::string> CartLabels(SizeOfBasisSet);
  getwords(currentWords, is);
  for (int k = 0; k < SizeOfBasisSet; k++)
  {
    getwords(currentWords, is);
    CartLabels[k] = currentWords[0];
  }

  is.seekg(pivot);

  getMO_single_set(is, CartMat, EigVal_alpha);
  int cnt = 0;
  for (int i = 0; i < numMO; i++)
    for (int k = 0; k < SizeOfBasisSet; k++)
      EigVec[cnt++] = CartMat[i][k];

  // beta states for now
  if (!SpinRestricted)
  {
    search(is, "BEGIN_MO");
    getwords(currentWords, is); // empty line
    getMO_single_set(is, CartMat, EigVal_beta);
  }

  for (int i = 0; i < numMO; i++)
    for (int k = 0; k < SizeOfBasisSet; k++)
      EigVec[cnt++] = CartMat[i][k];
  std::cout << "Finished reading MO." << std::endl;
}

getMO_single_set()

void getMO_single_set	(	std::istream &	is,
		Matrix< double > &	CartMat,
		std::vector< value_type > &	EigVal_alpha
	)

Definition at line 519 of file QPParser.cpp.

References OhmmsAsciiParser::currentWords, getwords(), QMCGaussianParserBase::numMO, and QMCGaussianParserBase::SizeOfBasisSet.

Referenced by getMO().

{
  int nq  = numMO / 4;
  int rem = numMO % 4;
  int cnt = 0;
  for (int i = 0; i < nq; i++)
  {
    getwords(currentWords, is);
    for (int k = 0; k < SizeOfBasisSet; k++)
    {
      getwords(currentWords, is);
      if (currentWords.size() == 6)
      {
        CartMat[cnt][k]     = atof(currentWords[2].c_str());
        CartMat[cnt + 1][k] = atof(currentWords[3].c_str());
        CartMat[cnt + 2][k] = atof(currentWords[4].c_str());
        CartMat[cnt + 3][k] = atof(currentWords[5].c_str());
      }
      else
      {
        std::cerr << "Problem reading orbitals!!" << std::endl;
        abort();
      }
    }
    getwords(currentWords, is);
    cnt += 4;
  }
  if (rem > 0)
  {
    getwords(currentWords, is);

    for (int k = 0; k < SizeOfBasisSet; k++)
    {
      getwords(currentWords, is);
      for (int i = 0; i < rem; i++)
      {
        CartMat[cnt + i][k] = atof(currentWords[2 + i].c_str());
      }
    }
    getwords(currentWords, is);
  }
}

getQPCI()

void getQPCI

(

std::istream &

is

)

Definition at line 563 of file QPParser.cpp.

References QMCGaussianParserBase::ci_nca, QMCGaussianParserBase::ci_ncb, QMCGaussianParserBase::ci_nea, QMCGaussianParserBase::ci_neb, QMCGaussianParserBase::ci_nstates, QMCGaussianParserBase::ci_size, QMCGaussianParserBase::CIalpha, QMCGaussianParserBase::CIbeta, QMCGaussianParserBase::CIcoeff, OhmmsAsciiParser::currentWords, and getwords().

Referenced by parse().

{
  CIcoeff.clear();
  CIalpha.clear();
  CIbeta.clear();
  CIcoeff.resize(ci_size);
  CIalpha.resize(ci_size);
  CIbeta.resize(ci_size);


  for (int i = 0; i < ci_size; i++)
  {
    getwords(currentWords, is); //Empty Line
    if (currentWords[0] == "END_DET")
    {
      std::cout << "Done reading determinants" << std::endl;
      break;
    }

    getwords(currentWords, is); //Coeff
    CIcoeff[i] = atof(currentWords[0].c_str());

    //Alpha spin
    getwords(currentWords, is);
    CIalpha[i] = currentWords[0];
    //Beta spin
    getwords(currentWords, is);
    CIbeta[i] = currentWords[0];
  }
  ci_nea = ci_neb = 0;
  for (int i = 0; i < CIalpha[0].size(); i++)
    if (CIalpha[0].at(i) == '1')
      ci_nea++;
  for (int i = 0; i < CIbeta[0].size(); i++)
    if (CIbeta[0].at(i) == '1')
      ci_neb++;
  if (CIalpha[0].size() != CIbeta[0].size())
  {
    std::cerr << "QMCPACK can't handle different number of active orbitals in alpha and beta channels right now. "
                 "Contact developers for help (Miguel).\n";
    abort();
  }
  //  int ds=SpinMultiplicity-1;
  //  int neb= (NumberOfEls-ds)/2;
  //  int nea= NumberOfEls-NumberOfBeta;
  ci_nca = 0;
  ci_ncb = 0;
  std::cout << " Done reading CIs!!" << std::endl;
  ci_nstates = CIalpha[0].size();
}

parse()

void parse ( const std::string &  fname )

virtual

Implements QMCGaussianParserBase.

Definition at line 47 of file QPParser.cpp.

References QMCGaussianParserBase::ci_size, ParticleSet::create(), OhmmsAsciiParser::currentWords, QMCGaussianParserBase::ECP, getGaussianCenters(), getGeometry(), getMO(), getQPCI(), getwords(), QMCGaussianParserBase::GroupName, QMCGaussianParserBase::IonSystem, MOtype, QMCGaussianParserBase::multideterminant, NAC, NEXT, NFZC, NTOT, numAO, QMCGaussianParserBase::NumberOfAlpha, QMCGaussianParserBase::NumberOfAtoms, QMCGaussianParserBase::NumberOfBeta, QMCGaussianParserBase::NumberOfEls, QMCGaussianParserBase::numMO, parsewords(), pivot_begin, readtype, OhmmsAsciiParser::search(), QMCGaussianParserBase::SizeOfBasisSet, QMCGaussianParserBase::SpinMultiplicity, and QMCGaussianParserBase::SpinRestricted.

{
  std::ifstream fin(fname.c_str());
  pivot_begin = fin.tellg();
  std::string aline;

  search(fin, "do_pseudo", aline);
  parsewords(aline.c_str(), currentWords);
  if (currentWords[1] == "True")
  {
    ECP = true;
  }
  else
  {
    ECP = false;
  }
  std::cout << "usingECP: " << (ECP ? ("yes") : ("no")) << std::endl;
  std::cout.flush();

  search(fin, "multi_det", aline);
  parsewords(aline.c_str(), currentWords);
  if (currentWords[1] == "True")
    multideterminant = true;
  else
    multideterminant = false;

  std::cout << "Multideterminant: " << (multideterminant ? ("yes") : ("no")) << std::endl;


  search(fin, "ao_num", aline);
  parsewords(aline.c_str(), currentWords);
  numAO = atoi(currentWords[1].c_str());
  std::cout << "NUMBER OF AOs: " << numAO << std::endl;
  SizeOfBasisSet = numAO;
  std::cout << "Size of Basis Set: " << SizeOfBasisSet << std::endl;

  search(fin, "mo_num", aline);
  parsewords(aline.c_str(), currentWords);
  numMO = atoi(currentWords[1].c_str());
  std::cout << "NUMBER OF MOs: " << numMO << std::endl;


  search(fin, "elec_alpha_num", aline);
  parsewords(aline.c_str(), currentWords);
  NumberOfAlpha = atoi(currentWords[1].c_str());
  std::cout << "Number of alpha electrons: " << NumberOfAlpha << std::endl;
  search(fin, "elec_beta_num", aline);
  parsewords(aline.c_str(), currentWords);
  NumberOfBeta = atoi(currentWords[1].c_str());
  std::cout << "Number of beta electrons: " << NumberOfBeta << std::endl;


  search(fin, "elec_tot_num", aline);
  parsewords(aline.c_str(), currentWords);
  NumberOfEls = atoi(currentWords[1].c_str());
  std::cout << "Number of electrons: " << NumberOfEls << std::endl;


  search(fin, "spin_multiplicity", aline);
  parsewords(aline.c_str(), currentWords);
  SpinMultiplicity = atoi(currentWords[1].c_str());
  std::cout << "SPIN MULTIPLICITY: " << SpinMultiplicity << std::endl;

  SpinRestricted = true;


  search(fin, "nucl_num", aline);
  parsewords(aline.c_str(), currentWords);
  NumberOfAtoms = atoi(currentWords[1].c_str());
  std::cout << "NUMBER OF ATOMS: " << NumberOfAtoms << std::endl;


  IonSystem.create(NumberOfAtoms);
  GroupName.resize(NumberOfAtoms);
  getGeometry(fin);
  fin.seekg(pivot_begin);

  getGaussianCenters(fin);
  fin.seekg(pivot_begin);
  MOtype   = "Canonical";
  readtype = 0;
  getMO(fin);
  fin.close();


  if (multideterminant)
  {
    fin.open(fname.c_str());
    QP          = true;
    pivot_begin = fin.tellg();
    search(fin, "BEGIN_DET", aline);
    getwords(currentWords, fin); //Empty Line
    getwords(currentWords, fin); //mo_num
    getwords(currentWords, fin); //Number Of determinants
    std::cout << "Found " << currentWords[1] << " Determinants" << std::endl;
    ci_size = atoi(currentWords[1].c_str());
    NFZC    = 0;
    NAC     = numMO;
    NEXT    = 0;
    NTOT    = NEXT + NAC;
    std::cout << "# core, #active, #external: " << NFZC << " " << NAC << " " << NEXT << std::endl;
    //fin.seekg(pivot_begin);
    getQPCI(fin);
  }
}

Member Data Documentation

MOtype

std::string MOtype

Definition at line 33 of file QPParser.h.

Referenced by parse(), and QPParser().

NAC

int NAC

Definition at line 35 of file QPParser.h.

Referenced by parse().

NEXT

int NEXT

Definition at line 35 of file QPParser.h.

Referenced by parse().

NFZC

int NFZC

Definition at line 35 of file QPParser.h.

Referenced by parse(), and QPParser().

NTOT

int NTOT

Definition at line 35 of file QPParser.h.

Referenced by parse().

numAO

int numAO

Definition at line 34 of file QPParser.h.

Referenced by parse(), and QPParser().

pivot_begin

std::streampos pivot_begin

Definition at line 31 of file QPParser.h.

Referenced by getGaussianCenters(), getGeometry(), and parse().

readtype

int readtype

Definition at line 34 of file QPParser.h.

Referenced by parse(), and QPParser().

tags

std::vector<std::string> tags

Definition at line 32 of file QPParser.h.

Referenced by getGaussianCenters(), and getGeometry().

---

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

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