DecayParser Class Reference

#include <DecayParser.h>

Collaboration diagram for DecayParser:

Public Member Functions
	DecayParser (const std::string &cmd)
	Constructor with parameters:
virtual	~DecayParser ()
	Destructor:
const std::vector< McUtils::Strings > &	getParents () const
	I/O operators.
const std::vector< McUtils::Strings > &	getChildren () const
void	dump () const
	Const methods:
int	pdgId (const std::string &pdgIdString) const
void	parse (const std::string &cmd)
	Non-const methods:

Protected Member Functions
	DecayParser ()
	Default constructor:
	DecayParser (const DecayParser &rhs)
	Copy constructor:
DecayParser &	operator= (const DecayParser &obj)
	Assignment operator:
void	printMcUtilsStrings (const std::vector< McUtils::Strings > &list) const
	Print the content of a vector of McUtils::Strings to std::cout.

Protected Attributes
std::vector< McUtils::Strings >	m_parents
	List of parents : each slot of the vector is a list of candidates So one could have something like : [ ["22","23"] ] to model a decay of a gamma or a Z0.
std::vector< McUtils::Strings >	m_children
	List of children : each slot of the vector is a list of candidates So one could have something like : [ ["11","13"], ["-11","-13" ] ] to model a decay into a pair of electrons or muons.

Detailed Description

Definition at line 29 of file DecayParser.h.

Constructor & Destructor Documentation

DecayParser() [1/3]

DecayParser::DecayParser

(

const std::string &

cmd

)

Constructor with parameters:

Public methods:

Constructors

Definition at line 61 of file DecayParser.cxx.

                                               :
  m_parents  ( ),
  m_children ( )
{
  parse(cmd);
}

~DecayParser()

DecayParser::~DecayParser ( )

virtual

Destructor:

Destructor.

Definition at line 71 of file DecayParser.cxx.

{
}

DecayParser() [2/3]

DecayParser::DecayParser ( )

protected

Default constructor:

DecayParser() [3/3]

DecayParser::DecayParser ( const DecayParser & rhs )

protected

Copy constructor:

Member Function Documentation

dump()

void DecayParser::dump

(

)

const

Const methods:

Definition at line 78 of file DecayParser.cxx.

{
  std::cout << "--- Parents ---" << std::endl;
  printMcUtilsStrings( m_parents );
 
  std::cout << "--- Children ---" << std::endl;
  printMcUtilsStrings( m_children );
}

getChildren()

const std::vector< McUtils::Strings > & DecayParser::getChildren ( ) const

inline

Definition at line 117 of file DecayParser.h.

{ 
  return m_children;
}

getParents()

const std::vector< McUtils::Strings > & DecayParser::getParents ( ) const

inline

I/O operators.

Inline methods:

Definition at line 110 of file DecayParser.h.

{ 
  return m_parents;
}

operator=()

DecayParser & DecayParser::operator= ( const DecayParser & obj )

protected

Assignment operator:

Definition at line 172 of file DecayParser.cxx.

{
  if ( this != &rhs ) {
    m_parents      = rhs.m_parents;
    m_children     = rhs.m_children;
  }
  return *this;
}

parse()

void DecayParser::parse

(

const std::string &

cmd

)

Non-const methods:

Definition at line 99 of file DecayParser.cxx.

{
  if ( inputCmd.empty() ) {
    return;
  }
 
  std::string cmd;
  cmd.reserve(inputCmd.size());
  for (unsigned char c : inputCmd) {
    if (!std::isspace(c)) {
      cmd.push_back(c);
    }
  }
  if (cmd.empty()) {
    return;
  }
 
  // Reset the parents and children lists
  m_parents.clear();
  m_children.clear();
 
  if (cmd == "->") {
    return;
  }
 
  const std::size_t arrowPos = cmd.find("->");
  if (arrowPos == std::string::npos) {
    std::string error = "missing '->' in command [" + inputCmd + "]";
    throw std::runtime_error(error);
  }
 
  if (cmd.find("->", arrowPos + 2) != std::string::npos) {
    std::string error = "multiple '->' separators in command [" + inputCmd + "]";
    throw std::runtime_error(error);
  }
 
  const std::string_view cmdView{cmd};
  const auto parentsBlock  = cmdView.substr(0, arrowPos);
  const auto childrenBlock = cmdView.substr(arrowPos + 2);
 
  m_parents  = process_block(parentsBlock);
  m_children = process_block(childrenBlock);
}

pdgId()

int DecayParser::pdgId

(

const std::string &

pdgIdString

)

const

Definition at line 87 of file DecayParser.cxx.

{
  int pdgID = 0;
  int iPDG = 0;
  std::stringstream( pdgIdString ) >> iPDG;
  pdgID = iPDG;
 
  return pdgID;
}

printMcUtilsStrings()

void DecayParser::printMcUtilsStrings ( const std::vector< McUtils::Strings > & list ) const

protected

Print the content of a vector of McUtils::Strings to std::cout.

Definition at line 145 of file DecayParser.cxx.

{
  unsigned int iSlot = 0;
  for( std::vector<McUtils::Strings>::const_iterator itr = list.begin();
       itr != list.end();
       ++itr,++iSlot ) {
    std::stringstream iSlotStr;
    iSlotStr << iSlot;
    const McUtils::Strings::const_iterator candEnd = itr->end();
    std::cout << "slot #" << iSlotStr.str() << ": candidates= [ ";
    for( McUtils::Strings::const_iterator candidate = itr->begin();
     candidate != candEnd;
     ++candidate ) {
      std::cout << *candidate;
      if ( candidate+1 != candEnd ) {
    std::cout << " | ";
      }
    }
    std::cout << " ]" << std::endl;
  }
  return;
}

Member Data Documentation

m_children

std::vector<McUtils::Strings> DecayParser::m_children

protected

List of children : each slot of the vector is a list of candidates So one could have something like : [ ["11","13"], ["-11","-13" ] ] to model a decay into a pair of electrons or muons.

Definition at line 96 of file DecayParser.h.

m_parents

std::vector<McUtils::Strings> DecayParser::m_parents

protected

List of parents : each slot of the vector is a list of candidates So one could have something like : [ ["22","23"] ] to model a decay of a gamma or a Z0.

Definition at line 90 of file DecayParser.h.

---

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

• DecayParser.h
• DecayParser.cxx