XMLParticleParser Class Reference

Inheritance diagram for XMLParticleParser:

Collaboration diagram for XMLParticleParser:

Public Member Functions
	XMLParticleParser (Particle_t &aptcl)
	constructor More...
bool	readXML (xmlNodePtr cur)
	process xmlnode <particleset/> which contains everything about the particle set to initialize More...
bool	reset (xmlNodePtr cur)
	reset the properties of a particle set More...

Private Types
using	Particle_t = ParticleSet
using	ParticleIndex = Particle_t::ParticleIndex
using	ParticleScalar = Particle_t::ParticleScalar
using	ParticlePos = Particle_t::ParticlePos
using	ParticleTensor = Particle_t::ParticleTensor

Private Member Functions
void	getPtclAttrib (xmlNodePtr cur, int in_offset, int copy_size, int out_offset)
	read the data of a particle attribute More...
void	checkGrouping (int nat, const std::vector< int > &nat_group) const

Private Attributes
Particle_t &	ref_
AttribListType	ref_AttribList

Additional Inherited Members
Public Types inherited from ParticleTags
enum	{   PA_IndexType = 0, PA_ScalarType, PA_StringType, PA_PositionType,   PA_TensorType, PA_UnkownType }
	enumeraton for datatypes for particle attributes More...
Static Public Attributes inherited from ParticleTags
static std::string	null_tag = "null"
	type names of particle attributes, e.g., posArray More...
static std::string	indextype_tag = "indexArray"
	the datatype tag for the index-type attribute More...
static std::string	scalartype_tag = "scalarArray"
	the datatype tag for the scalar-type attribute More...
static std::string	stringtype_tag = "stringArray"
	the datatype tag for the string-type attribute More...
static std::string	postype_tag = "posArray"
	the datatype tag for the pos-type attribute More...
static std::string	gradtype_tag = "gradArray"
	the datatype tag for the gradient-type attribute More...
static std::string	laptype_tag = "lapArray"
	the datatype tag for the laplacian-type attribute More...
static std::string	tensortype_tag = "tensorArray"
	the datatype tag for the tensor-type attribute More...
static std::string	xmoltype_tag = "xmolArray"
	the datatype tag for the xmol-type attribute More...
static std::string	position_tag = "position"
	names of particle attributes, e.g., position More...
static std::string	spins_tag = "spins"
	the name for spins attribute More...
static std::string	id_tag = "id"
	the name for id attribute More...
static std::string	ionid_tag = "ionid"
	the name for ionid attribute More...
static std::string	trajectory_tag = "trajectory"
	the name for trajectory attribute More...
static std::string	force_tag = "f"
	the name for force attribute More...
static std::string	velocity_tag = "v"
	the name for velocity attribute More...
static std::string	energy_tag = "e"
	the name for energy attribute More...
static std::string	sumbc_tag = "sumbc"
	the name for sumbc (accumulative boundary crossings) attribute More...
static std::string	root_tag = "particleset"
	xml element names More...
static std::string	attrib_tag = "attrib"
	the name of particle attribute node More...
static std::string	name_tag = "name"
	the attribute name of name More...
static std::string	datatype_tag = "datatype"
	the attribute name of datatype More...
static std::string	condition_tag = "condition"
	the attribute name of condition More...
static std::string	size_tag = "size"
	the attribute name of size More...
static std::string	format_tag = "format"
	the attribute name of format More...
static std::string	role_tag = "role"
	the attribute name of role More...

Detailed Description

Definition at line 94 of file XMLParticleIO.h.

Member Typedef Documentation

Particle_t

using Particle_t = ParticleSet

private

Definition at line 96 of file XMLParticleIO.h.

ParticleIndex

using ParticleIndex = Particle_t::ParticleIndex

private

Definition at line 97 of file XMLParticleIO.h.

ParticlePos

using ParticlePos = Particle_t::ParticlePos

private

Definition at line 99 of file XMLParticleIO.h.

ParticleScalar

using ParticleScalar = Particle_t::ParticleScalar

private

Definition at line 98 of file XMLParticleIO.h.

ParticleTensor

using ParticleTensor = Particle_t::ParticleTensor

private

Definition at line 100 of file XMLParticleIO.h.

Constructor & Destructor Documentation

XMLParticleParser()

XMLParticleParser

(

Particle_t &

aptcl

)

constructor

Parameters

aptcl

the particleset to be initialized

Definition at line 80 of file XMLParticleIO.cpp.

References ParticleSet::createAttributeList(), XMLParticleParser::ref_, and XMLParticleParser::ref_AttribList.

                                                      : ref_(aptcl)
{
  //add ref particle attributes
  ref_.createAttributeList(ref_AttribList);
}

Member Function Documentation

checkGrouping()

void checkGrouping ( int  nat, const std::vector< int > &  nat_group  ) const

private

Definition at line 352 of file XMLParticleIO.cpp.

References app_debug, SpeciesSet::getSpeciesName(), ParticleSet::getSpeciesSet(), and XMLParticleParser::ref_.

Referenced by XMLParticleParser::readXML().

{
  app_debug() << "There are " << nat << " particles in " << nat_group.size() << " species containing:" << std::endl;
  for (int ig = 0; ig < nat_group.size(); ig++)
  {
    const auto& group_species_name = ref_.getSpeciesSet().getSpeciesName(ig);
    if (nat_group[ig] == 0)
      throw UniformCommunicateError("Element '" + group_species_name + "' was provided but never referenced.");
    app_debug() << "    " << nat_group[ig] << " '" << group_species_name << "'" << std::endl;
  }

  if (std::accumulate(nat_group.begin(), nat_group.end(), 0) != nat)
    throw UniformCommunicateError(
        "The total number of particles doesn't match the sum of the particle counts of all the species.");
}

getPtclAttrib()

void getPtclAttrib ( xmlNodePtr  cur, int  in_offset, int  copy_size, int  out_offset  )

private

read the data of a particle attribute

Parameters

cur	the xmlnode
in_offset	the location offset to read from XML element node body.
copy_size	the number of particle attributes to be read
out_offset	the current local count to which copy_size particle attributes are added.

Definition at line 433 of file XMLParticleIO.cpp.

References OhmmsAttributeSet::add(), qmcplusplus::app_error(), ParticleTags::condition_tag, ParticleTags::datatype_tag, AttribListType::getAttribType(), AttribListType::getAttribute(), ParticleTags::ionid_tag, ParticleTags::PA_IndexType, ParticleTags::PA_PositionType, ParticleTags::PA_ScalarType, ParticleTags::PA_TensorType, OhmmsAttributeSet::put(), and XMLParticleParser::ref_AttribList.

Referenced by XMLParticleParser::readXML().

{
  std::string oname, otype;
  int utype   = 0;
  int size_in = 0;
  OhmmsAttributeSet pAttrib;
  pAttrib.add(otype, datatype_tag);  //datatype
  pAttrib.add(oname, "name");        //name
  pAttrib.add(utype, condition_tag); //condition
  pAttrib.add(size_in, "size");      //size
  pAttrib.put(cur);
  if (oname.empty() || otype.empty())
  {
    app_error() << "   Missing attrib/@name or attrib/@datatype " << std::endl;
    app_error() << R"(     <attrib name="aname"  datatype="atype"/>)" << std::endl;
    return;
  }
  int t_id = ref_AttribList.getAttribType(otype);

  if (oname == ionid_tag)
    throw UniformCommunicateError("'ionid' should not be parsed by getPtclAttrib.");
  else
  {
    //very permissive in that a unregistered attribute will be created and stored by ParticleSet
    //cloning is not going to work
    if (t_id == PA_IndexType)
    {
      ParticleIndex* obj = ref_AttribList.getAttribute<PtclOnLatticeTraits::Index_t>(otype, oname);
      ParticleAttribXmlNode<ParticleIndex> a(*obj, static_cast<PosUnit>(utype));
      a.put(cur, in_offset, copy_size, out_offset);
    }
    else if (t_id == PA_ScalarType)
    {
      ParticleScalar* obj = ref_AttribList.getAttribute<PtclOnLatticeTraits::Scalar_t>(otype, oname);
      ParticleAttribXmlNode<ParticleScalar> a(*obj, static_cast<PosUnit>(utype));
      a.put(cur, in_offset, copy_size, out_offset);
    }
    else if (t_id == PA_PositionType)
    {
      ParticlePos* obj = ref_AttribList.getAttribute<PtclOnLatticeTraits::SingleParticlePos>(otype, oname);
      ParticleAttribXmlNode<ParticlePos> a(*obj, static_cast<PosUnit>(utype));
      a.put(cur, in_offset, copy_size, out_offset);
    }
    else if (t_id == PA_TensorType)
    {
      ParticleTensor* obj = ref_AttribList.getAttribute<PtclOnLatticeTraits::Tensor_t>(otype, oname);
      ParticleAttribXmlNode<ParticleTensor> a(*obj, static_cast<PosUnit>(utype));
      a.put(cur, in_offset, copy_size, out_offset);
    }
  }
}

readXML()

bool readXML

(

xmlNodePtr

cur

)

process xmlnode <particleset/> which contains everything about the particle set to initialize

Parameters

cur	the xmlnode to work on

Definition at line 90 of file XMLParticleIO.cpp.

References OhmmsAttributeSet::add(), app_debug, qmcplusplus::app_log(), ParticleSet::applyBC(), ParticleTags::attrib_tag, XMLParticleParser::checkGrouping(), ParticleSet::convert2Cart(), ParticleSet::create(), ParticleSet::createSK(), ParticleTags::datatype_tag, ParticleSet::getLattice(), XMLParticleParser::getPtclAttrib(), ParticleSet::getSpeciesSet(), ParticleSet::getTotalNum(), getXMLAttributeValue(), ParticleTags::ionid_tag, qmcplusplus::Lattice, qmcplusplus::makeUniformRandom(), processChildren(), OhmmsAttributeSet::put(), putContent(), ParticleSet::R, XMLParticleParser::ref_, ParticleSet::resetGroups(), ParticleSet::setMapStorageToInput(), ParticleSet::setName(), qmcplusplus::setSpeciesProperty(), ParticleAttrib< T, Alloc >::setUnit(), ParticleSet::spins, and ParticleTags::stringtype_tag.

Referenced by qmcplusplus::create_CN_particlesets(), qmcplusplus::parse_electron_ion_pbc_z(), ParticleSetPool::put(), qmcplusplus::test_C_diamond(), qmcplusplus::TEST_CASE(), qmcplusplus::test_EtOH_mw(), and qmcplusplus::test_HCN().

{
  ReportEngine PRE("XMLParticleParser", "readXML");

  if (ref_.getTotalNum())
    throw UniformCommunicateError("The ParticleSet object to load XML input was not empty. Report a bug!");

  SpeciesSet& tspecies(ref_.getSpeciesSet());
  if (tspecies.size() != 0)
    throw UniformCommunicateError("The SpeciesSet object to load XML input was not empty. Report a bug!");

  // the total number of particles, once it is set non-zero, always check against it.
  int nat = 0;
  // the number of particles by group, once it is constructed, always check against it.
  std::vector<int> nat_group;

  std::string pname("none");
  std::string randomizeR("no");
  OhmmsAttributeSet pAttrib;
  pAttrib.add(randomizeR, "random");
  pAttrib.add(nat, "size");
  pAttrib.add(pname, "name");
  pAttrib.put(cur);

  ref_.setName(pname.c_str());

  if (nat != 0)
  {
    app_debug() << "Set the total size " << nat
                << " by the 'size' attribute found in 'particleset' XML element node named '" << pname << "'."
                << std::endl;
  }

  bool ionid_found = false;
  { // parse all the 'group's to obtain or verify the total number of particles
    //total count of the particles to be created
    int ntot               = 0;
    int num_non_zero_group = 0;
    bool group_found       = false;

    processChildren(cur, [&](const std::string& cname, const xmlNodePtr element) {
      if (cname == "atom")
        throw UniformCommunicateError("XML element node atom is no more supported");
      else if (cname.find("ell") < cname.size()) //accept UnitCell, unitcell, supercell
        throw UniformCommunicateError("Constructing cell inside particleset is illegal!");
      else if (cname == "group")
      {
        group_found       = true;
        std::string sname = getXMLAttributeValue(element, "name");
        if (sname.empty())
          throw UniformCommunicateError("'group' element node must include a name attribute!");
        else
        {
          const int sid = tspecies.addSpecies(sname);
          setSpeciesProperty(tspecies, sid, element);
        }

        int nat_per_group = 0;
        OhmmsAttributeSet gAttrib;
        gAttrib.add(nat_per_group, "size");
        gAttrib.put(element);

        nat_group.push_back(nat_per_group);
        ntot += nat_per_group;
        if (nat_per_group > 0)
          num_non_zero_group++;
      }
      else if (cname == attrib_tag && getXMLAttributeValue(element, "name") == ionid_tag)
        ionid_found = true;
    });

    if (!group_found)
      throw UniformCommunicateError("No 'group' XML element node was found. Check XML input!");

    if (nat != 0 && ntot != 0 && nat != ntot)
    {
      std::ostringstream msg;
      msg << "The total number of particles deterimined previously was " << nat
          << "but the sum of the sizes from all the 'group' XML element nodes is " << ntot
          << ". Please check the 'particleset' XML element node!" << std::endl;
      throw UniformCommunicateError(msg.str());
    }

    if (nat == 0 && ntot != 0)
    {
      nat = ntot;
      app_debug() << "Set the total size " << nat << " by the sum of the 'size's on all the 'group' XML element nodes."
                  << std::endl;
    }

    if (ntot > 0 && num_non_zero_group != nat_group.size())
      throw UniformCommunicateError("Some 'group' XML element node doesn't contain a 'size' attribute! 'size = 0' is not allowed in the input. Make appropriate adjustments to the input or converter.");
  }

  { // parse all the 'attrib's to obtain or verify the total number of particles
    processChildren(cur, [&](const std::string& cname, const xmlNodePtr element) {
      if (cname == attrib_tag)
      {
        std::string sname = getXMLAttributeValue(element, "name");
        if (sname.empty())
          throw UniformCommunicateError("'" + ParticleTags::attrib_tag +
                                        "' XML element node must include a name attribute!");

        int size_att = 0;
        OhmmsAttributeSet aAttrib;
        aAttrib.add(size_att, "size");
        aAttrib.put(element);

        if (nat != 0 && size_att != 0 && nat != size_att)
        {
          std::ostringstream msg;
          msg << "The total number of particles deterimined previously was " << nat
              << " but the 'size' atttribute found on the '" << ParticleTags::attrib_tag
              << "' XML element nodes named '" << sname << "' is " << size_att
              << ". Please check the 'particleset' XML element node!" << std::endl;
          throw UniformCommunicateError(msg.str());
        }

        if (nat == 0 && size_att != 0)
        {
          nat = size_att;
          app_debug() << "Set the total size " << nat << " by the 'size' on the '" << ParticleTags::attrib_tag
                      << "' XML element node named '" << sname << "'." << std::endl;
        }
      }
    });
  }

  if (nat == 0)
    throw UniformCommunicateError("Failed in figuring out the total number of particles. Check XML input!");

  if (ionid_found)
  { // parse ionid and construct input order to stored order
    std::vector<int> map_storage_to_input(nat);
    processChildren(cur, [&](const std::string& cname, const xmlNodePtr element) {
      if (cname == attrib_tag && getXMLAttributeValue(element, "name") == ionid_tag)
      {
        std::string datatype = getXMLAttributeValue(element, datatype_tag);
        if (datatype != stringtype_tag)
          throw UniformCommunicateError("'ionid' only supports datatype=\"" + stringtype_tag + "\"");
        std::vector<std::string> d_in(nat);
        putContent(d_in, element);
        bool input_ungrouped = false;
        int storage_index    = 0;
        for (int ig = 0; ig < nat_group.size(); ig++)
        {
          const auto& group_species_name = tspecies.getSpeciesName(ig);
          int count_group_size           = 0;
          for (int iat = 0; iat < nat; iat++)
          {
            const int element_index = tspecies.findSpecies(d_in[iat]);
            if (element_index == tspecies.size())
              throw UniformCommunicateError("Element " + d_in[iat] +
                                            " doesn't match any species from 'group' XML element nodes.");
            if (element_index == ig)
            {
              if (iat != storage_index)
                input_ungrouped = true;
              count_group_size++;
              map_storage_to_input[storage_index++] = iat;
            }
          }

          if (count_group_size == 0)
            throw UniformCommunicateError("Element '" + group_species_name + "' not found in 'ionid'.");

          if (nat_group[ig] == 0)
            nat_group[ig] = count_group_size;
          else if (nat_group[ig] != count_group_size)
          {
            std::ostringstream msg;
            msg << "The number of particles of element '" << group_species_name << "' from 'group' XML elment node was "
                << nat_group[ig] << " but 'ionid' contains " << count_group_size << " entries." << std::endl;
            throw UniformCommunicateError(msg.str());
          }
        }

        if (input_ungrouped)
        {
          app_log() << "  Input particle set is not grouped by species.  Remapping particle position indices "
                       "internally."
                    << std::endl;
          app_debug() << "    Species : input particle index -> internal particle index" << std::endl;
          for (int new_idx = 0; new_idx < map_storage_to_input.size(); new_idx++)
          {
            int old_idx = map_storage_to_input[new_idx];
            if (new_idx != old_idx)
            {
              app_debug() << "    " << d_in[old_idx] << " : " << old_idx << " -> " << new_idx << std::endl;
            }
          }
        }
      }
    });

    checkGrouping(nat, nat_group);
    ref_.create(nat_group);
    // save map_storage_to_input
    ref_.setMapStorageToInput(map_storage_to_input);

    for (int iat = 0; iat < nat; iat++)
    {
      processChildren(cur, [&](const std::string& cname, const xmlNodePtr element) {
        if (cname == attrib_tag && getXMLAttributeValue(element, "name") != ionid_tag)
          getPtclAttrib(element, map_storage_to_input[iat], 1, iat);
      });
    }
  }
  else
  {
    // fix old input with positions outside 'group'
    if (nat_group.size() == 1 && nat_group[0] == 0)
      nat_group[0] = nat;

    checkGrouping(nat, nat_group);
    ref_.create(nat_group);

    // obtain 'attrib' inside 'group'
    size_t start = 0;
    size_t ig    = 0;
    processChildren(cur, [&](const std::string& cname, const xmlNodePtr child) {
      if (cname == "group")
      {
        processChildren(child, [&](const std::string& cname, const xmlNodePtr element) {
          if (cname == attrib_tag)
            getPtclAttrib(element, 0, nat_group[ig], start);
        });
        start += nat_group[ig];
        ig++;
      }
      else if (cname == attrib_tag)
      {
        if (nat_group.size() > 1)
          throw UniformCommunicateError("An 'attrib' XML element node was found outside 'group'"
                                        " without XML element node named 'ionid'."
                                        " Cannot map particles to more than one species. Check XML input!");
        getPtclAttrib(child, 0, nat, 0);
      }
    });
  }

  if (ref_.getLattice().SuperCellEnum)
  {
    if (randomizeR == "yes")
    {
      makeUniformRandom(ref_.R);
      ref_.R.setUnit(PosUnit::Lattice);
      ref_.convert2Cart(ref_.R);
      makeUniformRandom(ref_.spins);
      ref_.spins *= 2 * M_PI;
    }
    else // put them [0,1) in the cell
      ref_.applyBC(ref_.R);
  }

  //this sets Mass, Z
  ref_.resetGroups();
  ref_.createSK();

  return true;
}

reset()

bool reset

(

xmlNodePtr

cur

)

reset the properties of a particle set

process xmlnode to reset the properties of a particle set

Parameters

cur	current node

Returns

true, if successful

This resets or adds new attributes to a particle set. It cannot modify the size of the particle set.

Definition at line 375 of file XMLParticleIO.cpp.

References OhmmsAttributeSet::add(), ParticleSet::getSpeciesSet(), OhmmsAttributeSet::put(), XMLParticleParser::ref_, and qmcplusplus::setSpeciesProperty().

{
  ReportEngine PRE("XMLParticleParser", "reset");
  SpeciesSet& tspecies(ref_.getSpeciesSet());
  cur = cur->xmlChildrenNode;
  while (cur != NULL)
  {
    std::string cname((const char*)cur->name);
    if (cname == "group")
    {
      std::string sname;
      OhmmsAttributeSet gAttrib;
      gAttrib.add(sname, "name");
      gAttrib.put(cur);
      if (sname.size())
      {
        int sid = tspecies.addSpecies(sname);
        setSpeciesProperty(tspecies, sid, cur);
      }
    }
    cur = cur->next;
  }
  //  //@todo Will add a member function to ParticleSet to handle these
  //  int massind=tspecies.addAttribute("mass");
  //  for(int iat=0; iat<ref_.getTotalNum(); iat++)
  //    ref_.Mass[iat]=tspecies(massind,ref_.GroupID[iat]);
  //
  //  int qind=tspecies.addAttribute("charge");
  //  for(int iat=0; iat<ref_.getTotalNum(); iat++)
  //    ref_.Z[iat]=tspecies(qind,ref_.GroupID[iat]);
  //
  return true;
}

Member Data Documentation

ref_

Particle_t& ref_

private

Definition at line 102 of file XMLParticleIO.h.

Referenced by XMLParticleParser::checkGrouping(), XMLParticleParser::readXML(), XMLParticleParser::reset(), and XMLParticleParser::XMLParticleParser().

ref_AttribList

AttribListType ref_AttribList

private

Definition at line 103 of file XMLParticleIO.h.

Referenced by XMLParticleParser::getPtclAttrib(), and XMLParticleParser::XMLParticleParser().

---

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

• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/Particle/ParticleIO/XMLParticleIO.h
• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/Particle/ParticleIO/XMLParticleIO.cpp