DecayParser Class Reference

#include <DecayParser.h>

Collaboration diagram for DecayParser:

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

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

Protected Attributes
PyObject *	m_parseFct
	python function to parse the input string modeling the decay pattern to look for. More...
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. More...
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. More...

Detailed Description

Definition at line 33 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 39 of file DecayParser.cxx.

                                               :
  m_parseFct (0),
  m_parents  ( ),
  m_children ( )
{
  m_parseFct = ::fetch_py_parse_fct();
  parse(cmd);
}

~DecayParser()

DecayParser::~DecayParser ( )

virtual

Destructor:

Destructor.

Definition at line 51 of file DecayParser.cxx.

{
  Py_XDECREF (m_parseFct);
}

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 59 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 126 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 119 of file DecayParser.h.

{ 
  return m_parents;
}

operator=()

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

protected

Assignment operator:

Definition at line 210 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 80 of file DecayParser.cxx.

{
  if ( inputCmd.empty() ) {
    return;
  }
 
  // Reset the parents and children lists
  m_parents.clear();
  m_children.clear();
 
 
 
  // real parsing takes place now.
  PyObject *res = PyObject_CallFunction (m_parseFct,
                     (char*)"s",
                     inputCmd.c_str());
  if (!res) {
    Py_XDECREF (res);
    std::string error = "problem while parsing command [" + inputCmd +"]";
    throw std::runtime_error (error);
  }
  
  if (!PyTuple_Check (res)) {
    Py_DECREF (res);
    std::string error = "expected a python tuple";
    throw std::runtime_error (error);
  }
 
  if (PyTuple_GET_SIZE (res) != 3) {
    Py_DECREF (res);
    std::string error = "expected a python tuple of size 3";
    throw std::runtime_error (error);
  }
 
  PyObject *sc = PyTuple_GET_ITEM (res, 0);
  Py_XINCREF (sc);
  if (!sc || !PyLong_Check (sc)) {
    Py_XDECREF (sc);
    Py_DECREF  (res);
    std::string error = "corrupted return code";
    throw std::runtime_error (error);
  }
 
  Py_ssize_t status = PyLong_AsSsize_t (sc);
  if (status != 0) {
    Py_DECREF (sc);
    Py_DECREF (res);
    std::string error = "failed to parse command ["+inputCmd+"]";
    throw std::runtime_error (error);
  }
  Py_DECREF (sc);
 
  PyObject *parents = PyTuple_GET_ITEM (res, 1);
  Py_XINCREF (parents);
  if (!parents) {
    Py_DECREF (res);
    std::string error = "corrupted parents' list";
    throw std::runtime_error (error);
  }
 
  PyObject *children= PyTuple_GET_ITEM (res, 2);
  Py_XINCREF (children);
  if (!children) {
    Py_DECREF (parents);
    Py_DECREF (res);
    std::string error = "corrupted children' list";
    throw std::runtime_error (error);
  }
  Py_DECREF (res);
 
  if (parents==Py_None && children==Py_None) {
    // special case of a single arrow without any parent nor child :
    // this decay pattern will select every single vertex
    Py_DECREF (parents);
    Py_DECREF (children);
    return;
  }
  
  if (!py_to_cpp (parents, m_parents)) {
    Py_DECREF (parents);
    Py_DECREF (children);
    std::string error = "could not translate parents' list";
    throw std::runtime_error (error);
  }
 
  if (!py_to_cpp (children, m_children)) {
    Py_DECREF (parents);
    Py_DECREF (children);
    std::string error = "could not translate children' list";
    throw std::runtime_error (error);
  }
 
  return;
}

pdgId()

int DecayParser::pdgId

(

const std::string &

pdgIdString

)

const

Definition at line 68 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.

Protected methods:

Definition at line 182 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 105 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 99 of file DecayParser.h.

m_parseFct

PyObject* DecayParser::m_parseFct

protected

python function to parse the input string modeling the decay pattern to look for.

Definition at line 93 of file DecayParser.h.

---

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

• DecayParser.h
• DecayParser.cxx