DecayDescriptor Class Reference

The DecayDescriptor stores information about a decay tree or parts of a decay tree. More...

#include <DecayDescriptor.h>

Collaboration diagram for DecayDescriptor:

Public Member Functions
	operator DecayDescriptor * ()
	Dereference operator.
	DecayDescriptor ()
	Default ctor.
	DecayDescriptor (const DecayDescriptor &)=default
	Want the default copy ctor.
DecayDescriptor &	operator= (const DecayDescriptor &)=default
	Want the default assignment operator.
std::vector< std::vector< std::pair< int, std::string > > >	getHierarchyOfSelected ()
	Function to get hierarchy of selected particles and their names (for python use)
std::vector< std::vector< std::pair< int, std::string > > >	getHierarchyOfSelected (const std::vector< std::pair< int, std::string > > &currentPath)
	Helper function to get hierarchy of selected particles and their names.
bool	init (const std::string &str)
	Initialise the DecayDescriptor from given string.
bool	init (const DecayString &s)
	Initialise the DecayDescriptor from a given DecayString.
int	match (const Particle *p)
	Check if the DecayDescriptor matches with the given Particle.
int	match (const MCParticle *p)
	See match(const Particle* p).
int	getMatchedDaughter ()
	Particle daughter ID set by previous call of match(const Particle*) function.
void	resetMatch ()
	Reset results from previous call of the match() function.
std::vector< const Particle * >	getSelectionParticles (const Particle *particle)
	Get a vector of pointers with selected daughters in the decay tree.
std::vector< std::string >	getSelectionNames ()
	Return list of human readable names of selected particles.
std::vector< int >	getSelectionPDGCodes ()
	Return list of PDG codes of selected particles.
const DecayDescriptorParticle *	getMother () const
	return mother.
int	getNDaughters () const
	return number of direct daughters.
const DecayDescriptor *	getDaughter (int i) const
	return i-th daughter (0 based index).
int	getProperty () const
	return property of the particle.
bool	isIgnoreRadiatedPhotons () const
	Check if additional radiated photons shall be ignored.
bool	isIgnoreIntermediate () const
	Check if intermediate resonances/particles shall be ignored.
bool	isIgnoreMassive () const
	Check if missing massive final state particles shall be ignored.
bool	isIgnoreNeutrino () const
	Check if missing neutrinos shall be ignored.
bool	isIgnoreGamma () const
	Check if missing gammas shall be ignored.
bool	isIgnoreBrems () const
	Check if added Brems gammas shall be ignored.
bool	isSelfConjugated () const
	Is the decay or the particle self conjugated.
bool	isInitOK () const
	Check if the object initialized correctly.
bool	getSelectionParticlesAndNames (const Particle *particle, std::vector< const Particle * > &selparticles, std::vector< std::string > &selnames)
	Takes as input argument a (reconstructed) Particle, tries to match with this DecayDescriptorElement and returns true when matched.

Static Public Attributes
static const DecayDescriptor &	s_NULL = DecayDescriptor()
	Singleton object representing NULL.

Private Member Functions
template<class T >
int	match (const T *p, int iDaughter_p)
	Internally called by match(Particle*) and match(MCParticle*) function.

Private Attributes
DecayDescriptorParticle	m_mother
	Mother of the decay ('left side').
int	m_iDaughter_p
	ID of the Daughter Particle* matched to this DecayDescriptor.
std::vector< DecayDescriptor >	m_daughters
	Direct daughters of the decaying particle.
int	m_properties
	Particle property.
bool	m_isNULL
	Is this the NULL object?
std::vector< std::vector< std::pair< int, std::string > > >	m_hierarchy
	Collection of hierarchy paths of selected particles.
bool	m_isInitOK
	Is this object initialized correctly?

Detailed Description

The DecayDescriptor stores information about a decay tree or parts of a decay tree.

It contains the mother <-> daughter relations.

User documentation is located at analysis/doc/DecayDescriptor.rst Please modify in accordingly to introduced changes.

Definition at line 33 of file DecayDescriptor.h.

Constructor & Destructor Documentation

DecayDescriptor()

DecayDescriptor

(

)

Default ctor.

Definition at line 36 of file DecayDescriptor.cc.

                                 :
  m_mother(),
  m_iDaughter_p(-1),
  m_daughters(),
  m_properties(0),
  m_isNULL(false),
  m_isInitOK(false)
{
}

Member Function Documentation

getDaughter()

const DecayDescriptor * getDaughter ( int  i ) const

inline

return i-th daughter (0 based index).

Definition at line 139 of file DecayDescriptor.h.

    {
      return (i < getNDaughters()) ? &(m_daughters[i]) : nullptr;
    }

getHierarchyOfSelected() [1/2]

std::vector< std::vector< std::pair< int, std::string > > > getHierarchyOfSelected

(

)

Function to get hierarchy of selected particles and their names (for python use)

Definition at line 405 of file DecayDescriptor.cc.

{
  if (not m_hierarchy.empty()) {
    std::vector<std::vector<std::pair<int, std::string>>> hierarchy = m_hierarchy;
    return hierarchy;
  }
  std::vector<std::pair<int, std::string>> currentPath;
  currentPath.emplace_back(0, m_mother.getNameSimple());
  return getHierarchyOfSelected(currentPath);
}

getHierarchyOfSelected() [2/2]

std::vector< std::vector< std::pair< int, std::string > > > getHierarchyOfSelected

(

const std::vector< std::pair< int, std::string > > &

currentPath

)

Helper function to get hierarchy of selected particles and their names.

Called iteratively and get hierarchy path of a particle as an argument

Definition at line 416 of file DecayDescriptor.cc.

{
  if (m_mother.isSelected()) m_hierarchy.push_back(currentPath);
  for (std::size_t i = 0; i < m_daughters.size(); i++) {
    std::vector<std::pair<int, std::string>> newPath = currentPath;
    newPath.emplace_back(i, m_daughters[i].getMother()->getNameSimple());
    std::vector<std::vector<std::pair<int, std::string>>> foundPathes = m_daughters[i].getHierarchyOfSelected(newPath);
    for (auto& path : foundPathes) m_hierarchy.push_back(path);
  }
  std::vector<std::vector<std::pair<int, std::string>>> hierarchy = m_hierarchy;
  return hierarchy;
}

getMatchedDaughter()

int getMatchedDaughter ( )

inline

Particle daughter ID set by previous call of match(const Particle*) function.

Definition at line 114 of file DecayDescriptor.h.

{return m_iDaughter_p;}

getMother()

const DecayDescriptorParticle * getMother ( ) const

inline

return mother.

Definition at line 129 of file DecayDescriptor.h.

    {
      return &m_mother;
    }

getNDaughters()

int getNDaughters ( ) const

inline

return number of direct daughters.

Definition at line 134 of file DecayDescriptor.h.

    {
      return m_daughters.size();
    }

getProperty()

int getProperty ( ) const

inline

return property of the particle.

Definition at line 144 of file DecayDescriptor.h.

    {
      return m_properties;
    }

getSelectionNames()

vector< string > getSelectionNames

(

)

Return list of human readable names of selected particles.

Example for the case that all particles are selected in B+ -> (anti-D0 -> K^- pi^+) pi^+: ["B", "D0", "D0_K", "D_pi", "pi"]

Definition at line 342 of file DecayDescriptor.cc.

{
  vector<string> strNames;
  if (m_mother.isSelected()) strNames.push_back(m_mother.getNameSimple());
  for (auto& daughter : m_daughters) {
    vector<string> strDaughterNames = daughter.getSelectionNames();
    int nDaughters = strDaughterNames.size();
    for (int iDaughter = 0; iDaughter < nDaughters; iDaughter++) {
      // Checking variable naming scheme from AnalysisConfiguratin
      // For example, effect of possible schemes for PX variable
      // of pi0 from D in decay B->(D->pi0 pi) pi0:
      // default: B_D_pi0_PX
      // semidefault: D_pi0_PX
      // laconic: pi01_PX
      if (AnalysisConfiguration::instance()->getTupleStyle() == "laconic") continue;
      if ((AnalysisConfiguration::instance()->getTupleStyle() == "semilaconic") && (iDaughter == nDaughters)) continue;
      strDaughterNames[iDaughter] = m_mother.getNameSimple() + "_" + strDaughterNames[iDaughter];
    }
    strNames.insert(strNames.end(), strDaughterNames.begin(), strDaughterNames.end());
  }
 
  // search for multiple occurrence of the same name and then distinguish by attaching a number
 
  for (auto itName = strNames.begin(); itName != strNames.end(); ++itName) {
    if (count(itName, strNames.end(), *itName) == 1) continue;
    // multiple occurrence found!
    string strNameOld = *itName;
    auto itOccurrence = strNames.begin();
    int iOccurrence = 0;
    while (iOccurrence <= 10) {
      // find next occurrence of the identical particle name defined in DecayDescriptor
      itOccurrence = find(itOccurrence, strNames.end(), strNameOld);
      // stop, if nothing found
      if (itOccurrence == strNames.end()) break;
      // create new particle name by attaching a number
      string strNameNew = strNameOld + std::to_string(iOccurrence);
      // check if the new particle name exists already, if not, then it is OK to use it
      if (count(strNames.begin(), strNames.end(), strNameNew) == 0) {
        *itOccurrence = strNameNew;
        ++itOccurrence;
      }
      iOccurrence++;
    }
    if (iOccurrence == 10) {
      B2ERROR("DecayDescriptor::getSelectionNames - Something is wrong! More than 10x the same name!");
      break;
    }
  }
  return strNames;
}

getSelectionParticles()

vector< const Particle * > getSelectionParticles

(

const Particle *

particle

)

Get a vector of pointers with selected daughters in the decay tree.

Definition at line 283 of file DecayDescriptor.cc.

{
  // Create vector for output
  vector<const Particle*> selparticles;
  if (m_mother.isSelected()) {
    int motherPDG = abs(particle->getPDGCode());
    int decayDescriptorMotherPDG = abs(m_mother.getPDGCode());
    if (motherPDG != decayDescriptorMotherPDG)
      B2ERROR("The PDG code of the mother particle (" << motherPDG <<
              ") does not match the PDG code of the DecayDescriptor mother (" << decayDescriptorMotherPDG <<
              ")! Check the order of the decay string is the same you expect in the reconstructed Particles.");
    selparticles.push_back(particle);
  }
  int nDaughters_d = getNDaughters();
  for (int iDaughter_d = 0; iDaughter_d < nDaughters_d; ++iDaughter_d) {
    // retrieve the particle daughter ID from this DecayDescriptor daughter
    int iDaughter_p = m_daughters[iDaughter_d].getMatchedDaughter();
    // If the particle daughter ID is below one, the match function was not called before
    // or the match was ambiguous. In this case try to use the daughter ID of the DecayDescriptor.
    // This corresponds to using the particle order in the decay string.
    if (iDaughter_p < 0) iDaughter_p = iDaughter_d;
    const Particle* daughter = particle->getDaughter(iDaughter_p);
    if (!daughter) {
      B2WARNING("Could not find daughter!");
      continue;
    }
    // check if the daughter has the correct PDG code
    int daughterPDG = abs(daughter->getPDGCode());
    int decayDescriptorDaughterPDG = abs(m_daughters[iDaughter_d].getMother()->getPDGCode());
    if (daughterPDG != decayDescriptorDaughterPDG) {
      B2ERROR("The PDG code of the particle daughter (" << daughterPDG <<
              ") does not match the PDG code of the DecayDescriptor daughter (" << decayDescriptorDaughterPDG <<
              ")! Check the order of the decay string is the same you expect in the reconstructed Particles.");
      break;
    }
    vector<const Particle*> seldaughters = m_daughters[iDaughter_d].getSelectionParticles(daughter);
    selparticles.insert(selparticles.end(), seldaughters.begin(), seldaughters.end());
  }
  return selparticles;
}

getSelectionPDGCodes()

vector< int > getSelectionPDGCodes

(

)

Return list of PDG codes of selected particles.

Definition at line 393 of file DecayDescriptor.cc.

{
  vector<int> listPDG;
  if (m_mother.isSelected()) listPDG.push_back(m_mother.getPDGCode());
  for (auto& daughter : m_daughters) {
    vector<int> listPDGDaughters = daughter.getSelectionPDGCodes();
    listPDG.insert(listPDG.end(), listPDGDaughters.begin(), listPDGDaughters.end());
  }
  return listPDG;
}

init() [1/2]

bool init

(

const DecayString &

s

)

Initialise the DecayDescriptor from a given DecayString.

The DecayString struct is obtained from the parser called in the init(const std::string) function.

Definition at line 58 of file DecayDescriptor.cc.

{
  // The DecayString is a hybrid, it can be
  // a) DecayStringParticleList
  // b) DecayStringDecay
 
  if (const DecayStringParticle* p = boost::get< DecayStringParticle >(&s)) {
    m_isInitOK = m_mother.init(*p);
    if (!m_isInitOK) {
      B2WARNING("Could not initialise mother particle " << p->m_strName);
      return false;
    }
    return true;
  } else if (const DecayStringDecay* d = boost::get< DecayStringDecay > (&s)) {
    // Initialise list of mother particles
    m_isInitOK = m_mother.init(d->m_mother);
    if (!m_isInitOK) {
      B2WARNING("Could not initialise mother particle " << d->m_mother.m_strName);
      return false;
    }
 
    // Identify arrow type
    if (d->m_strArrow == "->") {
      m_properties |= Particle::PropertyFlags::c_IsIgnoreRadiatedPhotons ;
      m_properties |= Particle::PropertyFlags::c_IsIgnoreIntermediate;
    } else if (d->m_strArrow == "=norad=>") {
      m_properties |= Particle::PropertyFlags::c_IsIgnoreIntermediate;
    } else if (d->m_strArrow == "=direct=>") {
      m_properties |= Particle::PropertyFlags::c_IsIgnoreRadiatedPhotons;
    } else if (d->m_strArrow == "=exact=>") {
      // do nothing
    } else {
      B2WARNING("Unknown arrow: " << d->m_strArrow);
      m_isInitOK = false;
      return false;
    }
 
    // Initialise list of daughters
    if (d->m_daughters.empty()) {
      m_isInitOK = false;
      return false;
    }
    int nDaughters = d->m_daughters.size();
    for (int iDaughter = 0; iDaughter < nDaughters; iDaughter++) {
      DecayDescriptor daughter;
      m_isInitOK = daughter.init(d->m_daughters[iDaughter]);
      if (!m_isInitOK) {
        B2WARNING("Could not initialise daughter!");
        return false;
      }
      m_daughters.push_back(daughter);
    }
 
    // Initialise list of keywords
    // For neutrino
    if ((std::find(d->m_keywords.begin(), d->m_keywords.end(), "?nu")) !=  d->m_keywords.end()) {
      m_properties |= Particle::PropertyFlags::c_IsIgnoreNeutrino;
    }
    // For gamma
    if ((std::find(d->m_keywords.begin(), d->m_keywords.end(), "?gamma")) != d->m_keywords.end()) {
      m_properties |= Particle::PropertyFlags::c_IsIgnoreGamma;
    }
    // For massive FSP
    if ((std::find(d->m_keywords.begin(), d->m_keywords.end(), "...")) != d->m_keywords.end()) {
      m_properties |= Particle::PropertyFlags::c_IsIgnoreMassive;
    }
    // For brems photons
    if ((std::find(d->m_keywords.begin(), d->m_keywords.end(), "?addbrems")) != d->m_keywords.end()) {
      m_properties |= Particle::PropertyFlags::c_IsIgnoreBrems;
    }
 
    return true;
  }
  m_isInitOK = false;
  return false;
}

init() [2/2]

bool init

(

const std::string &

str

)

Initialise the DecayDescriptor from given string.

Typically, the string is a parameter of an analysis module.

Definition at line 46 of file DecayDescriptor.cc.

{
  // The decay string grammar
  DecayStringGrammar<std::string::const_iterator> g;
  DecayString s;
  std::string::const_iterator iter = str.begin();
  std::string::const_iterator end = str.end();
  bool r = phrase_parse(iter, end, g, boost::spirit::unicode::space, s);
  if (!r || iter != end) return false;
  return init(s);
}

isIgnoreBrems()

bool isIgnoreBrems ( ) const

inline

Check if added Brems gammas shall be ignored.

Definition at line 174 of file DecayDescriptor.h.

    {
      return (m_properties & Particle::PropertyFlags::c_IsIgnoreBrems) > 0;
    }

isIgnoreGamma()

bool isIgnoreGamma ( ) const

inline

Check if missing gammas shall be ignored.

Definition at line 169 of file DecayDescriptor.h.

    {
      return (m_properties & Particle::PropertyFlags::c_IsIgnoreGamma) > 0;
    }

isIgnoreIntermediate()

bool isIgnoreIntermediate ( ) const

inline

Check if intermediate resonances/particles shall be ignored.

Definition at line 154 of file DecayDescriptor.h.

    {
      return (m_properties & Particle::PropertyFlags::c_IsIgnoreIntermediate) > 0;
    }

isIgnoreMassive()

bool isIgnoreMassive ( ) const

inline

Check if missing massive final state particles shall be ignored.

Definition at line 159 of file DecayDescriptor.h.

    {
      return (m_properties & Particle::PropertyFlags::c_IsIgnoreMassive) > 0;
    }

isIgnoreNeutrino()

bool isIgnoreNeutrino ( ) const

inline

Check if missing neutrinos shall be ignored.

Definition at line 164 of file DecayDescriptor.h.

    {
      return (m_properties & Particle::PropertyFlags::c_IsIgnoreNeutrino) > 0;
    }

isIgnoreRadiatedPhotons()

bool isIgnoreRadiatedPhotons ( ) const

inline

Check if additional radiated photons shall be ignored.

Definition at line 149 of file DecayDescriptor.h.

    {
      return (m_properties & Particle::PropertyFlags::c_IsIgnoreRadiatedPhotons) > 0;
    }

isInitOK()

bool isInitOK ( ) const

inline

Check if the object initialized correctly.

Definition at line 183 of file DecayDescriptor.h.

    {
      return m_isInitOK;
    }

isSelfConjugated()

bool isSelfConjugated

(

)

const

Is the decay or the particle self conjugated.

Definition at line 324 of file DecayDescriptor.cc.

{
 
  std::vector<int> decay, decaybar;
  for (int i = 0; i < getNDaughters(); ++i) {
    const DecayDescriptorParticle* daughter = getDaughter(i)->getMother();
    int pdg = daughter->getPDGCode();
    decay.push_back(pdg);
    decaybar.push_back(Belle2::EvtPDLUtil::hasAntiParticle(pdg) ? -pdg : pdg);
  }
 
  std::sort(decay.begin(), decay.end());
  std::sort(decaybar.begin(), decaybar.end());
 
  return (not Belle2::EvtPDLUtil::hasAntiParticle(getMother()->getPDGCode())) || (decay == decaybar);
 
}

match() [1/3]

int match ( const MCParticle *  p )

inline

See match(const Particle* p).

Definition at line 111 of file DecayDescriptor.h.

{return match<MCParticle>(p, -1);}

match() [2/3]

int match ( const Particle *  p )

inline

Check if the DecayDescriptor matches with the given Particle.

0 = no match 1 = matches DecayDescriptor 2 = matches charge conjugated DecayDescriptor 3 = matches DeacyDescriptor AND charge conjugated DecayDescriptor -1, -2, -3 : same, but match is not unambiguous.

Definition at line 108 of file DecayDescriptor.h.

{return match<Particle>(p, -1);}

match() [3/3]

int match ( const T *  p, int  iDaughter_p  )

private

Internally called by match(Particle*) and match(MCParticle*) function.

Definition at line 136 of file DecayDescriptor.cc.

{
  // this DecayDescriptor was not matched or
  // it is not the daughter of another DecayDescriptor
  m_iDaughter_p = -1;
 
  if (!p) {
    B2WARNING("NULL pointer provided instead of particle.");
    return 0;
  }
 
  int iPDGCode_p = 0;
  if (const auto* part_test = dynamic_cast<const Particle*>(p))
    iPDGCode_p = part_test->getPDGCode();
  else if (const auto* mc_test = dynamic_cast<const MCParticle*>(p))
    iPDGCode_p = mc_test->getPDG();
  else {
    B2WARNING("Template type not supported!");
    return 0;
  }
 
  int iPDGCodeCC_p = TDatabasePDG::Instance()->GetParticle(iPDGCode_p)->AntiParticle()->PdgCode();
  int iPDGCode_d = m_mother.getPDGCode();
  if (abs(iPDGCode_d) != abs(iPDGCode_p)) return 0;
  int iCC = 0;
  if (iPDGCode_p == iPDGCodeCC_p) iCC = 3;
  else if (iPDGCode_d == iPDGCode_p) iCC = 1;
  else if (iPDGCode_d == iPDGCodeCC_p) iCC = 2;
 
  const std::vector<T*> daughterList = p->getDaughters();
  int nDaughters_p = daughterList.size();
 
  // 1st case: the descriptor has no daughters => nothing to check
  if (getNDaughters() == 0) {
    m_iDaughter_p = iDaughter_p;
    return iCC;
  }
 
  // 2nd case: the descriptor has daughters, but not the particle
  // => that is not allowed!
  if (nDaughters_p == 0) return 0;
 
  // 3rd case: the descriptor and the particle have daughters
  // There are two cases that can happen when matching the
  // DecayDescriptor daughters to the particle daughters:
  // 1. The match is unambiguous -> no problem
  // 2. Multiple particle daughters match the same DecayDescriptor daughter
  // -> in the latter case the ambiguity is resolved later
 
  // 1. DecayDescriptor -> Particle relation for the cases where only one particle matches
  vector< pair< int, int > > singlematch;
  // 2. DecayDescriptor -> Particle relation for the cases where multiple particles match
  vector< pair< int, set<int> > > multimatch;
  // Are there ambiguities in the match?
  bool isAmbiguities = false;
  // The particle daughters that have been matched
  set<int> matches_global;
 
  // check if the daughters match
  for (int iDaughter_d = 0; iDaughter_d < getNDaughters(); iDaughter_d++) {
    set<int> matches;
    for (int jDaughter_p = 0; jDaughter_p < nDaughters_p; jDaughter_p++) {
      const T* daughter = daughterList[jDaughter_p];
      int iPDGCode_daughter_p = 0;
      if (const auto* part_test = dynamic_cast<const Particle*>(daughter))
        iPDGCode_daughter_p = part_test->getPDGCode();
      else if (const auto* mc_test = dynamic_cast<const MCParticle*>(daughter))
        iPDGCode_daughter_p = mc_test->getPDG();
 
      if (iDaughter_d == 0 && (this->isIgnoreRadiatedPhotons() or this->isIgnoreGamma() or this->isIgnoreBrems())
          && iPDGCode_daughter_p == Const::photon.getPDGCode())
        matches_global.insert(jDaughter_p);
 
      int iMatchResult = m_daughters[iDaughter_d].match(daughter, jDaughter_p);
      if (iMatchResult < 0) isAmbiguities = true;
      if (abs(iMatchResult) == 2 && iCC == 1) continue;
      if (abs(iMatchResult) == 1 && iCC == 2) continue;
      if (abs(iMatchResult) == 2 && iCC == 3) continue;
      matches.insert(jDaughter_p);
      matches_global.insert(jDaughter_p);
    }
    if (matches.empty()) return 0;
    if (matches.size() == 1) {
      int jDaughter_p = *(matches.begin());
      singlematch.emplace_back(iDaughter_d, jDaughter_p);
    } else multimatch.emplace_back(iDaughter_d, matches);
  }
 
  // Now, all daughters of the particles should be matched to at least one DecayDescriptor daughter
  if (!(this->isIgnoreIntermediate() or this->isIgnoreMassive() or this->isIgnoreNeutrino())
      && int(matches_global.size()) != nDaughters_p) return 0;
 
  // In case that there are DecayDescriptor daughters with multiple matches, try to solve the problem
  // by removing the daughter candidates which are already used in other unambiguous relations.
  // This is done iteratively. We limit the maximum number of attempts to 20 to avoid an infinite loop.
  bool isModified = true;
  for (int iTry = 0; iTry < 20; iTry++) {
    if (int(singlematch.size()) == getNDaughters()) break;
    if (!isModified) break;
    isModified = false;
    for (auto& itMulti : multimatch) {
      for (auto& itSingle : singlematch) {
        // try to remove particle from the multimatch list
        if (itMulti.second.erase(itSingle.second)) {
          B2FATAL("Trying to execute part of the code with known bug, which is not fixed yet! Send email to anze.zupanc@ijs.si with notification that this happens!");
          /*
            This part of the code is commented, because of the following error:
            Iterator 'itMulti' used after element has been erased.
 
                // if multimatch list contains only one particle candidate, move the entry to the singlematch list
                if (itMulti->second.size() == 1) {
                  int iDaughter_d = itMulti->first;
                  int iDaughter_p = *(itMulti->second.begin());
                  singlematch.push_back(make_pair(iDaughter_d, iDaughter_p));
                  multimatch.erase(itMulti);
                  // call match function again to set the correct daughter
                  if (!isAmbiguities) {
                    const T* daughter = daughterList[iDaughter_p];
                    if (!daughter) continue;
                    m_daughters[iDaughter_d].match(daughter, iDaughter_p);
                  }
                  --itMulti;
                  isModified = true;
                  break;
                }
          */
        }
      }
    }
  }
 
  if (!multimatch.empty()) isAmbiguities = true;
  if (isAmbiguities) return -iCC;
  else {
    m_iDaughter_p = iDaughter_p;
    return iCC;
  }
  return 0;
}

operator DecayDescriptor *()

operator DecayDescriptor * ( )

inline

Dereference operator.

Definition at line 73 of file DecayDescriptor.h.

    {
      return m_isNULL ? nullptr : this;
    }

resetMatch()

void resetMatch

(

)

Reset results from previous call of the match() function.

Definition at line 276 of file DecayDescriptor.cc.

{
  m_iDaughter_p = -1;
  int nDaughters = m_daughters.size();
  for (int iDaughter = 0; iDaughter < nDaughters; iDaughter++) m_daughters[iDaughter].resetMatch();
}

Member Data Documentation

m_daughters

std::vector<DecayDescriptor> m_daughters

private

Direct daughters of the decaying particle.

Definition at line 41 of file DecayDescriptor.h.

m_hierarchy

std::vector<std::vector<std::pair<int, std::string> > > m_hierarchy

private

Collection of hierarchy paths of selected particles.

Hierarchy path is vector of pairs of relative daughter numbers and particle names. For instance, in decay B+ -> [ D+ -> ^K+ pi0 ] pi0 decay path of K+ is [(0, B), (0, D), (0 K)] Every selected particle has its own hierarchy path and they are stored as a vector in this variable: For the decayString B+ -> [ D+ -> ^K+ pi0 ] ^pi0 m_hierarchy, once filled, is [[(0, B), (0, D), (0, K)], [(0, B), (1, pi0)]]

Definition at line 63 of file DecayDescriptor.h.

m_iDaughter_p

int m_iDaughter_p

private

ID of the Daughter Particle* matched to this DecayDescriptor.

If this DecayDescriptor was not matched, the value is -1.

Definition at line 39 of file DecayDescriptor.h.

m_isInitOK

bool m_isInitOK

private

Is this object initialized correctly?

Definition at line 66 of file DecayDescriptor.h.

m_isNULL

bool m_isNULL

private

Is this the NULL object?

Definition at line 45 of file DecayDescriptor.h.

m_mother

DecayDescriptorParticle m_mother

private

Mother of the decay ('left side').

Definition at line 36 of file DecayDescriptor.h.

m_properties

int m_properties

private

Particle property.

Flags are defined in Particle::PropertyFlags

Definition at line 43 of file DecayDescriptor.h.

s_NULL

const DecayDescriptor & s_NULL = DecayDescriptor()

static

Singleton object representing NULL.

Definition at line 70 of file DecayDescriptor.h.

---

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

• analysis/DecayDescriptor/include/DecayDescriptor.h
• analysis/DecayDescriptor/src/DecayDescriptor.cc