Functions to perform Monte Carlo matching for reconstructed Particles. More...

#include <MCMatching.h>

Public Types
enum	MCErrorFlags { c_Correct = 0 , c_MissFSR = 1 , c_MissingResonance = 2 , c_DecayInFlight = 4 , c_MissNeutrino = 8 , c_MissGamma = 16 , c_MissMassiveParticle = 32 , c_MissKlong = 64 , c_MisID = 128 , c_AddedWrongParticle = 256 , c_InternalError = 512 , c_MissPHOTOS = 1024 , c_AddedRecoBremsPhoton = 2048 }
	Flags that describe different reconstruction errors. More...

Static Public Member Functions
static std::string	explainFlags (unsigned int flags)
	Return string with all human-readable flags, e.g.

static bool	setMCTruth (const Belle2::Particle *particle)
	This is the main function of MC matching algorithm.

static int	getMCErrors (const Belle2::Particle particle, const Belle2::MCParticle mcParticle=nullptr)
	Returns quality indicator of the match as a bit pattern where the individual bits indicate the the type of mismatch.

static int	setMCErrorsExtraInfo (Belle2::Particle particle, const Belle2::MCParticle mcParticle)
	Sets error flags in extra-info (also returns it).

static void	fillGenMothers (const Belle2::MCParticle *mcP, std::vector< int > &genMCPMothers)
	Fills vector with array (1-based) indices of all generator ancestors of given MCParticle.

static int	findCommonMother (const Belle2::MCParticle *mcP, const std::vector< int > &firstMothers, int lastMother)
	Finds a mother of mcP that is in firstMothers, from [lastMother, end].

static bool	isFSP (int pdg)
	Returns true if given PDG code indicates a FSP.

static bool	isFSR (const Belle2::MCParticle *p)
	Returns true if given MCParticle is a final state radiation (FSR) photon based on MCParticle::c_IsFSRPhoton.

static bool	isFSRLegacy (const Belle2::MCParticle *p)
	Returns true if given MCParticle is a final state radiation (FSR) photon.

static bool	isRadiativePhoton (const Belle2::MCParticle *p)
	Returns true if given MCParticle is a radiative photon.

static int	getMissingParticleFlags (const Belle2::Particle particle, const Belle2::MCParticle mcParticle)
	Determines which daughters of 'mcParticle' are not reconstructed by any daughter of 'particle'.

static int	getFlagsOfFSP (const Particle particle, const MCParticle mcParticle)
	Returns flags of given Final State Particle.

static int	getFlagsOfDaughters (const Particle daughter, const MCParticle mcParticle)
	Returns flags of daughters of given particle.

static int	getFlagsOfBremsPhotonDaughter (const Particle daughter, const MCParticle mcParticle, const std::vector< const MCParticle * > &genParts)
	Returns flags of given daughter which is a brems photon.

static int	getNumberOfDaughtersWithoutNeutrinos (const MCParticle *mcParticle)
	Determines the number of daughter particles which are not neutrinos.

static int	countMissingParticle (const Belle2::Particle particle, const Belle2::MCParticle mcParticle, const std::vector< int > &daughterPDG)
	Count the number of missing daughters of the 'particle'.

static int	getFlagsIgnoredByProperty (const Belle2::Particle *particle)
	Returns the flags ignored by PropertyFlags of given particle.

static int	makeDaughterAcceptMask (int daughterProperty)
	Returns the daughter mask from given daughterProperty.

Static Public Attributes
static const std::string	c_extraInfoMCErrors = "mcErrors"
	Name of extra-info field stored in Particle.

Detailed Description

Functions to perform Monte Carlo matching for reconstructed Particles.

End users should usually not need to run these functions directly, but can use the matchMCTruth() python function in modularAnalysis (or the MCMatching module). Afterwards, Particles have relations to the matched MCParticle.

Different MCErrorFlags flags can be queried using getMCErrors(), or the associated 'mcErrors' variable (available via VariablesToNtuple, the MCTruth ntuple tool, etc.). For checking if a Particle is correctly reconstructed, the 'isSignal' variable can be used.

Definition at line 28 of file MCMatching.h.

Member Enumeration Documentation

◆ MCErrorFlags

enum MCErrorFlags

Flags that describe different reconstruction errors.

Enumerator
c_Correct	This Particle and all its daughters are perfectly reconstructed.
c_MissFSR	A Final State Radiation (FSR) photon is not reconstructed (based on MCParticle::c_IsFSRPhoton).
c_MissingResonance	The associated MCParticle decay contained additional non-final-state particles (e.g. a rho) that weren't reconstructed. This is probably O.K. in most cases
c_DecayInFlight	A Particle was reconstructed from the secondary decay product of the actual particle. This means that a wrong hypothesis was used to reconstruct it, which e.g. for tracks might mean a pion hypothesis was used for a secondary electron.
c_MissNeutrino	A neutrino is missing (not reconstructed).
c_MissGamma	A photon (not FSR) is missing (not reconstructed).
c_MissMassiveParticle	A generated massive FSP is missing (not reconstructed).
c_MissKlong	A Klong is missing (not reconstructed).
c_MisID	One of the charged final state particles is mis-identified, i.e. PDG != mcPDG. This can be due to the mis-identification of particle type (i.e. abs(PDG) != abs(mcPDG)) and/or the wrong charge assignment (i.e. charge != mcCharge).
c_AddedWrongParticle	A non-FSP Particle has wrong PDG code, meaning one of the daughters (or their daughters) belongs to another Particle.
c_InternalError	There was an error in MC matching. Not a valid match. Might indicate fake/background track or cluster.
c_MissPHOTOS	A photon created by PHOTOS was not reconstructed (based on MCParticle::c_IsPHOTOSPhoton)
c_AddedRecoBremsPhoton	A photon added with the bremsstrahlung recovery tools (correctBrems or correctBremsBelle) has no MC particle assigned, or it doesn't belong to the decay chain.

Definition at line 33 of file MCMatching.h.

                      {
      c_Correct               = 0,  
      c_MissFSR               = 1, 
      c_MissingResonance      = 2, 
      c_DecayInFlight         = 4, 
      c_MissNeutrino          = 8, 
      c_MissGamma             = 16, 
      c_MissMassiveParticle   = 32, 
      c_MissKlong             = 64, 
      c_MisID                 = 128, 
      c_AddedWrongParticle    = 256, 
      c_InternalError         = 512, 
      c_MissPHOTOS            = 1024, 
      c_AddedRecoBremsPhoton  = 2048, 
    };

Member Function Documentation

◆ countMissingParticle()

int countMissingParticle	(	const Belle2::Particle *	particle,
		const Belle2::MCParticle *	mcParticle,
		const std::vector< int > &	daughterPDG
	)

static

Count the number of missing daughters of the 'particle'.

Returns: number of missing daughters having given PDG codes

Definition at line 561 of file MCMatching.cc.

{
  unordered_set<const MCParticle*> mcMatchedParticles;
  // Missing particles which are accepted by the property flags are NOT stored.
  // --> Such particles are also counted in nMissingDaughter.
  appendParticles(particle, mcMatchedParticles);
  vector<const MCParticle*> genParts;
  appendParticles(mcParticle, genParts);
 
  int nMissingDaughter = 0;
 
  for (const MCParticle* genPart : genParts) {
    const bool missing = (mcMatchedParticles.find(genPart) == mcMatchedParticles.end());
    if (missing) {
 
      const int generatedPDG = genPart->getPDG();
      const int absGeneratedPDG = abs(generatedPDG);
 
      auto result = find(daughterPDG.begin(), daughterPDG.end(), absGeneratedPDG);
      if (result != daughterPDG.end())
        nMissingDaughter++;
    }
  }
 
  return nMissingDaughter;
}

◆ explainFlags()

std::string explainFlags ( unsigned int flags )

static

Return string with all human-readable flags, e.g.

explainFlags(402) returns "c_MissingResonance | c_MissGamma | c_MisID | c_AddedWrongParticle".

Can also be used from Python:

import basf2
from ROOT import Belle2, gInterpreter
gInterpreter.ProcessLine('#include "analysis/utility/MCMatching.h"')
print(Belle2.MCMatching.explainFlags(123))

Definition at line 26 of file MCMatching.cc.

{
  if (flags == c_Correct)
    return "c_Correct";
 
  std::string s;
  unsigned int f = 1;
  while (flags != 0) {
    if (flags & f) {
      switch (f) {
        case c_MissFSR               : s += "c_MissFSR"; break;
        case c_MissingResonance      : s += "c_MissingResonance"; break;
        case c_DecayInFlight         : s += "c_DecayInFlight"; break;
        case c_MissNeutrino          : s += "c_MissNeutrino"; break;
        case c_MissGamma             : s += "c_MissGamma"; break;
        case c_MissMassiveParticle   : s += "c_MissMassiveParticle"; break;
        case c_MissKlong             : s += "c_MissKlong"; break;
        case c_MisID                 : s += "c_MisID"; break;
        case c_AddedWrongParticle    : s += "c_AddedWrongParticle"; break;
        case c_InternalError         : s += "c_InternalError"; break;
        case c_MissPHOTOS            : s += "c_MissPHOTOS"; break;
        case c_AddedRecoBremsPhoton  : s += "c_AddedRecoBremsPhoton"; break;
        default:
          s += to_string(f);
          B2ERROR("MCMatching::explainFlags() doesn't know about flag " << f << ", please update it.");
      }
      flags -= f; //remove flag
      if (flags != 0)
        s += " | ";
    }
    f *= 2;
  }
  return s;
}

◆ fillGenMothers()

void fillGenMothers	(	const Belle2::MCParticle *	mcP,
		std::vector< int > &	genMCPMothers
	)

static

Fills vector with array (1-based) indices of all generator ancestors of given MCParticle.

Parameters

mcP	pointer to the MCParticle
genMCPMothers	pointer to the generator ancestors MCParticle

Definition at line 61 of file MCMatching.cc.

{
  while (mcP) {
    genMCPMothers.push_back(mcP->getIndex());
    mcP = mcP->getMother();
  }
}

◆ findCommonMother()

int findCommonMother	(	const Belle2::MCParticle *	mcP,
		const std::vector< int > &	firstMothers,
		int	lastMother
	)

static

Finds a mother of mcP that is in firstMothers, from [lastMother, end].

To actually find the common mother of all daughters, each time this function is called for a daughter particle, specify the return value from the last call for lastMother.

Note: this looks like an ideal case for applying a more sophisticated algorithm for LCA (lowest common ancestor) problems. However, our trees aren't very large, so additional preprocessing might slow this down (I saw this when experimenting with the algorithm). This might still be worth looking into if an algorithm with inexpensive preprocessing were used, or the preprocessing was done only once per event. See http://community.topcoder.com/tc?module=Static&d1=tutorials&d2=lowestCommonAncestor for an interesting introduction to related algorithms.

Returns: index of the first common mother in firstMothers (!), or -1 if not found.

Definition at line 70 of file MCMatching.cc.

{
  while (mcP) {
    int idx = mcP->getIndex();
    for (unsigned int i = lastMother; i < firstMothers.size(); i++) {
      if (firstMothers[i] == idx)
        return i;
    }
 
    mcP = mcP->getMother();
  }
  //not found
  return -1;
}

◆ getFlagsIgnoredByProperty()

int getFlagsIgnoredByProperty ( const Belle2::Particle * particle )

static

Returns the flags ignored by PropertyFlags of given particle.

Only c_isIgnored... flags are considered. c_isUnspecified is already considered in setMCErrorsExtraInfo function.

Returns: ORed combination of corresponding MCErrorFlags with PropertyFlags of given particle

Definition at line 588 of file MCMatching.cc.

{
  int flags = 0;
 
  if (part->getProperty() & Particle::PropertyFlags::c_IsIgnoreBrems) flags |= (MCMatching::c_AddedRecoBremsPhoton);
 
  return flags;
}

◆ getFlagsOfBremsPhotonDaughter()

int getFlagsOfBremsPhotonDaughter	(	const Particle *	daughter,
		const MCParticle *	mcParticle,
		const std::vector< const MCParticle * > &	genParts
	)

static

Returns flags of given daughter which is a brems photon.

Special treatment for brems is done.

Parameters

daughter
mcParticle	(this is MC mother of daughter)
genParts	vector of MC (n*grand-)daughters

Returns: flags of given daughter

Definition at line 409 of file MCMatching.cc.

{
  //At first, call getMCErrors as usual
  int daughterStatus = getMCErrors(daughter);
 
  //Check if the daughter has an MC particle related
  const MCParticle* mcDaughter = daughter->getRelatedTo<MCParticle>();
  //If it hasn't, add the c_BremsPhotonAdded flag to the mother and stop the propagation of c_InternalError
  if (!mcDaughter) {
    daughterStatus &= (~c_InternalError);
    daughterStatus |= c_AddedRecoBremsPhoton;
  }
  //If it has, check if MCParticle of the daughter is same as the mother. If so, we'll stop the propagation of c_MisID
  else if (mcDaughter == mcParticle) {
    daughterStatus &= (~c_MisID);
  }
  //If it has, check if the MC particle is (n*grand)-daughter of the particle mother. If it isn't, we'll add the error flag
  else if (std::find(genParts.begin(), genParts.end(), mcDaughter) == genParts.end()) {
    daughterStatus |= c_AddedRecoBremsPhoton;
  }
  //else nothing to do
 
  return daughterStatus;
}

◆ getFlagsOfDaughters()

int getFlagsOfDaughters	(	const Particle *	daughter,
		const MCParticle *	mcParticle
	)

static

Returns flags of daughters of given particle.

Parameters

daughter
mcParticle

Returns: flags of daughters of given particle

Definition at line 371 of file MCMatching.cc.

{
  unsigned nChildren = particle->getNDaughters();
 
  //Vector to store all the MC (n*grand-)daughters of the mother of the bremsstrahlung corrected particle
  vector<const MCParticle*> genParts;
  //Fill it only in the case we have a particle that has been brems corrected
  if (particle->hasExtraInfo("bremsCorrected") && nChildren > 1) {
    if (mcParticle && mcParticle->getMother())
      appendParticles(mcParticle->getMother(), genParts);
  }
 
  int daughterStatuses = 0;
  vector<int> daughterProperties = particle->getDaughterProperties();
  for (unsigned i = 0; i < nChildren; ++i) {
    const Particle* daughter = particle->getDaughter(i);
    int daughterStatus = 0;
    if (particle->hasExtraInfo("bremsCorrected") && daughter->getPDGCode() == Const::photon.getPDGCode()) {
      // if the daughter is a brems photon, start the special treatment
      daughterStatus |= getFlagsOfBremsPhotonDaughter(daughter, mcParticle, genParts);
    } else {
      daughterStatus |= getMCErrors(daughter);
    }
 
    int daughterStatusAcceptMask = (~c_Correct);
    if (i < daughterProperties.size()) // sanity check. daughterProperties should be larger than i.
      daughterStatusAcceptMask = makeDaughterAcceptMask(daughterProperties[i]);
 
    daughterStatuses |= (daughterStatus & daughterStatusAcceptMask);
  }
 
  //add up all (accepted) status flags we collected for our daughters
  const int daughterStatusesAcceptMask = c_MisID | c_AddedWrongParticle | c_DecayInFlight | c_InternalError | c_AddedRecoBremsPhoton;
  return (daughterStatuses & daughterStatusesAcceptMask);
 
}

◆ getFlagsOfFSP()

int getFlagsOfFSP	(	const Particle *	particle,
		const MCParticle *	mcParticle
	)

static

Returns flags of given Final State Particle.

Parameters

particle
mcParticle

Returns: flags of given particle

Definition at line 343 of file MCMatching.cc.

{
  if (particle->getPDGCode() == mcParticle->getPDG())
    return MCErrorFlags::c_Correct;
 
  // if PDG of particle is different from that of mcParticle
  if (mcParticle->hasStatus(MCParticle::c_PrimaryParticle)) {
    // if particle is primary, add the c_MisID flag.
    return MCErrorFlags::c_MisID;
  } else {
    // secondary particle, so the original particle probably decayed
    int status = MCErrorFlags::c_DecayInFlight;
 
    //find first primary mother
    const MCParticle* primary = mcParticle->getMother();
    while (primary and !primary->hasStatus(MCParticle::c_PrimaryParticle))
      primary = primary->getMother();
 
    if (!primary) {
      status |= MCErrorFlags::c_InternalError;
    } else if (particle->getPDGCode() != primary->getPDG()) {
      //if primary particle also has wrong PDG code, we're actually MisIDed
      status |= MCErrorFlags::c_MisID;
    }
    return status;
  }
}

◆ getMCErrors()

int getMCErrors	(	const Belle2::Particle *	particle,
		const Belle2::MCParticle *	mcParticle = `nullptr`
	)

static

Returns quality indicator of the match as a bit pattern where the individual bits indicate the the type of mismatch.

The values are defined in the MCErrorFlags enum and described in detail there.

A return value equal to c_Correct == 0 indicates a perfect MC match (everything OK).

The value is also stored inside the Particle's extra-info fields (so it is calculated only once per candidate).

Parameters

particle	pointer to the particle. setMCTruth() must have been called previously (usually via the MCMatching module)!
mcParticle	pointer to the matched MCParticle. Can be specified to avoid repeated lookups.

Returns: ORed combination of MCErrorFlags describing differences between reconstructed particle and MC truth.

Definition at line 282 of file MCMatching.cc.

{
  if (particle->hasExtraInfo(c_extraInfoMCErrors)) {
    return particle->getExtraInfo(c_extraInfoMCErrors);
  } else {
    if (!mcParticle)
      mcParticle = particle->getRelatedTo<MCParticle>();
    return setMCErrorsExtraInfo(const_cast<Particle*>(particle), mcParticle);
  }
}

◆ getMissingParticleFlags()

int getMissingParticleFlags	(	const Belle2::Particle *	particle,
		const Belle2::MCParticle *	mcParticle
	)

static

Determines which daughters of 'mcParticle' are not reconstructed by any daughter of 'particle'.

Returns: ORed combination of MCErrorFlags flags for missing particles.

Definition at line 502 of file MCMatching.cc.

{
  int flags = 0;
 
  vector<const MCParticle*> genParts;
  appendParticles(mcParticle, genParts);
 
  unordered_set<const MCParticle*> mcMatchedParticles;
  appendParticles(particle, mcMatchedParticles);
  unordered_set<const MCParticle*> acceptedParticles;
  appendAcceptedMissingDaughters(particle, acceptedParticles);
  for (auto part : acceptedParticles) {
    mcMatchedParticles.insert(part);
  }
 
 
  for (const MCParticle* genPart : genParts) {
 
    // if genPart exists in mcMatchedParticles, continue.
    if (mcMatchedParticles.find(genPart) != mcMatchedParticles.end())
      continue;
 
    //we want to set a flag, so what kind of particle is genPart?
    const int generatedPDG = genPart->getPDG();
    const int absGeneratedPDG = abs(generatedPDG);
 
    if (!isFSP(generatedPDG)) {
      flags |= c_MissingResonance;
    } else if (generatedPDG == Const::photon.getPDGCode()) { //missing photon
      if (AnalysisConfiguration::instance()->useLegacyMCMatching()) {
        if (flags & (c_MissFSR | c_MissGamma)) {
          // if flags already have c_MissFSR or c_MissGamm, do nothing.
        } else {
          if (isFSRLegacy(genPart)) {
            flags |= c_MissFSR;
            flags |= c_MissPHOTOS;
          } else {
            flags |= c_MissGamma;
          }
        }
      } else {
        if (isFSR(genPart))
          flags |= c_MissFSR;
        else if (genPart->hasStatus(MCParticle::c_IsPHOTOSPhoton))
          flags |= c_MissPHOTOS;
        else
          flags |= c_MissGamma;
      }
    } else if (absGeneratedPDG == 12 || absGeneratedPDG == 14 || absGeneratedPDG == 16) { // missing neutrino
      flags |= c_MissNeutrino;
    } else { //neither photon nor neutrino -> massive
      flags |= c_MissMassiveParticle;
      if (absGeneratedPDG == Const::Klong.getPDGCode())
        flags |= c_MissKlong;
    }
  }
  return flags;
}

◆ getNumberOfDaughtersWithoutNeutrinos()

int getNumberOfDaughtersWithoutNeutrinos ( const MCParticle * mcParticle )

static

Determines the number of daughter particles which are not neutrinos.

Needed to handle the special case tau -> rho nu correctly.

Parameters

mcParticle

Returns: number of daughters which are not neutrinos

Definition at line 435 of file MCMatching.cc.

{
  auto daughters = mcParticle->getDaughters();
  unsigned int number_of_neutrinos = 0;
  for (auto& p : daughters) {
    auto pdg = abs(p->getPDG());
    if (pdg == 12 || pdg == 14 || pdg == 16) {
      number_of_neutrinos++;
    }
  }
  return daughters.size() - number_of_neutrinos;
}

◆ isFSP()

bool isFSP ( int pdg )

static

Returns true if given PDG code indicates a FSP.

Definition at line 448 of file MCMatching.cc.

{
  switch (abs(pdg)) {
    case 211: // pi
    case 321: // K
    case 11: // e
    case 12: // nu_e
    case 13: // mu
    case 14: // nu_mu
    case 16: // nu_tau
    case 22: // gamma
    case 2212: // proton
    case 310: // K0S
    case 130: // K0L
    case 2112: // neutron
      return true;
    default:
      return false;
  }
}

◆ isFSR()

bool isFSR ( const Belle2::MCParticle * p )

static

Returns true if given MCParticle is a final state radiation (FSR) photon based on MCParticle::c_IsFSRPhoton.

Assumes PDG code of p is 22.

Definition at line 469 of file MCMatching.cc.

{
  return p->hasStatus(MCParticle::c_IsFSRPhoton);
}

◆ isFSRLegacy()

bool isFSRLegacy ( const Belle2::MCParticle * p )

static

Returns true if given MCParticle is a final state radiation (FSR) photon.

This is a legacy version of isFSR(const Belle2::MCParticle* p) function that works on MC samples without MCParticle::c_IsFSRPhoton and MCParticle::c_IsPHOTOSPhoton properly set (for example Belle MC).

Definition at line 474 of file MCMatching.cc.

{
  // In older versions of MC MCParticles don't have c_IsFSRPhoton, c_IsISRPhoton or c_ISPHOTOSPhoton bits
  // properly set. Instead this approximation is used to check if given photon is radiative (physics) photon
  // or produced by PHOTOS (FSR).
 
  const MCParticle* mother = p->getMother();
  if (!mother) {
    B2ERROR("The hell? why would this gamma not have a mother?");
    return false; //?
  }
 
  int ndaug = mother->getNDaughters();
  if (ndaug > 2) { // M -> A B (...) gamma is probably FSR
    return true;
  } else { // M -> A gamma is probably a decay
    return false;
  }
}

◆ isRadiativePhoton()

bool isRadiativePhoton ( const Belle2::MCParticle * p )

static

Returns true if given MCParticle is a radiative photon.

Assumes PDG code of p is 22.

Definition at line 495 of file MCMatching.cc.

{
  // Check if any of the bits c_IsFSRPhoton, c_IsISRPhoton or c_ISPHOTOSPhoton is set
  return p->getStatus(MCParticle::c_IsRadiativePhoton) != 0;
}

◆ makeDaughterAcceptMask()

int makeDaughterAcceptMask ( int daughterProperty )

static

Returns the daughter mask from given daughterProperty.

Returns: ORed combination of MCErrorFlags to be accepted for the daughter

Definition at line 597 of file MCMatching.cc.

{
  int flags = 0;
 
  if (daughterProperty & Particle::PropertyFlags::c_IsIgnoreMisID) flags |= (MCMatching::c_MisID);
  if (daughterProperty & Particle::PropertyFlags::c_IsIgnoreDecayInFlight) flags |= (MCMatching::c_DecayInFlight);
 
  return (~flags);
 
}

◆ setMCErrorsExtraInfo()

int setMCErrorsExtraInfo	(	Belle2::Particle *	particle,
		const Belle2::MCParticle *	mcParticle
	)

static

Sets error flags in extra-info (also returns it).

Users should use getMCErrors(), which only calculates this information when necessary.

Definition at line 293 of file MCMatching.cc.

{
  auto setStatus = [](Particle * part, int s) -> int {
    part->addExtraInfo(c_extraInfoMCErrors, s);
    return s;
  };
 
  if (!mcParticle)
    return setStatus(particle, MCErrorFlags::c_InternalError);
 
  if (particle->getNDaughters() == 0) { //FSP
    //other checks concern daughters of particle, so we're done here
    return setStatus(particle, getFlagsOfFSP(particle, mcParticle));;
  }
 
  int status = 0;
 
  // Check if particle (non FSP) has different PDG code than mcParticle
  const Particle::EFlavorType flavorType = particle->getFlavorType();
  if ((flavorType == Particle::c_Flavored and particle->getPDGCode() != mcParticle->getPDG())
      or (flavorType == Particle::c_Unflavored and abs(particle->getPDGCode()) != abs(mcParticle->getPDG()))) {
    auto mother = mcParticle->getMother();
 
    // Check if mother particle has the correct pdg code, if so we have to take care of the special case
    // tau -> rho nu, where a the matched mother is  the rho, but we have only a missing resonance and not added a wrong particle.
    if (mother and particle->getPDGCode() == mother->getPDG() and getNumberOfDaughtersWithoutNeutrinos(mother) == 1
        and !particle->hasExtraInfo("bremsCorrected")) {
      if (abs(mother->getPDG()) != 15 and abs(mcParticle->getPDG()) != 15) {
        B2WARNING("Special treatment in MCMatching for tau is called for a non-tau particle. Check if you discovered another special case here, or if we have a bug! "
                  << mother->getPDG() << " " << particle->getPDGCode() << " " << mcParticle->getPDG());
      }
      // if particle has c_IsIgnoreIntermediate flag, c_MissingResonance will not be added.
      if (not(particle->getProperty() & Particle::PropertyFlags::c_IsIgnoreIntermediate))
        status |= MCErrorFlags::c_MissingResonance;
    } else if (!(particle->getProperty() & Particle::PropertyFlags::c_IsUnspecified)) {
      // Check if the particle is unspecified. If so the flag of c_AddedWrongParticle will be ignored.
      status |= MCErrorFlags::c_AddedWrongParticle;
    }
  }
 
  status |= getFlagsOfDaughters(particle, mcParticle);
 
  status |= getMissingParticleFlags(particle, mcParticle);
 
  // Mask the flags ignored by PropertyFlags of the particle
  status &= ~(getFlagsIgnoredByProperty(particle));
 
  return setStatus(particle, status);
}

◆ setMCTruth()

bool setMCTruth ( const Belle2::Particle * particle )

static

This is the main function of MC matching algorithm.

When executed the algorithm searches for first common generated mother (MCParticle) of this particle's daughters. If such MCParticle is found the Particle -> MCParticle relation is set between them. If the relation between daughter particles and matched generated MC particle does not exist the algorithm sets it also for them.

Parameters

particle pointer to the Particle to be mc-matched

Returns: returns true if relation is set and false otherwise

Definition at line 86 of file MCMatching.cc.

{
  //if extra-info is set, we already handled this particle
  //TODO check whether this actually speeds things up or not
  if (particle->hasExtraInfo(c_extraInfoMCErrors))
    return true;
 
  if (particle->getRelatedTo<MCParticle>()) {
    //nothing to do
    return true;
  }
 
  int nChildren = particle->getNDaughters();
  if (nChildren == 0) {
    //no daughters -> should be an FSP, but no related MCParticle. Probably background.
    return false;
  }
 
  // check, if for all daughter particles Particle -> MCParticle relation exists
  bool daugMCTruth = true;
  for (int i = 0; i < nChildren; ++i) {
    const Particle* daugP = particle->getDaughter(i);
    // call setMCTruth for all daughters
    daugMCTruth &= setMCTruth(daugP);
  }
  if (!daugMCTruth)
    return false;
 
  int motherIndex = 0;
  if (nChildren == 1) {
    // assign mother of MCParticle related to our daughter
    const Particle*    daugP   = particle->getDaughter(0);
    const MCParticle*  daugMCP = daugP->getRelatedTo<MCParticle>();
    if (!daugMCP)
      return false;
    const MCParticle* mom = daugMCP->getMother();
    if (!mom)
      return false;
    motherIndex = mom->getIndex();
 
  } else {
    // at this stage for all daughters particles the  Particle <-> MCParticle relation exists
    // first fill vector with indices of all mothers of first daughter,
    // then search common mother for each other daughter
 
    vector<int> firstDaugMothers; // indices of generated mothers of first daughter
 
    int lastMother = 0; //index in firstDaugMothers (start with first daughter itself)
    for (int i = 0; i < nChildren; ++i) {
      const Particle*    daugP   = particle->getDaughter(i);
      const MCParticle*  daugMCP = daugP->getRelatedTo<MCParticle>();
 
      if (i == 0) {
        fillGenMothers(daugMCP, firstDaugMothers);
      } else {
        lastMother = findCommonMother(daugMCP, firstDaugMothers, lastMother);
        if (lastMother == -1)
          break; //not found
      }
    }
    if (lastMother >= 0)
      motherIndex = firstDaugMothers[lastMother];
  }
 
  // if index is less than 1, the common mother particle was not found
  // remember: it's 1-based index
  if (motherIndex < 1)
    return false;
 
  // finally the relation can be set
  StoreArray<MCParticle> mcParticles;
 
  // sanity check
  if (motherIndex > mcParticles.getEntries()) {
    B2ERROR("setMCTruth(): sanity check failed!");
    return false;
  }
 
  const MCParticle* mcMatch = mcParticles[motherIndex - 1];
  particle->addRelationTo(mcMatch);
 
  return true;
}

Member Data Documentation

◆ c_extraInfoMCErrors

const std::string c_extraInfoMCErrors = "mcErrors"

static

Name of extra-info field stored in Particle.

Definition at line 30 of file MCMatching.h.

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

analysis/utility/include/MCMatching.h
analysis/utility/src/MCMatching.cc

Public Types

Static Public Member Functions

Static Public Attributes

Detailed Description

Member Enumeration Documentation

◆ MCErrorFlags

Member Function Documentation

◆ countMissingParticle()

◆ explainFlags()

◆ fillGenMothers()

◆ findCommonMother()

◆ getFlagsIgnoredByProperty()

◆ getFlagsOfBremsPhotonDaughter()

◆ getFlagsOfDaughters()

◆ getFlagsOfFSP()

◆ getMCErrors()

◆ getMissingParticleFlags()

◆ getNumberOfDaughtersWithoutNeutrinos()

◆ isFSP()

◆ isFSR()

◆ isFSRLegacy()

◆ isRadiativePhoton()

◆ makeDaughterAcceptMask()

◆ setMCErrorsExtraInfo()

◆ setMCTruth()

Member Data Documentation

◆ c_extraInfoMCErrors