Class to store reconstructed particles. More...

#include <Particle.h>

Inheritance diagram for Particle:

Collaboration diagram for Particle:

[legend]

Public Types
enum	EParticleSourceObject { c_Undefined = 0 , c_Track = 1 , c_ECLCluster = 2 , c_KLMCluster = 3 , c_V0 = 4 , c_MCParticle = 5 , c_Composite = 6 , c_NoMDSTSource = 7 }
	particle source enumerators More...

enum	EFlavorType { c_Unflavored = 0 , c_Flavored = 1 }
	describes flavor type, see getFlavorType(). More...

enum	{ c_DimPosition = 3 , c_DimMomentum = 4 , c_DimMatrix = 7 , c_SizeMatrix = c_DimMatrix * (c_DimMatrix + 1) / 2 }
	error matrix dimensions and size of 1D representation More...

enum	{ c_Px , c_Py , c_Pz , c_E , c_X , c_Y , c_Z }
	enumerator used for error matrix handling, shows also in which order the rows (columns) are defined More...

enum	PropertyFlags { c_Ordinary = 0 , c_IsUnspecified = 1 , c_IsIgnoreRadiatedPhotons = 2 , c_IsIgnoreIntermediate = 4 , c_IsIgnoreMassive = 8 , c_IsIgnoreNeutrino = 16 , c_IsIgnoreGamma = 32 , c_IsIgnoreBrems = 64 , c_IsIgnoreMisID = 128 , c_IsIgnoreDecayInFlight = 256 }
	Flags that describe the particle property, which are used in the MC matching. More...

Public Member Functions
	Particle ()
	Default constructor.

	Particle (const ROOT::Math::PxPyPzEVector &momentum, const int pdgCode)
	Constructor from a Lorentz vector and PDG code.

	Particle (const ROOT::Math::PxPyPzEVector &momentum, const int pdgCode, EFlavorType flavorType, const EParticleSourceObject particleType, const unsigned mdstIndex)
	Constructor for final state particles.

	Particle (const ROOT::Math::PxPyPzEVector &momentum, const int pdgCode, EFlavorType flavorType, const std::vector< int > &daughterIndices, TClonesArray *arrayPointer=nullptr)
	Constructor for composite particles.

	Particle (const ROOT::Math::PxPyPzEVector &momentum, const int pdgCode, EFlavorType flavorType, const std::vector< int > &daughterIndices, int properties, TClonesArray *arrayPointer=nullptr)
	Constructor for composite particles.

	Particle (const ROOT::Math::PxPyPzEVector &momentum, const int pdgCode, EFlavorType flavorType, const std::vector< int > &daughterIndices, int properties, const std::vector< int > &daughterProperties, TClonesArray *arrayPointer=nullptr)
	Constructor for composite particles.

	Particle (const Track *track, const Const::ChargedStable &chargedStable)
	Constructor from a reconstructed track (mdst object Track);.

	Particle (int trackArrayIndex, const TrackFitResult *trackFit, const Const::ChargedStable &chargedStable)
	Constructor from a reconstructed Track given as TrackFitResult.

	Particle (const ECLCluster *eclCluster, const Const::ParticleType &type=Const::photon)
	Constructor of a photon from a reconstructed ECL cluster that is not matched to any charged track.

	Particle (const KLMCluster *klmCluster, const int pdgCode=Const::Klong.getPDGCode())
	Constructor from a reconstructed KLM cluster.

	Particle (const MCParticle *MCparticle)
	Constructor from MC particle (mdst object MCParticle)

	~Particle ()
	Destructor.

void	setPDGCode (const int pdg)
	Sets PDG code.

void	set4Vector (const ROOT::Math::PxPyPzEVector &p4)
	Sets Lorentz vector.

void	set4VectorDividingByMomentumScaling (const ROOT::Math::PxPyPzEVector &p4)
	Sets Lorentz vector dividing by the momentum scaling factor.

void	setVertex (const ROOT::Math::XYZVector &vertex)
	Sets position (decay vertex)

void	setEnergyLossCorrection (double energyLossCorrection)
	Sets Energy loss correction.

double	getMomentumLossCorrectionFactor () const
	Returns effect of energy correction on the particle momentum.

void	setMomentumScalingFactor (double momentumScalingFactor)
	Sets momentum scaling.

void	setMomentumSmearingFactor (double momentumSmearingFactor)
	Sets momentum smearing.

void	setJacobiMatrix (const TMatrixF &jacobiMatrix)
	Sets 4x6 jacobi matrix.

void	setMomentumVertexErrorMatrix (const TMatrixFSym &errMatrix)
	Sets 7x7 error matrix.

void	setPValue (double pValue)
	Sets chi^2 probability of fit.

void	setProperty (const int properties)
	sets m_properties

void	updateMomentum (const ROOT::Math::PxPyPzEVector &p4, const ROOT::Math::XYZVector &vertex, const TMatrixFSym &errMatrix, double pValue)
	Sets Lorentz vector, position, 7x7 error matrix and p-value.

void	updateMass (const int pdgCode)
	Updates particle mass with the mass of the particle corresponding to the given PDG.

void	appendDaughter (const Particle *daughter, const bool updateType=true, const int daughterProperty=c_Ordinary)
	Appends index of daughter to daughters index array.

void	appendDaughter (int particleIndex, const bool updateType=true)
	Appends index of daughter to daughters index array.

void	removeDaughter (const Particle *daughter, const bool updateType=true)
	Removes index of daughter from daughters index array.

bool	replaceDaughter (const Particle oldDaughter, Particle newDaughter)
	Replace index of given daughter with new daughter, return true if a replacement is made.

bool	replaceDaughterRecursively (const Particle oldDaughter, Particle newDaughter)
	Apply replaceDaughter to all Particles in the decay tree by looping recursively through it, return true if a replacement is made.

int	getPDGCode (void) const
	Returns PDG code.

double	getCharge (void) const
	Returns particle charge.

EFlavorType	getFlavorType () const
	Returns flavor type of the decay (for FS particles: flavor type of particle)

EParticleSourceObject	getParticleSource () const
	Returns particle source as defined with enum EParticleSourceObject.

unsigned	getMdstArrayIndex (void) const
	Returns 0-based index of MDST store array object (0 for composite particles)

int	getProperty () const
	Returns particle property as a bit pattern The values are defined in the PropertyFlags enum and described in detail there.

double	getMass () const
	Returns invariant mass (= nominal for FS particles)

double	getPDGMass (void) const
	Returns uncertainty on the invariant mass (requires valid momentum error matrix)

double	getPDGLifetime () const
	Returns particle nominal lifetime.

double	getEnergy () const
	Returns total energy.

ROOT::Math::PxPyPzEVector	get4Vector () const
	Returns Lorentz vector.

ROOT::Math::XYZVector	getMomentum () const
	Returns momentum vector.

double	getMomentumMagnitude () const
	Returns momentum magnitude.

double	getP () const
	Returns momentum magnitude (same as getMomentumMagnitude but with shorter name)

double	getPx () const
	Returns x component of momentum.

double	getPy () const
	Returns y component of momentum.

double	getPz () const
	Returns z component of momentum.

double	getEffectiveMomentumScale () const
	Returns effective momentum scale which is the product of the momentum scaling and smearing factors.

double	getEnergyLossCorrection () const
	Returns Energy Loss Correction.

ROOT::Math::XYZVector	getVertex () const
	Returns vertex position (POCA for charged, IP for neutral FS particles)

double	getX () const
	Returns x component of vertex position.

double	getY () const
	Returns y component of vertex position.

double	getZ () const
	Returns z component of vertex position.

double	getPValue () const
	Returns chi^2 probability of fit if done or -1.

TMatrixFSym	getMomentumVertexErrorMatrix () const
	Returns 7x7 error matrix.

TMatrixFSym	getMomentumErrorMatrix () const
	Returns the 4x4 momentum error matrix.

TMatrixFSym	getVertexErrorMatrix () const
	Returns the 3x3 position error sub-matrix.

double	getCosHelicity (const Particle *mother=nullptr) const
	Returns cosine of the helicity angle The helicity angle is defined in the rest frame of the particle as the angle between the negative momentum of the mother and.

double	getCosHelicityDaughter (unsigned iDaughter, unsigned iGrandDaughter=0) const
	Returns cosine of the helicity angle of the given daughter defined by given grand daughter.

double	getAcoplanarity () const
	Returns acoplanarity angle defined as the angle between the decay planes of the grand daughters in the particle's rest frame This assumes that the particle and its daughters have two daughters each.

int	getMdstSource () const
	Returns unique identifier of final state particle (needed in particle combiner)

unsigned	getNDaughters (void) const
	Returns number of daughter particles.

const std::vector< int > &	getDaughterIndices () const
	Returns a vector of store array indices of daughter particles.

const std::vector< int > &	getDaughterProperties () const
	Returns a vector of properties of daughter particles.

const Particle *	getDaughter (unsigned i) const
	Returns a pointer to the i-th daughter particle.

bool	forEachDaughter (const std::function< bool(const Particle *)> &function, bool recursive=true, bool includeSelf=true) const
	Apply a function to all daughters of this particle.

std::vector< Belle2::Particle * >	getDaughters () const
	Returns a vector of pointers to daughter particles.

std::vector< const Belle2::Particle * >	getFinalStateDaughters () const
	Returns a vector of pointers to Final State daughter particles.

std::vector< const Belle2::Particle * >	getAllDaughters () const
	Returns a vector of pointers to all generations' daughter particles.

std::vector< int >	getMdstArrayIndices (EParticleSourceObject type) const
	Returns a vector of StoreArray indices of given MDST dataobjects.

bool	overlapsWith (const Particle *oParticle) const
	Returns true if final state ancestors of oParticle overlap.

bool	isCopyOf (const Particle *oParticle, bool doDetailedComparison=false) const
	Returns true if this Particle and oParticle are copies of each other.

const Track *	getTrack () const
	Returns the pointer to the Track object that was used to create this Particle (ParticleType == c_Track).

const TrackFitResult *	getTrackFitResult () const
	Returns the pointer to the TrackFitResult that was used to create this Particle (ParticleType == c_Track).

const V0 *	getV0 () const
	Returns the pointer to the V0 object that was used to create this Particle (if ParticleType == c_V0).

const PIDLikelihood *	getPIDLikelihood () const
	Returns the pointer to the PIDLikelihood object that is related to the Track, which was used to create this Particle (ParticleType == c_Track).

const ECLCluster *	getECLCluster () const
	Returns the pointer to the ECLCluster object that was used to create this Particle (if ParticleType == c_ECLCluster).

double	getECLClusterEnergy () const
	Returns the energy of the ECLCluster for the particle.

const KLMCluster *	getKLMCluster () const
	Returns the pointer to the KLMCluster object that was used to create this Particle (ParticleType == c_KLMCluster).

const MCParticle *	getMCParticle () const
	Returns the pointer to the MCParticle object that was used to create this Particle (ParticleType == c_MCParticle).

std::string	getName () const override
	Return name of this particle.

std::string	getInfoHTML () const override
	Return a short summary of this object's contents in HTML format.

void	print () const
	Prints the contents of a Particle object to standard output.

std::vector< std::string >	getExtraInfoNames () const
	get a list of the extra info names

void	removeExtraInfo ()
	Remove all stored extra info fields.

double	getExtraInfo (const std::string &name) const
	Return given value if set.

bool	hasExtraInfo (const std::string &name) const
	Return whether the extra info with the given name is set.

int	getExtraInfoMap () const
	Return the id of the associated ParticleExtraInfoMap or -1 if no map is set.

unsigned int	getExtraInfoSize () const
	Return the size of the extra info array.

void	writeExtraInfo (const std::string &name, const double value)
	Sets the user defined extraInfo.

void	setExtraInfo (const std::string &name, double value)
	Sets the user-defined data of given name to the given value.

void	addExtraInfo (const std::string &name, double value)
	Sets the user-defined data of given name to the given value.

TClonesArray *	getArrayPointer () const
	Returns the pointer to the store array which holds the daughter particles.

int	getPDGCodeUsedForFit () const
	Return the always positive PDG code which was used for the track fit (if there was a track fit) of this particle.

bool	wasExactFitHypothesisUsed () const
	Returns true if the type represented by this Particle object was used use as a mass hypothesis during the track of this Particle's parameters.

bool	isMostLikely () const
	Returns true if the (track-based) particle is created with its most likely mass hypothesis based on PID likelihood.

std::pair< Const::ChargedStable, const TrackFitResult * >	getMostLikelyTrackFitResult () const
	For a (track-based) particle, returns the charged stable mass hypothesis associated to the most probable TrackFitResult, and the TrackFitResult itself.

bool	isMostLikelyTrackFitResult () const
	Returns true if the (track-based) particle is created with its most likely mass hypothesis based on TrackFitResult.

ECLCluster::EHypothesisBit	getECLClusterEHypothesisBit () const
	Returns the ECLCluster EHypothesisBit for this Particle.

const Particle *	getParticleFromGeneralizedIndexString (const std::string &generalizedIndex) const
	Explores the decay tree of the particle and returns the (grand^n)daughter identified by a generalized index.

void	updateJacobiMatrix ()
	Propagate the photon energy scaling to jacobian elements that were calculated using energy.

void	fillFSPDaughters (std::vector< const Belle2::Particle * > &fspDaughters) const
	Fill final state particle daughters into a vector.

void	fillAllDaughters (std::vector< const Belle2::Particle * > &allDaughters) const
	Fill all generations' daughters into a vector.

void	addRelationTo (const RelationsInterface< BASE > *object, float weight=1.0, const std::string &namedRelation="") const
	Add a relation from this object to another object (with caching).

void	addRelationTo (const TObject *object, float weight=1.0, const std::string &namedRelation="") const
	Add a relation from this object to another object (no caching, can be quite slow).

void	copyRelations (const RelationsInterface< BASE > *sourceObj)
	Copies all relations of sourceObj (pointing from or to sourceObj) to this object (including weights).

template<class TO >
RelationVector< TO >	getRelationsTo (const std::string &name="", const std::string &namedRelation="") const
	Get the relations that point from this object to another store array.

template<class FROM >
RelationVector< FROM >	getRelationsFrom (const std::string &name="", const std::string &namedRelation="") const
	Get the relations that point from another store array to this object.

template<class T >
RelationVector< T >	getRelationsWith (const std::string &name="", const std::string &namedRelation="") const
	Get the relations between this object and another store array.

template<class TO >
TO *	getRelatedTo (const std::string &name="", const std::string &namedRelation="") const
	Get the object to which this object has a relation.

template<class FROM >
FROM *	getRelatedFrom (const std::string &name="", const std::string &namedRelation="") const
	Get the object from which this object has a relation.

template<class T >
T *	getRelated (const std::string &name="", const std::string &namedRelation="") const
	Get the object to or from which this object has a relation.

template<class TO >
std::pair< TO *, float >	getRelatedToWithWeight (const std::string &name="", const std::string &namedRelation="") const
	Get first related object & weight of relation pointing to an array.

template<class FROM >
std::pair< FROM *, float >	getRelatedFromWithWeight (const std::string &name="", const std::string &namedRelation="") const
	Get first related object & weight of relation pointing from an array.

template<class T >
std::pair< T *, float >	getRelatedWithWeight (const std::string &name="", const std::string &namedRelation="") const
	Get first related object & weight of relation pointing from/to an array.

std::string	getInfo () const
	Return a short summary of this object's contents in raw text format.

std::string	getArrayName () const
	Get name of array this object is stored in, or "" if not found.

int	getArrayIndex () const
	Returns this object's array index (in StoreArray), or -1 if not found.

Private Member Functions
void	setMomentumPositionErrorMatrix (const TrackFitResult *trackFit)
	Sets the momentum, position and error matrix for this particle (created from charged Track)

void	resetErrorMatrix ()
	Resets 7x7 error matrix All elements are set to 0.0.

void	resetJacobiMatrix ()
	Resets 4x6 error matrix All elements are set to 0.0.

void	storeErrorMatrix (const TMatrixFSym &errMatrix)
	Stores 7x7 error matrix into private member m_errMatrix.

void	storeJacobiMatrix (const TMatrixF &jacobiMatrix)
	Stores 4x6 Jacobi matrix into private member m_jacobiMatrix.

void	fillDecayChain (std::vector< int > &decayChain) const
	Fill vector with (PDGCode, MdstSource) pairs for the entire decay chain.

void	setFlavorType ()
	sets m_flavorType using m_pdgCode

void	setMdstArrayIndex (const int arrayIndex)
	set mdst array index

int	generatePDGCodeFromCharge (const int chargedSign, const Const::ChargedStable &chargedStable)
	Generate the PDG code with correct sign, using the charge.

	ClassDefOverride (Particle, 17)
	Class to store reconstructed particles.

	ClassDef (RelationsInterface, 0)
	defines interface for accessing relations of objects in StoreArray.

Private Attributes
int	m_pdgCode
	PDG code.

int	m_pdgCodeUsedForFit = 0
	PDG code used for the track fit.

double	m_mass
	particle (invariant) mass

double	m_px
	momentum component x

double	m_py
	momentum component y

double	m_pz
	momentum component z

double	m_momentumScale = 1.0
	effective momentum scale factor

double	m_momentumScalingFactor = 1.0
	momentum scaling factor

double	m_momentumSmearingFactor = 1.0
	momentum smearing factor

double	m_energyLossCorrection = 0.0
	energy loss correction.

double	m_x
	position component x

double	m_y
	position component y

double	m_z
	position component z

double	m_errMatrix [c_SizeMatrix] = {}
	error matrix (1D representation)

double	m_jacobiMatrix [c_SizeMatrix] = {}
	error matrix (1D representation)

double	m_pValue
	chi^2 probability of the fit.

std::vector< int >	m_daughterIndices
	daughter particle indices

EFlavorType	m_flavorType
	flavor type.

EParticleSourceObject	m_particleSource
	(mdst) source of particle

unsigned	m_mdstIndex
	0-based index of MDST store array object

int	m_properties
	particle property

std::vector< int >	m_daughterProperties
	daughter particle properties

int	m_identifier = -1
	Identifier that can be used to identify whether the particle is unique or is a copy or representation of another.

std::vector< double >	m_extraInfo
	Stores associated user defined values.

TClonesArray *	m_arrayPointer
	Internal pointer to DataStore array containing the daughters of this particle.

DataStore::StoreEntry *	m_cacheDataStoreEntry
	Cache of the data store entry to which this object belongs.

int	m_cacheArrayIndex
	Cache of the index in the TClonesArray to which this object belongs.

Friends
class	ParticleSubset

Detailed Description

Class to store reconstructed particles.

This class is a common representation of all particle types, e.g.:

final state particles (FS particles):
- charged kaons/pions/electrons/muons/protons reconstructed as Track
- photons reconstructed as ECLCluster (without associated Track)
- long lived neutral kaons reconstructed in KLM (as KLMCluster without associated Track)
composite particles:
- pre-reconstructed V0 particles: Kshort, Lambda baryon, converted photon, ...
- reconstructed in decays (via combinations)

Private members are limited to those which completely define the particle and that are common to all particle types. These are:

particle mass
- nominal for FS particles
- invariant for composite particles
momentum vector (px, py, pz)
position (x, y, z)
- POCA for charged FS particles
- IP for photons, Klong and pi0
- decay vertex for composite particles
7x7 error matrix (order is: px, py, pz, E, x, y, z)
chi^2 probability of the fit (track fit, pi0 mass-constr. fit or vertex fit)
PDG code
vector of StoreArray<Particle> indices of daughter particles

Additional private members are needed in order to make composite particles (via combinations):

mdst index of an object from which the FS particle is created
source of the object from which the particle is created (see EParticleSourceObject)
flavor type (unflavored/flavored) of a decay or flavor type of FS particle

Finally, it is possible to store user-defined floating-point values using addExtraInfo() and getExtraInfo(), identified by a string key. These are general purpose functions for collecting additional information about reconstructed particles that can not be included into any existing data object. Different Particle objects can store different sets of values, and there are no hard-coded limitations on the number of values stored.

Definition at line 75 of file Particle.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

error matrix dimensions and size of 1D representation

Definition at line 102 of file Particle.h.

         {c_DimPosition = 3, c_DimMomentum = 4, c_DimMatrix = 7,
          c_SizeMatrix = c_DimMatrix * (c_DimMatrix + 1) / 2
         };

◆ anonymous enum

anonymous enum

enumerator used for error matrix handling, shows also in which order the rows (columns) are defined

Definition at line 110 of file Particle.h.

110{c_Px, c_Py, c_Pz, c_E, c_X, c_Y, c_Z};

◆ EFlavorType

enum EFlavorType

describes flavor type, see getFlavorType().

Enumerator
c_Unflavored	Is its own antiparticle or we don't know whether it is a particle/antiparticle.
c_Flavored	Is either particle or antiparticle.

Definition at line 94 of file Particle.h.

                     {
      c_Unflavored = 0, 
      c_Flavored = 1, 
    };

◆ EParticleSourceObject

enum EParticleSourceObject

particle source enumerators

Definition at line 82 of file Particle.h.

                               {
      c_Undefined     = 0,
      c_Track         = 1,
      c_ECLCluster    = 2,
      c_KLMCluster    = 3,
      c_V0            = 4,
      c_MCParticle    = 5,
      c_Composite     = 6,
      c_NoMDSTSource  = 7
    };

◆ PropertyFlags

enum PropertyFlags

Flags that describe the particle property, which are used in the MC matching.

Enumerator
c_IsUnspecified	Ordinary particles. Is the particle unspecified by marking @ ?
c_IsIgnoreRadiatedPhotons	Is the particle MC matched with the ignore radiated photon flag set?
c_IsIgnoreIntermediate	Is the particle MC matched with the ignore intermediate resonances flag set?
c_IsIgnoreMassive	Is the particle MC matched with the ignore missing massive particle flag set?
c_IsIgnoreNeutrino	Is the particle MC matched with the ignore missing neutrino flag set?
c_IsIgnoreGamma	Is the particle MC matched with the ignore missing gamma flag set?
c_IsIgnoreBrems	Is the particle MC matched with the ignore added Brems gamma flag set?
c_IsIgnoreMisID	Is the particle MC matched with the ignore MisID flag set?
c_IsIgnoreDecayInFlight	Is the particle MC matched with the ignore DecayInFlight flag set?

Definition at line 116 of file Particle.h.

                       {
      c_Ordinary = 0, 
      c_IsUnspecified = 1, 
      c_IsIgnoreRadiatedPhotons = 2, 
      c_IsIgnoreIntermediate = 4, 
      c_IsIgnoreMassive = 8, 
      c_IsIgnoreNeutrino = 16, 
      c_IsIgnoreGamma = 32, 
      c_IsIgnoreBrems = 64, 
      c_IsIgnoreMisID = 128, 
      c_IsIgnoreDecayInFlight = 256, 
    };

Constructor & Destructor Documentation

◆ Particle() [1/11]

Particle ( )

Default constructor.

All private members are set to 0. Particle type is set to c_Undefined.

Definition at line 45 of file Particle.cc.

                   :
  m_pdgCode(0), m_mass(0), m_px(0), m_py(0), m_pz(0), m_x(0), m_y(0), m_z(0),
  m_pValue(nan("")), m_flavorType(c_Unflavored), m_particleSource(c_Undefined), m_mdstIndex(0), m_properties(0),
  m_arrayPointer(nullptr)
{
  resetErrorMatrix();
}

◆ Particle() [2/11]

Particle	(	const ROOT::Math::PxPyPzEVector &	momentum,
		const int	pdgCode
	)

Constructor from a Lorentz vector and PDG code.

All other private members are set to their default values (0).

Parameters

momentum	Lorentz vector
pdgCode	PDG code

Definition at line 54 of file Particle.cc.

                                                                           :
  m_pdgCode(pdgCode), m_mass(0), m_px(0), m_py(0), m_pz(0), m_x(0), m_y(0), m_z(0),
  m_pValue(-1), m_flavorType(c_Unflavored), m_particleSource(c_Undefined), m_mdstIndex(0), m_properties(0), m_arrayPointer(nullptr)
{
  setFlavorType();
  set4Vector(momentum);
  resetErrorMatrix();
  // set mass of stable charged particle to its nominal value
  if (Const::chargedStableSet.find(abs(m_pdgCode)) == Const::ParticleType(abs(m_pdgCode))) {
    updateMass(m_pdgCode);
  }
}

◆ Particle() [3/11]

Particle	(	const ROOT::Math::PxPyPzEVector &	momentum,
		const int	pdgCode,
		EFlavorType	flavorType,
		const EParticleSourceObject	particleType,
		const unsigned	mdstIndex
	)

Constructor for final state particles.

All other private members are set to their default values (0).

Parameters

momentum	Lorentz vector
pdgCode	PDG code
flavorType	flavor type
particleType	particle source
mdstIndex	mdst index

Definition at line 68 of file Particle.cc.

                                             :
  m_pdgCode(pdgCode), m_mass(0), m_px(0), m_py(0), m_pz(0), m_x(0), m_y(0), m_z(0),
  m_pValue(-1), m_flavorType(flavorType), m_particleSource(source), m_properties(0), m_arrayPointer(nullptr)
{
  if (flavorType == c_Unflavored and pdgCode < 0)
    m_pdgCode = -pdgCode;
 
  setMdstArrayIndex(mdstIndex);
  set4Vector(momentum);
  resetErrorMatrix();
  // set mass of stable charged particle to its nominal value
  if (Const::chargedStableSet.find(abs(m_pdgCode)) == Const::ParticleType(abs(m_pdgCode))) {
    updateMass(m_pdgCode);
  }
}

◆ Particle() [4/11]

Particle	(	const ROOT::Math::PxPyPzEVector &	momentum,
		const int	pdgCode,
		EFlavorType	flavorType,
		const std::vector< int > &	daughterIndices,
		TClonesArray *	arrayPointer = `nullptr`
	)

Constructor for composite particles.

All other private members are set to their default values (0).

Parameters

momentum	Lorentz vector
pdgCode	PDG code
flavorType	decay flavor type
daughterIndices	indices of daughters in StoreArray<Particle>
arrayPointer	pointer to store array which stores the daughters, if the particle itself is stored in the same array the pointer can be automatically determined

Definition at line 89 of file Particle.cc.

                                               :
  m_pdgCode(0), m_mass(0), m_px(0), m_py(0), m_pz(0), m_x(0), m_y(0), m_z(0),
  m_pValue(-1),
  m_daughterIndices(daughterIndices),
  m_flavorType(c_Unflavored), m_particleSource(c_Undefined), m_mdstIndex(0),
  m_properties(0), m_arrayPointer(arrayPointer)
{
  m_pdgCode = pdgCode;
  m_flavorType = flavorType;
  if (flavorType == c_Unflavored and pdgCode < 0)
    m_pdgCode = -pdgCode;
  set4Vector(momentum);
  resetErrorMatrix();
  // set mass of stable charged particle to its nominal value
  if (Const::chargedStableSet.find(abs(m_pdgCode)) == Const::ParticleType(abs(m_pdgCode))) {
    updateMass(m_pdgCode);
  }
 
  if (!daughterIndices.empty()) {
    m_particleSource    = c_Composite;
    if (getArrayPointer() == nullptr) {
      B2FATAL("Composite Particle (with daughters) was constructed outside StoreArray without specifying daughter array!");
    }
    for (unsigned int i = 0; i < m_daughterIndices.size(); i++) {
      m_daughterProperties.push_back(Particle::PropertyFlags::c_Ordinary);
    }
  }
}

◆ Particle() [5/11]

Particle	(	const ROOT::Math::PxPyPzEVector &	momentum,
		const int	pdgCode,
		EFlavorType	flavorType,
		const std::vector< int > &	daughterIndices,
		int	properties,
		TClonesArray *	arrayPointer = `nullptr`
	)

Constructor for composite particles.

All other private members are set to their default values (0).

Parameters

momentum	Lorentz vector
pdgCode	PDG code
flavorType	decay flavor type
daughterIndices	indices of daughters in StoreArray<Particle>
properties	particle property
arrayPointer	pointer to store array which stores the daughters, if the particle itself is stored in the same array the pointer can be automatically determined

Definition at line 122 of file Particle.cc.

                                               :
  m_pdgCode(0), m_mass(0), m_px(0), m_py(0), m_pz(0), m_x(0), m_y(0), m_z(0),
  m_pValue(-1),
  m_daughterIndices(daughterIndices),
  m_flavorType(c_Unflavored), m_particleSource(c_Undefined), m_mdstIndex(0),
  m_arrayPointer(arrayPointer)
{
  m_pdgCode = pdgCode;
  m_flavorType = flavorType;
  if (flavorType == c_Unflavored and pdgCode < 0)
    m_pdgCode = -pdgCode;
  set4Vector(momentum);
  resetErrorMatrix();
  // set mass of stable charged particle to its nominal value
  if (Const::chargedStableSet.find(abs(m_pdgCode)) == Const::ParticleType(abs(m_pdgCode))) {
    updateMass(m_pdgCode);
  }
  m_properties = properties;
 
  if (!daughterIndices.empty()) {
    m_particleSource    = c_Composite;
    if (getArrayPointer() == nullptr) {
      B2FATAL("Composite Particle (with daughters) was constructed outside StoreArray without specifying daughter array!");
    }
    for (unsigned int i = 0; i < m_daughterIndices.size(); i++) {
      m_daughterProperties.push_back(Particle::PropertyFlags::c_Ordinary);
    }
  }
}

◆ Particle() [6/11]

Particle	(	const ROOT::Math::PxPyPzEVector &	momentum,
		const int	pdgCode,
		EFlavorType	flavorType,
		const std::vector< int > &	daughterIndices,
		int	properties,
		const std::vector< int > &	daughterProperties,
		TClonesArray *	arrayPointer = `nullptr`
	)

Constructor for composite particles.

All other private members are set to their default values (0).

Parameters

momentum	Lorentz vector
pdgCode	PDG code
flavorType	decay flavor type
daughterIndices	indices of daughters in StoreArray<Particle>
properties	particle property
daughterProperties	daughter particle properties
arrayPointer	pointer to store array which stores the daughters, if the particle itself is stored in the same array the pointer can be automatically determined

Definition at line 158 of file Particle.cc.

                                               :
  m_pdgCode(0), m_mass(0), m_px(0), m_py(0), m_pz(0), m_x(0), m_y(0), m_z(0),
  m_pValue(-1),
  m_daughterIndices(daughterIndices),
  m_flavorType(c_Unflavored), m_particleSource(c_Undefined), m_mdstIndex(0),
  m_daughterProperties(daughterProperties),
  m_arrayPointer(arrayPointer)
{
  m_pdgCode = pdgCode;
  m_flavorType = flavorType;
  if (flavorType == c_Unflavored and pdgCode < 0)
    m_pdgCode = -pdgCode;
  set4Vector(momentum);
  resetErrorMatrix();
  // set mass of stable charged particle to its nominal value
  if (Const::chargedStableSet.find(abs(m_pdgCode)) == Const::ParticleType(abs(m_pdgCode))) {
    updateMass(m_pdgCode);
  }
  m_properties = properties;
 
  if (!daughterIndices.empty()) {
    m_particleSource    = c_Composite;
    if (getArrayPointer() == nullptr) {
      B2FATAL("Composite Particle (with daughters) was constructed outside StoreArray without specifying daughter array!");
    }
  }
}

◆ Particle() [7/11]

Particle	(	const Track *	track,
		const Const::ChargedStable &	chargedStable
	)

Constructor from a reconstructed track (mdst object Track);.

Parameters

track	pointer to Track object
chargedStable	Type of charged particle

Definition at line 193 of file Particle.cc.

                                                            :
  Particle(track ? track->getArrayIndex() : 0, track ? track->getTrackFitResultWithClosestMass(chargedStable) : nullptr,
           chargedStable)
{
}

◆ Particle() [8/11]

Particle	(	int	trackArrayIndex,
		const TrackFitResult *	trackFit,
		const Const::ChargedStable &	chargedStable
	)

Constructor from a reconstructed Track given as TrackFitResult.

To be used to create Particle objects from tracks with full control over the hypothesis (e.g. V0 daughters).

Parameters

trackArrayIndex	track StoreArray index
trackFit	pointer to TrackFitResult object
chargedStable	Type of charged particle

Definition at line 200 of file Particle.cc.

                                                            :
  m_pdgCode(0), m_mass(0), m_px(0), m_py(0), m_pz(0), m_x(0), m_y(0), m_z(0),
  m_pValue(-1), m_flavorType(c_Unflavored), m_particleSource(c_Undefined), m_mdstIndex(0), m_properties(0), m_arrayPointer(nullptr)
{
  if (!trackFit) return;
 
  m_flavorType = c_Flavored; //tracks are charged
  m_particleSource = c_Track;
 
  setMdstArrayIndex(trackArrayIndex);
 
  m_pdgCodeUsedForFit = trackFit->getParticleType().getPDGCode();
  m_pdgCode           = generatePDGCodeFromCharge(trackFit->getChargeSign(), chargedStable);
 
  // set mass
  if (TDatabasePDG::Instance()->GetParticle(m_pdgCode) == nullptr)
    B2FATAL("PDG=" << m_pdgCode << " ***code unknown to TDatabasePDG");
  m_mass = TDatabasePDG::Instance()->GetParticle(m_pdgCode)->Mass() ;
 
  // set momentum, position and error matrix
  setMomentumPositionErrorMatrix(trackFit);
}

◆ Particle() [9/11]

Particle	(	const ECLCluster *	eclCluster,
		const Const::ParticleType &	type = `Const::photon`
	)

explicit

Constructor of a photon from a reconstructed ECL cluster that is not matched to any charged track.

Parameters

eclCluster	pointer to ECLCluster object
type	the kind of ParticleType we want (photon by default)

Definition at line 225 of file Particle.cc.

                                                                              :
  m_pdgCode(type.getPDGCode()), m_mass(type.getMass()), m_px(0), m_py(0), m_pz(0), m_x(0), m_y(0), m_z(0),
  m_pValue(-1), m_flavorType(c_Unflavored), m_particleSource(c_Undefined), m_mdstIndex(0), m_properties(0), m_arrayPointer(nullptr)
{
  if (!eclCluster) return;
 
  setFlavorType();
 
  // returns default vertex from clusterutils (from beam parameters if available)
  // leave it like that for the moment to make it transparent
  ClusterUtils C;
  const XYZVector clustervertex = C.GetIPPosition();
  setVertex(clustervertex);
 
  const PxPyPzEVector clustermom = C.Get4MomentumFromCluster(eclCluster, clustervertex, getECLClusterEHypothesisBit());
  m_px = clustermom.Px();
  m_py = clustermom.Py();
  m_pz = clustermom.Pz();
 
  m_particleSource = c_ECLCluster;
  setMdstArrayIndex(eclCluster->getArrayIndex());
 
  // set Chi^2 probability:
  //TODO: gamma quality can be written here
  m_pValue = 1;
 
  // get error matrix.
  updateJacobiMatrix();
 
}

◆ Particle() [10/11]

Particle	(	const KLMCluster *	klmCluster,
		const int	pdgCode = `Const::Klong.getPDGCode()`
	)

explicit

Constructor from a reconstructed KLM cluster.

Parameters

klmCluster	pointer to KLMCluster object
pdgCode	PDG code (Klong by default)

Definition at line 295 of file Particle.cc.

                                                                  :
  m_pdgCode(0), m_mass(0), m_px(0), m_py(0), m_pz(0), m_x(0), m_y(0), m_z(0),
  m_pValue(-1), m_flavorType(c_Unflavored), m_particleSource(c_Undefined), m_mdstIndex(0), m_properties(0), m_arrayPointer(nullptr)
{
  if (!klmCluster) return;
 
  m_pdgCode = pdgCode;
  setFlavorType();
 
  set4Vector(klmCluster->getMomentum());
  setVertex(XYZVector(0, 0, 0)); // so far KLMCluster don't provide reliable / usable position information
  updateMass(m_pdgCode); // KLMCluster internally use Klong mass, overwrite here to allow neutrons
 
  m_particleSource = c_KLMCluster;
  setMdstArrayIndex(klmCluster->getArrayIndex());
 
  // set Chi^2 probability:
  //TODO: KL quality can be written here
  m_pValue = -1;
 
  // TODO: set error matrix
  resetErrorMatrix();
  //storeErrorMatrix(klmCluster->getErrorMatrix());
}

◆ Particle() [11/11]

Particle ( const MCParticle * MCparticle )

explicit

Constructor from MC particle (mdst object MCParticle)

Parameters

MCparticle pointer to MCParticle object

Definition at line 321 of file Particle.cc.

                                               :
  m_pdgCode(0), m_mass(0), m_px(0), m_py(0), m_pz(0), m_x(0), m_y(0), m_z(0),
  m_pValue(-1), m_flavorType(c_Unflavored), m_particleSource(c_Undefined), m_mdstIndex(0), m_properties(0), m_arrayPointer(nullptr)
{
  if (!mcParticle) return;
 
  m_pdgCode      = mcParticle->getPDG();
  m_particleSource = c_MCParticle; // TODO: what about daughters if not FS particle?
 
  setMdstArrayIndex(mcParticle->getArrayIndex());
 
 
  setFlavorType();
 
  // mass and momentum
  m_mass = mcParticle->getMass();
  m_px = mcParticle->getMomentum().X();
  m_py = mcParticle->getMomentum().Y();
  m_pz = mcParticle->getMomentum().Z();
  // production vertex
  // TODO: good only for FS particles, for composite we must use decay vertex
  setVertex(mcParticle->getVertex());
 
  resetErrorMatrix();
}

Member Function Documentation

◆ addExtraInfo()

void addExtraInfo	(	const std::string &	name,
		double	value
	)

Sets the user-defined data of given name to the given value.

throws std::runtime_error if variable is already set.

Definition at line 1336 of file Particle.cc.

{
  if (hasExtraInfo(name))
    throw std::runtime_error(std::string("addExtraInfo: Value '") + name + "' already set!");
 
  StoreObjPtr<ParticleExtraInfoMap> extraInfoMap;
  if (!extraInfoMap)
    extraInfoMap.create();
  if (m_extraInfo.empty()) {
    unsigned int mapID = extraInfoMap->getMapForNewVar(name);
    m_extraInfo.push_back(mapID);
    m_extraInfo.push_back(value);
  } else {
    unsigned int oldMapID = m_extraInfo[0];
    unsigned int insertIndex = m_extraInfo.size();
    unsigned int mapID = extraInfoMap->getMapForNewVar(name, oldMapID, insertIndex);
 
    m_extraInfo[0] = mapID; //update map
    m_extraInfo.push_back(value); //add value
  }
}

◆ addRelationTo() [1/2]

void addRelationTo	(	const RelationsInterface< BASE > *	object,
		float	weight = `1.0`,
		const std::string &	namedRelation = `""`
	)		const

inlineinherited

Add a relation from this object to another object (with caching).

Parameters

object	The object to which the relation should point.
weight	The weight of the relation.
namedRelation	Additional name for the relation, or "" for the default naming

Definition at line 142 of file RelationsObject.h.

    {
      if (object)
        DataStore::Instance().addRelation(this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                                          object, object->m_cacheDataStoreEntry, object->m_cacheArrayIndex, weight, namedRelation);
    }

◆ addRelationTo() [2/2]

void addRelationTo	(	const TObject *	object,
		float	weight = `1.0`,
		const std::string &	namedRelation = `""`
	)		const

inlineinherited

Add a relation from this object to another object (no caching, can be quite slow).

Parameters

object	The object to which the relation should point.
weight	The weight of the relation.
namedRelation	Additional name for the relation, or "" for the default naming

Definition at line 155 of file RelationsObject.h.

    {
      StoreEntry* toEntry = nullptr;
      int toIndex = -1;
      DataStore::Instance().addRelation(this, m_cacheDataStoreEntry, m_cacheArrayIndex, object, toEntry, toIndex, weight, namedRelation);
    }

◆ appendDaughter() [1/2]

void appendDaughter	(	const Particle *	daughter,
		const bool	updateType = `true`,
		const int	daughterProperty = `c_Ordinary`
	)

Appends index of daughter to daughters index array.

Parameters

daughter	pointer to the daughter particle
updateType	bool to set whether particle type should be updated
daughterProperty	property of the daughter particle

Definition at line 676 of file Particle.cc.

{
  if (updateType) {
    // is it a composite particle or fsr corrected?
    m_particleSource = c_Composite;
  }
 
  // add daughter index
  m_daughterIndices.push_back(daughter->getArrayIndex());
  m_daughterProperties.push_back(daughterProperty);
}

◆ appendDaughter() [2/2]

void appendDaughter	(	int	particleIndex,
		const bool	updateType = `true`
	)

inline

Appends index of daughter to daughters index array.

Parameters

particleIndex	index of daughter in StoreArray<Particle>
updateType	bool to set whether particle type should be updated

Definition at line 416 of file Particle.h.

    {
      if (updateType) {
        // is it a composite particle or fsr corrected?
        m_particleSource = c_Composite;
      }
      m_daughterIndices.push_back(particleIndex);
      m_daughterProperties.push_back(c_Ordinary);
    }

◆ copyRelations()

void copyRelations ( const RelationsInterface< BASE > * sourceObj )

inlineinherited

Copies all relations of sourceObj (pointing from or to sourceObj) to this object (including weights).

Useful if you want to make a complete copy of a StoreArray object to make modifications to it, but retain all information on linked objects.

Note: this only works if sourceObj inherits from the same base (e.g. RelationsObject), and only for related objects that also inherit from the same base.

Definition at line 170 of file RelationsObject.h.

    {
      if (!sourceObj)
        return;
      auto fromRels = sourceObj->getRelationsFrom<RelationsInterface<BASE>>("ALL");
      for (unsigned int iRel = 0; iRel < fromRels.size(); iRel++) {
        fromRels.object(iRel)->addRelationTo(this, fromRels.weight(iRel));
      }
 
      auto toRels = sourceObj->getRelationsTo<RelationsInterface<BASE>>("ALL");
      for (unsigned int iRel = 0; iRel < toRels.size(); iRel++) {
        this->addRelationTo(toRels.object(iRel), toRels.weight(iRel));
      }
    }

◆ fillAllDaughters()

void fillAllDaughters ( std::vector< const Belle2::Particle * > & allDaughters ) const

Fill all generations' daughters into a vector.

Function is called recursively

Parameters

allDaughters vector of daughter particles

Definition at line 1127 of file Particle.cc.

{
  // this is FSP
  if (getNDaughters() == 0)
    return;
 
  // this is not FSP (fill it and go one level down)
  for (unsigned i = 0; i < getNDaughters(); i++) {
    allDaughters.push_back(getDaughter(i));
    getDaughter(i)->fillAllDaughters(allDaughters);
  }
}

◆ fillDecayChain()

void fillDecayChain ( std::vector< int > & decayChain ) const

private

Fill vector with (PDGCode, MdstSource) pairs for the entire decay chain.

Used to determine if two Particles are copies or not.

Function is called recursively

Parameters

decayChain vector of (PDGCode, MdstSource) pairs for each particle in the decay chain of this particle

Definition at line 1140 of file Particle.cc.

{
  decayChain.push_back(m_pdgCode);
  decayChain.push_back(getMdstSource());
 
  for (unsigned i = 0; i < getNDaughters(); i++)
    getDaughter(i)->fillDecayChain(decayChain);
}

◆ fillFSPDaughters()

void fillFSPDaughters ( std::vector< const Belle2::Particle * > & fspDaughters ) const

Fill final state particle daughters into a vector.

Function is called recursively

Parameters

fspDaughters vector of daughter particles

Definition at line 1114 of file Particle.cc.

{
  // this is FSP
  if (getNDaughters() == 0) {
    fspDaughters.push_back(this);
    return;
  }
 
  // this is not FSP (go one level down)
  for (unsigned i = 0; i < getNDaughters(); i++)
    getDaughter(i)->fillFSPDaughters(fspDaughters);
}

◆ forEachDaughter()

bool forEachDaughter	(	const std::function< bool(const Particle *)> &	function,
		bool	recursive = `true`,
		bool	includeSelf = `true`
	)		const

Apply a function to all daughters of this particle.

Parameters

function	function object to run on each daughter. If this function returns true the processing will be stopped immediately.
recursive	if true go through all daughters of daughters as well
includeSelf	if true also apply the function to this particle

Returns: true if the function returned true for any of the particles it was applied to

Definition at line 1358 of file Particle.cc.

{
  std::queue<const Particle*> qq;
  // If we include ourselves add only this, otherwise directly all children
  if (includeSelf) {
    qq.push(this);
  } else {
    for (size_t i = 0; i < getNDaughters(); ++i) qq.push(getDaughter(i));
  }
  // Now just repeat until done: take the child, run the functor, remove the
  // child, add all children if needed
  while (!qq.empty()) {
    const Particle* p = qq.front();
    if (function(p)) return true;
    qq.pop();
    // Add children if we go through all children recursively or if we look at
    // the current particle: we always want the direct children.
    if (recursive || p == this)
      for (size_t i = 0; i < p->getNDaughters(); ++i) qq.push(p->getDaughter(i));
  }
  return false;
}

◆ generatePDGCodeFromCharge()

int generatePDGCodeFromCharge	(	const int	chargedSign,
		const Const::ChargedStable &	chargedStable
	)

private

Generate the PDG code with correct sign, using the charge.

Parameters

chargedSign	charge of the particle
chargedStable	Type of charged particle

Definition at line 1382 of file Particle.cc.

{
  int absPDGCode = chargedStable.getPDGCode();
  int PDGCode = absPDGCode * chargeSign;
  // flip sign of PDG code for leptons: their PDG code is positive if the lepton charge is negative and vice versa
  if (chargedStable == Const::muon || chargedStable == Const::electron) PDGCode = -PDGCode;
  return PDGCode;
}

◆ get4Vector()

ROOT::Math::PxPyPzEVector get4Vector ( ) const

inline

Returns Lorentz vector.

Returns: Lorentz vector

Definition at line 547 of file Particle.h.

    {
      double correction = getMomentumLossCorrectionFactor();
      return ROOT::Math::PxPyPzEVector(m_momentumScale * correction * m_px,
                                       m_momentumScale * correction * m_py,
                                       m_momentumScale * correction * m_pz,
                                       getEnergy());
    }

◆ getAcoplanarity()

double getAcoplanarity ( ) const

Returns acoplanarity angle defined as the angle between the decay planes of the grand daughters in the particle's rest frame This assumes that the particle and its daughters have two daughters each.

Returns: acoplanarity angle

Definition at line 533 of file Particle.cc.

{
  // check that we have a decay to two daughters and then two grand daughters each
  if (getNDaughters() != 2) {
    B2ERROR("Cannot calculate acoplanarity of particle 'name' because the number of daughters is not 2"
            << LogVar("name", getName()) << LogVar("# of daughters", getNDaughters()));
    return std::numeric_limits<double>::quiet_NaN();
  }
  const Particle* daughter0 = getDaughter(0);
  const Particle* daughter1 = getDaughter(1);
  if ((daughter0->getNDaughters() != 2) || (daughter1->getNDaughters() != 2)) {
    B2ERROR("Cannot calculate acoplanarity of particle 'name' because the number of grand daughters is not 2"
            << LogVar("name", getName()) << LogVar("# of grand daughters of first daughter", daughter0->getNDaughters())
            << LogVar("# of grand daughters of second daughter", daughter1->getNDaughters()));
    return std::numeric_limits<double>::quiet_NaN();
  }
 
  // boost vector to the rest frame of the particle
  Boost boost(get4Vector().BoostToCM());
 
  // momenta of the daughters and grand daughters in the particle's rest frame
  PxPyPzEVector pDaughter0 = boost * daughter0->get4Vector();
  PxPyPzEVector pGrandDaughter0 = boost * daughter0->getDaughter(0)->get4Vector();
  PxPyPzEVector pDaughter1 = boost * daughter1->get4Vector();
  PxPyPzEVector pGrandDaughter1 = boost * daughter1->getDaughter(0)->get4Vector();
 
  // calculate angle between normal vectors
  XYZVector normal0 = pDaughter0.Vect().Cross(pGrandDaughter0.Vect());
  XYZVector normal1 = -pDaughter1.Vect().Cross(pGrandDaughter1.Vect());
  double result = acos(normal0.Unit().Dot(normal1.Unit()));
  if (normal0.Cross(normal1).Dot(pDaughter0.Vect()) < 0) result = -result;
 
  return result;
}

◆ getAllDaughters()

std::vector< const Belle2::Particle * > getAllDaughters ( ) const

Returns a vector of pointers to all generations' daughter particles.

Returns: vector of pointers to all generations' daughter particles

Definition at line 657 of file Particle.cc.

{
  std::vector<const Particle*> allDaughters;
  fillAllDaughters(allDaughters);
 
  return allDaughters;
}

◆ getArrayIndex()

int getArrayIndex ( ) const

inlineinherited

Returns this object's array index (in StoreArray), or -1 if not found.

Definition at line 385 of file RelationsObject.h.

    {
      DataStore::Instance().findStoreEntry(this, m_cacheDataStoreEntry, m_cacheArrayIndex);
      return m_cacheArrayIndex;
    }

◆ getArrayName()

std::string getArrayName ( ) const

inlineinherited

Get name of array this object is stored in, or "" if not found.

Definition at line 377 of file RelationsObject.h.

    {
      DataStore::Instance().findStoreEntry(this, m_cacheDataStoreEntry, m_cacheArrayIndex);
      return m_cacheDataStoreEntry ? m_cacheDataStoreEntry->name : "";
    }

◆ getArrayPointer()

TClonesArray * getArrayPointer ( ) const

inline

Returns the pointer to the store array which holds the daughter particles.

Warning: TClonesArray is dangerously easy to misuse, please avoid.

Definition at line 953 of file Particle.h.

    {
      if (!m_arrayPointer)
        m_arrayPointer = RelationsObject::getArrayPointer();
      return m_arrayPointer;
    }

◆ getCharge()

double getCharge ( void ) const

Returns particle charge.

Returns: particle charge in units of elementary charge

Definition at line 622 of file Particle.cc.

{
  if (TDatabasePDG::Instance()->GetParticle(m_pdgCode) == nullptr) {
    B2ERROR("PDG=" << m_pdgCode << " ***code unknown to TDatabasePDG");
    return 0.0;
  }
  return TDatabasePDG::Instance()->GetParticle(m_pdgCode)->Charge() / 3.0;
}

◆ getCosHelicity()

double getCosHelicity ( const Particle * mother = nullptr ) const

Returns cosine of the helicity angle The helicity angle is defined in the rest frame of the particle as the angle between the negative momentum of the mother and.

the momentum of the first daughter for two body decays
the momentum of the photon for pi0 Dalitz decays
the direction perpendicular to the daughter momenta for three body decays
Parameters

mother mother particle, if not given the center of mass system is taken as mother frame

Returns
cosine of the helicity angle

Definition at line 459 of file Particle.cc.

{
  // boost vector to the rest frame of the particle
  Boost boost(get4Vector().BoostToCM());
 
  // momentum of the mother in the particle's rest frame
  PxPyPzEVector pMother;
  if (mother) {
    pMother = mother->get4Vector();
  } else {
    static DBObjPtr<CollisionBoostVector> cmsBoost;
    static DBObjPtr<CollisionInvariantMass> cmsMass;
    pMother.SetE(cmsMass->getMass());
    pMother = Boost(cmsBoost->getBoost()) * pMother;
  }
  pMother = boost * pMother;
 
  // momentum of the daughter (or normal vector) in the particle's rest frame
  PxPyPzEVector pDaughter;
  if (getNDaughters() == 2) {  // two body decay
    pDaughter = boost * getDaughter(0)->get4Vector();
  } else if (getNDaughters() == 3) {
    if (getPDGCode() == Const::pi0.getPDGCode()) {  // pi0 Dalitz decay
      for (auto& daughter : getDaughters()) {
        if (daughter->getPDGCode() == Const::photon.getPDGCode()) {
          pDaughter = daughter->get4Vector();
        }
      }
      pDaughter = boost * pDaughter;
    } else {  // three body decay
      PxPyPzEVector pDaughter0 = boost * getDaughter(0)->get4Vector();
      PxPyPzEVector pDaughter1 = boost * getDaughter(1)->get4Vector();
 
      XYZVector pDaughterNormal(pDaughter0.Vect().Cross(pDaughter1.Vect()));
      pDaughter.SetPxPyPzE(pDaughterNormal.X(), pDaughterNormal.Y(), pDaughterNormal.Z(), 0); // energy doesn't matter
    }
  }
 
  double mag2 = pMother.P2() * pDaughter.P2();
  if (mag2 <= 0) return std::numeric_limits<double>::quiet_NaN();
  return -pMother.Vect().Dot(pDaughter.Vect()) / sqrt(mag2);
}

◆ getCosHelicityDaughter()

double getCosHelicityDaughter	(	unsigned	iDaughter,
		unsigned	iGrandDaughter = `0`
	)		const

Returns cosine of the helicity angle of the given daughter defined by given grand daughter.

Parameters

iDaughter	0-based index of daughter particle
iGrandDaughter	0-based index of grand daughter particle

Returns: cosine of the helicity angle

Definition at line 502 of file Particle.cc.

{
  // check existence of daughter
  if (getNDaughters() <= iDaughter) {
    B2ERROR("No daughter of particle 'name' with index 'iDaughter' for calculation of helicity angle"
            << LogVar("name", getName()) << LogVar("iDaughter", iDaughter));
    return std::numeric_limits<double>::quiet_NaN();
  }
 
  // boost vector to the rest frame of the daughter particle
  const Particle* daughter = getDaughter(iDaughter);
  Boost boost(daughter->get4Vector().BoostToCM());
 
  // momentum of the this particle in the daughter's rest frame
  PxPyPzEVector pMother = boost * get4Vector();
 
  // check existence of grand daughter
  if (daughter->getNDaughters() <= iGrandDaughter) {
    B2ERROR("No grand daughter of daughter 'iDaughter' of particle 'name' with index 'iGrandDaughter' for calculation of helicity angle"
            << LogVar("name", getName()) << LogVar("iDaughter", iDaughter) << LogVar("iGrandDaughter", iGrandDaughter));
    return std::numeric_limits<double>::quiet_NaN();
  }
 
  // momentum of the grand daughter in the daughter's rest frame
  PxPyPzEVector pGrandDaughter = boost * daughter->getDaughter(iGrandDaughter)->get4Vector();
 
  double mag2 = pMother.P2() * pGrandDaughter.P2();
  if (mag2 <= 0) return std::numeric_limits<double>::quiet_NaN();
  return -pMother.Vect().Dot(pGrandDaughter.Vect()) / sqrt(mag2);
}

◆ getDaughter()

const Particle * getDaughter ( unsigned i ) const

Returns a pointer to the i-th daughter particle.

Parameters

i	0-based index of daughter particle

Returns: Pointer to i-th daughter particles

Definition at line 631 of file Particle.cc.

{
  if (i >= getNDaughters()) return nullptr;
  return static_cast<Particle*>(getArrayPointer()->At(m_daughterIndices[i]));
}

◆ getDaughterIndices()

const std::vector< int > & getDaughterIndices ( ) const

inline

Returns a vector of store array indices of daughter particles.

Returns: vector of store array indices of daughter particle

Definition at line 736 of file Particle.h.

    {
      return m_daughterIndices;
    }

◆ getDaughterProperties()

const std::vector< int > & getDaughterProperties ( ) const

inline

Returns a vector of properties of daughter particles.

Returns: vector of daughter properties

Definition at line 745 of file Particle.h.

    {
      return m_daughterProperties;
    }

◆ getDaughters()

std::vector< Belle2::Particle * > getDaughters ( ) const

Returns a vector of pointers to daughter particles.

Returns: vector of pointers to daughter particles

Definition at line 637 of file Particle.cc.

{
  const unsigned int nDaughters = getNDaughters();
  std::vector<Particle*> daughters(nDaughters);
 
  const TClonesArray* array = getArrayPointer();
  for (unsigned i = 0; i < nDaughters; i++)
    daughters[i] = static_cast<Particle*>(array->At(m_daughterIndices[i]));
 
  return daughters;
}

◆ getECLCluster()

const ECLCluster * getECLCluster ( ) const

Returns the pointer to the ECLCluster object that was used to create this Particle (if ParticleType == c_ECLCluster).

Returns the pointer to the most energetic ECLCluster matched to the track (if ParticleType == c_Track). NULL pointer is returned, if the Particle has no relation to an ECLCluster (either the particle is a different type or there was no track match).

Returns: const pointer to the ECLCluster

Definition at line 891 of file Particle.cc.

{
  if (m_particleSource == c_ECLCluster) {
    StoreArray<ECLCluster> eclClusters{};
    return eclClusters[m_mdstIndex];
  } else if (m_particleSource == c_Track) {
    // a track may be matched to several clusters under different hypotheses
    // take the most energetic of the c_nPhotons hypothesis as "the" cluster
    StoreArray<Track> tracks{};
    const ECLCluster* bestTrackMatchedCluster = nullptr;
    double highestEnergy = -1.0;
    // loop over all clusters matched to this track
    for (const ECLCluster& cluster : tracks[m_mdstIndex]->getRelationsTo<ECLCluster>()) {
      // ignore everything except the nPhotons hypothesis
      if (!cluster.hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons))
        continue;
      // check if we're most energetic thus far
      if (cluster.getEnergy(ECLCluster::EHypothesisBit::c_nPhotons) > highestEnergy) {
        highestEnergy = cluster.getEnergy(ECLCluster::EHypothesisBit::c_nPhotons);
        bestTrackMatchedCluster = &cluster;
      }
    }
    return bestTrackMatchedCluster;
  } else {
    return nullptr;
  }
}

◆ getECLClusterEHypothesisBit()

ECLCluster::EHypothesisBit getECLClusterEHypothesisBit ( ) const

inline

Returns the ECLCluster EHypothesisBit for this Particle.

Definition at line 1001 of file Particle.h.

    {
      const int pdg = abs(getPDGCode());
      if ((pdg == Const::photon.getPDGCode())
          or (pdg == Const::electron.getPDGCode())
          or (pdg == Const::muon.getPDGCode())
          or (pdg == Const::pion.getPDGCode())
          or (pdg == Const::kaon.getPDGCode())
          or (pdg == Const::proton.getPDGCode())
          or (pdg == Const::deuteron.getPDGCode())) {
        return ECLCluster::EHypothesisBit::c_nPhotons;
      } else if ((pdg == Const::Klong.getPDGCode())
                 or (pdg == Const::neutron.getPDGCode())) {
        return ECLCluster::EHypothesisBit::c_neutralHadron;
      } else {
        return ECLCluster::EHypothesisBit::c_none;
      }
    }

◆ getECLClusterEnergy()

double getECLClusterEnergy ( ) const

Returns the energy of the ECLCluster for the particle.

The return value depends on the ECLCluster hypothesis.

Returns: energy of the ECLCluster

Definition at line 919 of file Particle.cc.

{
  const ECLCluster* cluster = this->getECLCluster();
  if (!cluster) return 0;
  return cluster->getEnergy(this->getECLClusterEHypothesisBit());
}

◆ getEffectiveMomentumScale()

double getEffectiveMomentumScale ( ) const

inline

Returns effective momentum scale which is the product of the momentum scaling and smearing factors.

Returns: momentum scaling factor

Definition at line 614 of file Particle.h.

    {
      return m_momentumScale;
    }

◆ getEnergy()

double getEnergy ( ) const

inline

Returns total energy.

Returns: total energy

Definition at line 535 of file Particle.h.

    {
      return sqrt(m_momentumScale * m_momentumScale * m_px * m_px +
                  m_momentumScale * m_momentumScale * m_py * m_py +
                  m_momentumScale * m_momentumScale * m_pz * m_pz +
                  m_mass * m_mass) - m_energyLossCorrection;
    }

◆ getEnergyLossCorrection()

double getEnergyLossCorrection ( ) const

inline

Returns Energy Loss Correction.

Returns: Energy Loss Correction

Definition at line 623 of file Particle.h.

    {
      return m_energyLossCorrection;
    }

◆ getExtraInfo()

double getExtraInfo ( const std::string & name ) const

Return given value if set.

throws std::runtime_error if variable is not set.

Definition at line 1289 of file Particle.cc.

{
  if (m_extraInfo.empty())
    throw std::runtime_error(std::string("getExtraInfo: Value '") + name + "' not found in Particle!");
 
  //get index for name
  const auto mapID = (unsigned int)m_extraInfo[0];
  StoreObjPtr<ParticleExtraInfoMap> extraInfoMap;
  if (!extraInfoMap) {
    B2FATAL("ParticleExtraInfoMap not available, but needed for storing extra info in Particle!");
  }
  unsigned int index = extraInfoMap->getIndex(mapID, name);
  if (index == 0 or index >= m_extraInfo.size()) //actually indices start at 1
    throw std::runtime_error(std::string("getExtraInfo: Value '") + name + "' not found in Particle!");
 
  return m_extraInfo[index];
 
}

◆ getExtraInfoMap()

int getExtraInfoMap ( ) const

inline

Return the id of the associated ParticleExtraInfoMap or -1 if no map is set.

Definition at line 921 of file Particle.h.

    {
      return !m_extraInfo.empty() ? m_extraInfo[0] : -1;
    }

◆ getExtraInfoNames()

std::vector< std::string > getExtraInfoNames ( ) const

get a list of the extra info names

Definition at line 1175 of file Particle.cc.

{
  std::vector<std::string> out;
  if (!m_extraInfo.empty()) {
    StoreObjPtr<ParticleExtraInfoMap> extraInfoMap;
    if (!extraInfoMap)
      B2FATAL("ParticleExtraInfoMap not available, but needed for storing extra info in Particle!");
    const ParticleExtraInfoMap::IndexMap& map = extraInfoMap->getMap(m_extraInfo[0]);
    for (auto const& ee : map) out.push_back(ee.first);
  }
  return out;
}

◆ getExtraInfoSize()

unsigned int getExtraInfoSize ( ) const

inline

Return the size of the extra info array.

Definition at line 927 of file Particle.h.

    {
      return m_extraInfo.size();
    }

◆ getFinalStateDaughters()

std::vector< const Belle2::Particle * > getFinalStateDaughters ( ) const

Returns a vector of pointers to Final State daughter particles.

Returns: vector of pointers to final state daughter particles

Definition at line 649 of file Particle.cc.

{
  std::vector<const Particle*> fspDaughters;
  fillFSPDaughters(fspDaughters);
 
  return fspDaughters;
}

◆ getFlavorType()

EFlavorType getFlavorType ( ) const

inline

Returns flavor type of the decay (for FS particles: flavor type of particle)

Returns: flavor type (0=unflavored, 1=flavored)

Definition at line 469 of file Particle.h.

    {
      return m_flavorType;
    }

◆ getInfo()

std::string getInfo ( ) const

inlineinherited

Return a short summary of this object's contents in raw text format.

Returns the contents of getInfoHTML() while translating line-breaks etc.

Note: : You don't need to implement this function (it's not virtual), getInfoHTML() is enough.

Definition at line 370 of file RelationsObject.h.

    {
      return _RelationsInterfaceImpl::htmlToPlainText(getInfoHTML());
    }

◆ getInfoHTML()

std::string getInfoHTML ( ) const

overridevirtual

Return a short summary of this object's contents in HTML format.

Reimplemented from RelationsInterface< BASE >.

Definition at line 1188 of file Particle.cc.

{
  std::stringstream stream;
  stream << std::setprecision(4);
  stream << "<b>collection</b>=" << getArrayName();
  stream << "<br>";
  stream << " <b>PDGCode</b>=" << m_pdgCode;
  stream << " <b>Charge</b>=" << getCharge();
  stream << " <b>PDGMass</b>=" << getPDGMass();
  stream << "<br>";
  stream << " <b>flavorType</b>=" << m_flavorType;
  stream << " <b>particleSource</b>=" << m_particleSource;
  stream << " <b>particleTypeUsedForFit</b>=" << m_pdgCodeUsedForFit;
  stream << "<br>";
 
  stream << " <b>mdstIndex</b>=" << m_mdstIndex;
  stream << " <b>arrayIndex</b>=" << getArrayIndex();
  stream << " <b>identifier</b>=" << m_identifier;
  stream << " <b>daughterIndices</b>: ";
  for (int daughterIndex : m_daughterIndices) {
    stream << daughterIndex << ", ";
  }
  if (m_daughterIndices.empty()) stream << " (none)";
  stream << "<br>";
 
  if (!m_daughterIndices.empty()) {
    stream << " <b>daughter PDGCodes</b>: ";
    for (unsigned i = 0; i < m_daughterIndices.size(); i++) {
      const Particle* p = getDaughter(i);
      if (p) {stream << p->getPDGCode() << ", ";}
      else {stream << "?, ";}
    }
    stream << "<br>";
  }
 
  stream << " <b>mass</b>=" << m_mass;
  stream << "<br>";
 
  stream << " <b>momentum</b>=" << HTML::getString(ROOT::Math::XYZVector(getPx(), getPy(), getPz()));
  stream << " <b>p</b>=" << getP();
  stream << "<br>";
 
  stream << " <b>momentum scaling factor</b>=" << m_momentumScale;
  stream << "<br>";
 
  stream << " <b>Energy loss correction</b>=" << m_energyLossCorrection;
  stream << "<br>";
 
  stream << " <b>position</b>=" << HTML::getString(ROOT::Math::XYZVector(m_x, m_y, m_z));
  stream << "<br>";
 
  stream << " <b>p-value of fit</b> (if done): ";
  stream << m_pValue;
  stream << "<br>";
 
  stream << " <b>error matrix</b> (px, py, pz, E, x, y ,z):<br>";
  stream << HTML::getString(getMomentumVertexErrorMatrix());
 
  stream << " <b>extra info</b>=( ";
  if (!m_extraInfo.empty()) {
    StoreObjPtr<ParticleExtraInfoMap> extraInfoMap;
    if (!extraInfoMap) {
      B2FATAL("ParticleExtraInfoMap not available, but needed for storing extra info in Particle!");
    }
    const ParticleExtraInfoMap::IndexMap& map = extraInfoMap->getMap(m_extraInfo[0]);
    const unsigned int nVars = m_extraInfo.size();
    for (const auto& pair : map) {
      if (pair.second < nVars) {
        stream << pair.first << "=" << m_extraInfo[pair.second] << " ";
      }
    }
 
  }
  stream << ") " << "<br>";
 
  return stream.str();
}

◆ getKLMCluster()

const KLMCluster * getKLMCluster ( ) const

Returns the pointer to the KLMCluster object that was used to create this Particle (ParticleType == c_KLMCluster).

Returns the pointer to the KLMCluster object associated to this Particle if ParticleType == c_Track. NULL pointer is returned, if the Particle has no relation to the KLMCluster.

Returns: const pointer to the KLMCluster

Definition at line 926 of file Particle.cc.

{
  if (m_particleSource == c_KLMCluster) {
    StoreArray<KLMCluster> klmClusters{};
    return klmClusters[m_mdstIndex];
  } else if (m_particleSource == c_Track) {
    // If there is an associated KLMCluster, it's the closest one
    StoreArray<Track> tracks{};
    const KLMCluster* klmCluster = tracks[m_mdstIndex]->getRelatedTo<KLMCluster>();
    return klmCluster;
  } else {
    return nullptr;
  }
}

◆ getMass()

double getMass ( ) const

inline

Returns invariant mass (= nominal for FS particles)

Returns: invariant mass

Definition at line 507 of file Particle.h.

    {
      return m_mass;
    }

◆ getMCParticle()

const MCParticle * getMCParticle ( ) const

Returns the pointer to the MCParticle object that was used to create this Particle (ParticleType == c_MCParticle).

Returns the best MC match for this particle (if ParticleType == c_Track or c_ECLCluster or c_KLMCluster) NULL pointer is returned, if the Particle was not made from MCParticle or not matched.

Returns: const pointer to the MCParticle

Definition at line 942 of file Particle.cc.

{
  if (m_particleSource == c_MCParticle) {
    StoreArray<MCParticle> mcParticles{};
    return mcParticles[m_mdstIndex];
  } else {
    const MCParticle* related = this->getRelated<MCParticle>();
    if (related)
      return related;
  }
  return nullptr;
}

◆ getMdstArrayIndex()

unsigned getMdstArrayIndex ( void ) const

inline

Returns 0-based index of MDST store array object (0 for composite particles)

Returns: index of MDST store array object

Definition at line 487 of file Particle.h.

    {
      return m_mdstIndex;
    }

◆ getMdstArrayIndices()

std::vector< int > getMdstArrayIndices ( EParticleSourceObject type ) const

Returns a vector of StoreArray indices of given MDST dataobjects.

Parameters

type	EParticleSourceObject corresponding to a given MDST dataobject

Returns: vector of StoreArray indices of a given MDST dataobjects

Definition at line 665 of file Particle.cc.

{
  std::vector<int> mdstIndices;
  for (const Particle* fsp : getFinalStateDaughters()) {
    // is this FSP daughter constructed from given MDST source
    if (fsp->getParticleSource() == source)
      mdstIndices.push_back(fsp->getMdstArrayIndex());
  }
  return mdstIndices;
}

◆ getMdstSource()

int getMdstSource ( ) const

Returns unique identifier of final state particle (needed in particle combiner)

Returns: unique identifier of final state particle

Definition at line 369 of file Particle.cc.

{
  // Is identifier already set
  if (m_identifier > -1)
    return m_identifier + (m_particleSource << 24);
 
  // Identifier is not set.
  int identifier = 0;
  if (m_particleSource == c_ECLCluster) {
    const ECLCluster* cluster = this->getECLCluster();
    if (cluster) {
      identifier = cluster->getUniqueClusterId();
    } else {
      B2ERROR("Particle is of type = ECLCluster has identifier not set and no relation to ECLCluster.\n"
              "This has happen because old microDST is analysed with newer version of software.");
    }
  } else {
    identifier = m_mdstIndex;
  }
 
  return identifier + (m_particleSource << 24);
}

◆ getMomentum()

ROOT::Math::XYZVector getMomentum ( ) const

inline

Returns momentum vector.

Returns: momentum vector

Definition at line 560 of file Particle.h.

    {
      return m_momentumScale * getMomentumLossCorrectionFactor() * ROOT::Math::XYZVector(m_px, m_py, m_pz);
    };

◆ getMomentumErrorMatrix()

TMatrixFSym getMomentumErrorMatrix ( ) const

Returns the 4x4 momentum error matrix.

Returns: The 4x4 momentum error matrix (order: px,py,pz,E)

Definition at line 435 of file Particle.cc.

{
  TMatrixFSym mom;
  const TMatrixFSym& full = getMomentumVertexErrorMatrix();
 
  // get 4x4 (momentum) submatrix from the full error matrix
  // momentum related elements are in [0,...,3]x[0,...,3] block
  full.GetSub(0, 3, mom, "S");
 
  return mom;
}

◆ getMomentumLossCorrectionFactor()

double getMomentumLossCorrectionFactor ( ) const

inline

Returns effect of energy correction on the particle momentum.

Returns: momentum change

Definition at line 315 of file Particle.h.

    {
      if (m_energyLossCorrection == 0.0) {
        return 1.0;
      }
      double origP = m_momentumScale * sqrt(m_px * m_px + m_py * m_py + m_pz * m_pz);
      if (origP == 0.0) {
        return 1.0;
      }
      double origE = sqrt(origP * origP + m_mass * m_mass);
 
      double newP = sqrt((origE - m_energyLossCorrection) * (origE - m_energyLossCorrection) - m_mass * m_mass);
      return newP / origP;
    }

◆ getMomentumMagnitude()

double getMomentumMagnitude ( ) const

inline

Returns momentum magnitude.

Returns: momentum magnitude

Definition at line 569 of file Particle.h.

    {
      return getP();
    };

◆ getMomentumVertexErrorMatrix()

TMatrixFSym getMomentumVertexErrorMatrix ( ) const

Returns 7x7 error matrix.

Returns: 7x7 error matrix (order: px,py,pz,E,x,y,z)

Definition at line 420 of file Particle.cc.

{
  TMatrixFSym m(c_DimMatrix);
 
  int element = 0;
  for (int irow = 0; irow < c_DimMatrix; irow++) {
    for (int icol = irow; icol < c_DimMatrix; icol++) {
      m(irow, icol) = m(icol, irow) = m_errMatrix[element];
      element++;
    }
  }
  return m;
}

◆ getMostLikelyTrackFitResult()

std::pair< Const::ChargedStable, const TrackFitResult * > getMostLikelyTrackFitResult ( ) const

For a (track-based) particle, returns the charged stable mass hypothesis associated to the most probable TrackFitResult, and the TrackFitResult itself.

Definition at line 1398 of file Particle.cc.

{
 
  const auto track = this->getTrack();
 
  if (!track) {
    return std::make_pair(Const::ChargedStable(std::abs(this->getPDGCode())), nullptr);
  }
 
  // Find the track fit with the highest pValue
  auto trackFitResults = track->getTrackFitResults();
  auto it_maxPValue = std::max_element(std::begin(trackFitResults), std::end(trackFitResults),
  [](auto tfrAndM1, auto tfrAndM2) {return tfrAndM1.second->getPValue() < tfrAndM2.second->getPValue();});
 
  return trackFitResults[std::distance(std::begin(trackFitResults), it_maxPValue)];
 
}

◆ getName()

std::string getName ( ) const

overridevirtual

Return name of this particle.

Reimplemented from RelationsInterface< BASE >.

Definition at line 1165 of file Particle.cc.

{
  return TDatabasePDG::Instance()->GetParticle(m_pdgCode)->GetName();
}

◆ getNDaughters()

unsigned getNDaughters ( void ) const

inline

Returns number of daughter particles.

Returns: number of daughter particles

Definition at line 727 of file Particle.h.

    {
      return m_daughterIndices.size();
    }

◆ getP()

double getP ( ) const

inline

Returns momentum magnitude (same as getMomentumMagnitude but with shorter name)

Returns: momentum magnitude

Definition at line 578 of file Particle.h.

    {
      return m_momentumScale * getMomentumLossCorrectionFactor() * sqrt(m_px * m_px + m_py * m_py + m_pz * m_pz);
    };

◆ getParticleFromGeneralizedIndexString()

const Particle * getParticleFromGeneralizedIndexString ( const std::string & generalizedIndex ) const

Explores the decay tree of the particle and returns the (grand^n)daughter identified by a generalized index.

The generalized index consists of a colon-separated list of daughter indexes, starting from the root particle: 0:1:3 identifies the fourth daughter (3) of the second daughter (1) of the first daughter (0) of the mother particle.

Parameters

generalizedIndex the generalized index of the particle to be returned

Returns: a particle in the decay tree of the root particle.

Definition at line 956 of file Particle.cc.

{
  // Split the generalizedIndex string in a vector of strings.
  std::vector<std::string> generalizedIndexes;
  boost::split(generalizedIndexes, generalizedIndex, boost::is_any_of(":"));
 
  if (generalizedIndexes.empty()) {
    B2WARNING("Generalized index of daughter particle is empty. Skipping.");
    return nullptr;
  }
 
  // To explore a decay tree of unknown depth, we need a place to store
  // both the root particle and the daughter particle at each iteration
  const Particle* dauPart =
    nullptr; // This will be eventually returned
  const Particle* currentPart = this; // This is the root particle of the next iteration
 
  // Loop over the generalizedIndexes until you get to the particle you want
  for (auto& indexString : generalizedIndexes) {
    // indexString is a string. First try to convert it into an int
    int dauIndex = 0;
    try {
      dauIndex = Belle2::convertString<int>(indexString);
    } catch (std::invalid_argument&) {
      B2WARNING("Found the string " << indexString << "instead of a daughter index.");
      return nullptr;
    }
 
    // Check that the daughter index is smaller than the number of daughters of the current root particle
    if (dauIndex >= int(currentPart->getNDaughters()) or dauIndex < 0) {
      B2WARNING("Daughter index out of range" << LogVar("Daughter index", dauIndex));
      B2WARNING("Trying to access non-existing particle.");
      return nullptr;
    } else {
      dauPart = currentPart->getDaughter(dauIndex); // Pick the particle indicated by the generalizedIndex
      currentPart = dauPart;
    }
  }
  return dauPart;
}

◆ getParticleSource()

EParticleSourceObject getParticleSource ( ) const

inline

Returns particle source as defined with enum EParticleSourceObject.

Returns: particle type

Definition at line 478 of file Particle.h.

    {
      return m_particleSource;
    }

◆ getPDGCode()

int getPDGCode ( void ) const

inline

Returns PDG code.

Returns: PDG code

Definition at line 454 of file Particle.h.

    {
      return m_pdgCode;
    }

◆ getPDGCodeUsedForFit()

int getPDGCodeUsedForFit ( ) const

inline

Return the always positive PDG code which was used for the track fit (if there was a track fit) of this particle.

This can be different than the Particle's PDG id as not all mass hypothesis are fitted during the reconstruction.

Definition at line 965 of file Particle.h.

    {
      return std::abs(m_pdgCodeUsedForFit);
    }

◆ getPDGLifetime()

double getPDGLifetime ( ) const

Returns particle nominal lifetime.

Returns: nominal lifetime [sec]

Definition at line 613 of file Particle.cc.

{
  if (TDatabasePDG::Instance()->GetParticle(m_pdgCode) == nullptr) {
    B2ERROR("PDG=" << m_pdgCode << " ***code unknown to TDatabasePDG");
    return 0.0;
  }
  return TDatabasePDG::Instance()->GetParticle(m_pdgCode)->Lifetime();
}

◆ getPDGMass()

double getPDGMass ( void ) const

Returns uncertainty on the invariant mass (requires valid momentum error matrix)

Returns: mass error Returns particle nominal mass; nominal mass

Definition at line 604 of file Particle.cc.

{
  if (TDatabasePDG::Instance()->GetParticle(m_pdgCode) == nullptr) {
    B2ERROR("PDG=" << m_pdgCode << " ***code unknown to TDatabasePDG");
    return 0.0;
  }
  return TDatabasePDG::Instance()->GetParticle(m_pdgCode)->Mass();
}

◆ getPIDLikelihood()

const PIDLikelihood * getPIDLikelihood ( ) const

Returns the pointer to the PIDLikelihood object that is related to the Track, which was used to create this Particle (ParticleType == c_Track).

NULL pointer is returned, if the Particle was not made from Track or if the Track has no relation to the PIDLikelihood

Returns: const pointer to the Track

Definition at line 871 of file Particle.cc.

{
  if (m_particleSource == c_Track) {
    StoreArray<Track> tracks{};
    return tracks[m_mdstIndex]->getRelated<PIDLikelihood>();
  } else
    return nullptr;
}

◆ getProperty()

int getProperty ( ) const

inline

Returns particle property as a bit pattern The values are defined in the PropertyFlags enum and described in detail there.

Returns: Combination of Properties describing the particle property

Definition at line 498 of file Particle.h.

    {
      return m_properties;
    }

◆ getPValue()

double getPValue ( ) const

inline

Returns chi^2 probability of fit if done or -1.

Returns: p-value of fit (nan means no fit done)

Definition at line 667 of file Particle.h.

    {
      return m_pValue;
    }

◆ getPx()

double getPx ( ) const

inline

Returns x component of momentum.

Returns: x component of momentum

Definition at line 587 of file Particle.h.

    {
      return m_momentumScale * getMomentumLossCorrectionFactor() * m_px;
    }

◆ getPy()

double getPy ( ) const

inline

Returns y component of momentum.

Returns: y component of momentum

Definition at line 596 of file Particle.h.

    {
      return m_momentumScale * getMomentumLossCorrectionFactor() * m_py;
    }

◆ getPz()

double getPz ( ) const

inline

Returns z component of momentum.

Returns: z component of momentum

Definition at line 605 of file Particle.h.

    {
      return m_momentumScale * getMomentumLossCorrectionFactor() * m_pz;
    }

◆ getRelated()

T * getRelated	(	const std::string &	name = `""`,
		const std::string &	namedRelation = `""`
	)		const

inlineinherited

Get the object to or from which this object has a relation.

Template Parameters

T	The class of objects to or from which the relation points.

Parameters

name	The name of the store array to or from which the relation points. If empty the default store array name for class T will be used. If the special name "ALL" is given all store arrays containing objects of type T are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns: The first related object or a null pointer.

Definition at line 278 of file RelationsObject.h.

    {
      return static_cast<T*>(DataStore::Instance().getRelationWith(DataStore::c_BothSides, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                             T::Class(), name, namedRelation).object);
    }

◆ getRelatedFrom()

FROM * getRelatedFrom	(	const std::string &	name = `""`,
		const std::string &	namedRelation = `""`
	)		const

inlineinherited

Get the object from which this object has a relation.

Template Parameters

FROM	The class of objects from which the relation points.

Parameters

name	The name of the store array from which the relation points. If empty the default store array name for class FROM will be used. If the special name "ALL" is given all store arrays containing objects of type FROM are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns: The first related object or a null pointer.

Definition at line 263 of file RelationsObject.h.

    {
      return static_cast<FROM*>(DataStore::Instance().getRelationWith(DataStore::c_FromSide, this, m_cacheDataStoreEntry,
                                m_cacheArrayIndex, FROM::Class(), name, namedRelation).object);
    }

◆ getRelatedFromWithWeight()

std::pair< FROM *, float > getRelatedFromWithWeight	(	const std::string &	name = `""`,
		const std::string &	namedRelation = `""`
	)		const

inlineinherited

Get first related object & weight of relation pointing from an array.

Template Parameters

FROM	The class of objects from which the relation points.

Parameters

name	The name of the store array from which the relation points. If empty the default store array name for class FROM will be used. If the special name "ALL" is given all store arrays containing objects of type FROM are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns: Pair of first related object and the relation weight, or (NULL, 1.0) if none found.

Definition at line 314 of file RelationsObject.h.

    {
      RelationEntry entry = DataStore::Instance().getRelationWith(DataStore::c_FromSide, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                                                                  FROM::Class(), name, namedRelation);
      return std::make_pair(static_cast<FROM*>(entry.object), entry.weight);
    }

◆ getRelatedTo()

TO * getRelatedTo	(	const std::string &	name = `""`,
		const std::string &	namedRelation = `""`
	)		const

inlineinherited

Get the object to which this object has a relation.

Template Parameters

TO	The class of objects to which the relation points.

Parameters

name	The name of the store array to which the relation points. If empty the default store array name for class TO will be used. If the special name "ALL" is given all store arrays containing objects of type TO are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns: The first related object or a null pointer.

Definition at line 248 of file RelationsObject.h.

    {
      return static_cast<TO*>(DataStore::Instance().getRelationWith(DataStore::c_ToSide, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                              TO::Class(), name, namedRelation).object);
    }

◆ getRelatedToWithWeight()

std::pair< TO *, float > getRelatedToWithWeight	(	const std::string &	name = `""`,
		const std::string &	namedRelation = `""`
	)		const

inlineinherited

Get first related object & weight of relation pointing to an array.

Template Parameters

TO	The class of objects to which the relation points.

Parameters

name	The name of the store array to which the relation points. If empty the default store array name for class TO will be used. If the special name "ALL" is given all store arrays containing objects of type TO are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns: Pair of first related object and the relation weight, or (NULL, 1.0) if none found.

Definition at line 297 of file RelationsObject.h.

    {
      RelationEntry entry = DataStore::Instance().getRelationWith(DataStore::c_ToSide, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                                                                  TO::Class(), name, namedRelation);
      return std::make_pair(static_cast<TO*>(entry.object), entry.weight);
    }

◆ getRelatedWithWeight()

std::pair< T *, float > getRelatedWithWeight	(	const std::string &	name = `""`,
		const std::string &	namedRelation = `""`
	)		const

inlineinherited

Get first related object & weight of relation pointing from/to an array.

Template Parameters

T	The class of objects to or from which the relation points.

Parameters

name	The name of the store array to or from which the relation points. If empty the default store array name for class T will be used. If the special name "ALL" is given all store arrays containing objects of type T are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns: Pair of first related object and the relation weight, or (NULL, 1.0) if none found.

Definition at line 331 of file RelationsObject.h.

    {
      RelationEntry entry = DataStore::Instance().getRelationWith(DataStore::c_BothSides, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                                                                  T::Class(), name, namedRelation);
      return std::make_pair(static_cast<T*>(entry.object), entry.weight);
    }

◆ getRelationsFrom()

RelationVector< FROM > getRelationsFrom	(	const std::string &	name = `""`,
		const std::string &	namedRelation = `""`
	)		const

inlineinherited

Get the relations that point from another store array to this object.

Template Parameters

FROM	The class of objects from which the relations point.

Parameters

name	The name of the store array from which the relations point. If empty the default store array name for class FROM will be used. If the special name "ALL" is given all store arrays containing objects of type FROM are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns: A vector of relations.

Definition at line 212 of file RelationsObject.h.

    {
      return RelationVector<FROM>(DataStore::Instance().getRelationsWith(DataStore::c_FromSide, this, m_cacheDataStoreEntry,
                                  m_cacheArrayIndex, FROM::Class(), name, namedRelation));
    }

◆ getRelationsTo()

RelationVector< TO > getRelationsTo	(	const std::string &	name = `""`,
		const std::string &	namedRelation = `""`
	)		const

inlineinherited

Get the relations that point from this object to another store array.

Template Parameters

TO	The class of objects to which the relations point.

Parameters

name	The name of the store array to which the relations point. If empty the default store array name for class TO will be used. If the special name "ALL" is given all store arrays containing objects of type TO are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns: A vector of relations.

Definition at line 197 of file RelationsObject.h.

    {
      return RelationVector<TO>(DataStore::Instance().getRelationsWith(DataStore::c_ToSide, this, m_cacheDataStoreEntry,
                                m_cacheArrayIndex, TO::Class(), name, namedRelation));
    }

◆ getRelationsWith()

RelationVector< T > getRelationsWith	(	const std::string &	name = `""`,
		const std::string &	namedRelation = `""`
	)		const

inlineinherited

Get the relations between this object and another store array.

Relations in both directions are returned.

Template Parameters

T	The class of objects to or from which the relations point.

Parameters

name	The name of the store array to or from which the relations point. If empty the default store array name for class T will be used. If the special name "ALL" is given all store arrays containing objects of type T are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns: A vector of relations.

Definition at line 230 of file RelationsObject.h.

    {
      return RelationVector<T>(DataStore::Instance().getRelationsWith(DataStore::c_BothSides, this, m_cacheDataStoreEntry,
                               m_cacheArrayIndex, T::Class(), name, namedRelation));
    }

◆ getTrack()

const Track * getTrack ( ) const

Returns the pointer to the Track object that was used to create this Particle (ParticleType == c_Track).

NULL pointer is returned, if the Particle was not made from Track.

Returns: const pointer to the Track

Definition at line 845 of file Particle.cc.

{
  if (m_particleSource == c_Track) {
    StoreArray<Track> tracks{};
    return tracks[m_mdstIndex];
  } else
    return nullptr;
}

◆ getTrackFitResult()

const TrackFitResult * getTrackFitResult ( ) const

Returns the pointer to the TrackFitResult that was used to create this Particle (ParticleType == c_Track).

NULL pointer is returned, if the Particle was not made from Track.

Returns: const pointer to the TrackFitResult

Definition at line 854 of file Particle.cc.

{
  // if the particle is related to a TrackFitResult then return this
  auto* selfrelated = this->getRelatedTo<TrackFitResult>();
  if (selfrelated && !isnan(selfrelated->getPValue()))
    return selfrelated;
 
  // if not get the TFR with closest mass to this particle
  auto* selftrack = this->getTrack();
  if (selftrack)
    return selftrack->getTrackFitResultWithClosestMass(
             Belle2::Const::ChargedStable(std::abs(this->getPDGCode())));
 
  // otherwise we're probably not a track based particle
  return nullptr;
}

◆ getV0()

const V0 * getV0 ( ) const

Returns the pointer to the V0 object that was used to create this Particle (if ParticleType == c_V0).

NULL pointer is returned if the Particle was not made from a V0.

Returns: const pointer to the V0

Definition at line 880 of file Particle.cc.

{
  if (m_particleSource == c_V0) {
    StoreArray<V0> v0s{};
    return v0s[m_mdstIndex];
  } else {
    return nullptr;
  }
}

◆ getVertex()

ROOT::Math::XYZVector getVertex ( ) const

inline

Returns vertex position (POCA for charged, IP for neutral FS particles)

Returns: vertex position

Definition at line 631 of file Particle.h.

    {
      return ROOT::Math::XYZVector(m_x, m_y, m_z);
    };

◆ getVertexErrorMatrix()

TMatrixFSym getVertexErrorMatrix ( ) const

Returns the 3x3 position error sub-matrix.

Returns: The 3x3 position error matrix (order: x,y,z)

Definition at line 447 of file Particle.cc.

{
  TMatrixFSym pos;
  const TMatrixFSym& full = getMomentumVertexErrorMatrix();
 
  // get 3x3 (position) submatrix from the full error matrix
  // vertex related elements are in [4,5,6]x[4,5,6] block
  full.GetSub(4, 6, pos, "S");
 
  return pos;
}

◆ getX()

double getX ( ) const

inline

Returns x component of vertex position.

Returns: x component of vertex position

Definition at line 640 of file Particle.h.

    {
      return m_x;
    }

◆ getY()

double getY ( ) const

inline

Returns y component of vertex position.

Returns: y component of vertex position

Definition at line 649 of file Particle.h.

    {
      return m_y;
    }

◆ getZ()

double getZ ( ) const

inline

Returns z component of vertex position.

Returns: z component of vertex position

Definition at line 658 of file Particle.h.

    {
      return m_z;
    }

◆ hasExtraInfo()

bool hasExtraInfo ( const std::string & name ) const

Return whether the extra info with the given name is set.

Definition at line 1266 of file Particle.cc.

{
  if (m_extraInfo.empty())
    return false;
 
  //get index for name
  const auto mapID = (unsigned int)m_extraInfo[0];
  StoreObjPtr<ParticleExtraInfoMap> extraInfoMap;
  if (!extraInfoMap) {
    B2FATAL("ParticleExtraInfoMap not available, but needed for storing extra info in Particle!");
  }
  unsigned int index = extraInfoMap->getIndex(mapID, name);
  if (index == 0 or index >= m_extraInfo.size()) //actually indices start at 1
    return false;
 
  return true;
}

◆ isCopyOf()

bool isCopyOf	(	const Particle *	oParticle,
		bool	doDetailedComparison = `false`
	)		const

Returns true if this Particle and oParticle are copies of each other.

Copies are defined as: o) The decay chain of both Particles is exactly the same o) Both Particles are constructed from exactly the same final state particles

Examples: M1 -> (C1 -> F1 F2) (C2 -> F3 F4) M2 -> (C1 -> F1 F2) (C2 -> F3 F5) M3 -> (C1 -> F1 F2) F3 F4 M4 -> (C1 -> F1 F2) (C2 -> F3 F4) and M4 is kinematically fitted (its momentum updated)

M1 and M2 are not copies since condition 2 is not fulfilled. M1 and M3 are not copies since condition 1 is not fulfilled. M1 and M4 are copies since both conditions are fulfilled.

Parameters

oParticle	pointer to other particle
doDetailedComparison	if true, this means that particles of different PDG codes, but created from the same track or cluster will be indicated as copies. Returns B2FATAL in case of comparison of c_MCParticle type to a non c_MCParticle.

Returns: true if particles are copies of each-other, otherwise false

Definition at line 752 of file Particle.cc.

{
  // the name of the game is to as quickly as possible determine
  // that the Particles are not copies
  if (this->getPDGCode() != oParticle->getPDGCode() and !doDetailedComparison)
    return false;
 
  unsigned nDaughters = this->getNDaughters();
  if (nDaughters != oParticle->getNDaughters())
    return false;
 
  if (nDaughters) {
    // has daughters: check if the decay chain is the same and it ends with
    // the same FSPs
    std::vector<int> thisDecayChain(nDaughters * 2);
    std::vector<int> othrDecayChain(nDaughters * 2);
 
    for (unsigned i = 0; i < nDaughters; i++) {
      this->getDaughter(i)->fillDecayChain(thisDecayChain);
      oParticle->getDaughter(i)->fillDecayChain(othrDecayChain);
    }
 
    // Even if the daughters have been provided in a different order in the
    // decay string the particles should be identified as copies / duplicates.
    // Therefore, the decay chain vectors, which contain both the pdg codes and
    // the mdst sources, are sorted here before comparing them.
    sort(thisDecayChain.begin(), thisDecayChain.end());
    sort(othrDecayChain.begin(), othrDecayChain.end());
 
    for (unsigned i = 0; i < thisDecayChain.size(); i++)
      if (thisDecayChain[i] != othrDecayChain[i])
        return false;
 
  } else if (this->getMdstSource() != oParticle->getMdstSource() and !doDetailedComparison) {
    // has no daughters: it's a FSP, compare MDST source and index
    return false;
  }
  // Stop here if we do not want a detailed comparison
  if (!doDetailedComparison)
    return true;
  //If we compare here a reconstructed Particle to a generated MCParticle
  //it means that something went horribly wrong and we must stop
  if ((this->getParticleSource() == EParticleSourceObject::c_MCParticle
       and oParticle->getParticleSource() != EParticleSourceObject::c_MCParticle)
      or (this->getParticleSource() != EParticleSourceObject::c_MCParticle
          and oParticle->getParticleSource() == EParticleSourceObject::c_MCParticle)) {
    B2WARNING("Something went wrong: MCParticle is being compared to a non MC Particle. Please check your script!\n"
              "                              If the MCParticle <-> Particle comparison happens in the RestOfEventBuilder,\n"
              "                              the Rest Of Event may contain signal side particles.");
    return false;
  }
  if (this->getParticleSource() == EParticleSourceObject::c_MCParticle
      and oParticle->getParticleSource() == EParticleSourceObject::c_MCParticle) {
    return this->getMCParticle() == oParticle->getMCParticle();
  }
  if (this->getParticleSource() != oParticle->getParticleSource()) {
    return false;
  }
  if (this->getMdstSource() == oParticle->getMdstSource()) {
    return true;
  }
  if (this->getTrack() && oParticle->getTrack() &&
      this->getTrack()->getArrayIndex() != oParticle->getTrack()->getArrayIndex()) {
    return false;
  }
  if (this->getKLMCluster() && oParticle->getKLMCluster()
      && this->getKLMCluster()->getArrayIndex() != oParticle->getKLMCluster()->getArrayIndex()) {
    return false;
  }
 
  // It can be a bit more complicated for ECLClusters as we might also have to ensure they are connected-region unique
  if (this->getECLCluster() && oParticle->getECLCluster()
      && this->getECLCluster()->getArrayIndex() != oParticle->getECLCluster()->getArrayIndex()) {
 
    // if either is a track then they must be different
    if (this->getECLCluster()->isTrack() or oParticle->getECLCluster()->isTrack())
      return false;
 
    // we cannot combine two particles of different hypotheses from the same
    // connected region (as their energies overlap)
    if (this->getECLClusterEHypothesisBit() == oParticle->getECLClusterEHypothesisBit())
      return false;
 
    // in the rare case that both are neutral and the hypotheses are different,
    // we must also check that they are from different connected regions
    // otherwise they come from the "same" underlying ECLShower
    if (this->getECLCluster()->getConnectedRegionId() != oParticle->getECLCluster()->getConnectedRegionId())
      return false;
  }
  return true;
 
}

◆ isMostLikely()

bool isMostLikely ( ) const

Returns true if the (track-based) particle is created with its most likely mass hypothesis based on PID likelihood.

Definition at line 1391 of file Particle.cc.

{
  const PIDLikelihood* likelihood = Particle::getPIDLikelihood();
  if (likelihood) return likelihood->getMostLikely().getPDGCode() == std::abs(m_pdgCode);
  else return false;
}

◆ isMostLikelyTrackFitResult()

bool isMostLikelyTrackFitResult ( ) const

Returns true if the (track-based) particle is created with its most likely mass hypothesis based on TrackFitResult.

Definition at line 1416 of file Particle.cc.

{
  const auto trackFit = this->getTrackFitResult();
  if (!trackFit) return false;
 
  return (trackFit == this->getMostLikelyTrackFitResult().second);
}

◆ overlapsWith()

bool overlapsWith ( const Particle * oParticle ) const

Returns true if final state ancestors of oParticle overlap.

Parameters

oParticle pointer to particle

Returns: true if overlap, otherwise false

Definition at line 737 of file Particle.cc.

{
  // obtain vectors of daughter final state particles
  std::vector<const Particle*> thisFSPs  = this->getFinalStateDaughters();
  std::vector<const Particle*> otherFSPs = oParticle->getFinalStateDaughters();
 
  // check if they share any of the FSPs
  for (auto& thisFSP : thisFSPs)
    for (auto& otherFSP : otherFSPs)
      if (thisFSP->getMdstSource() == otherFSP->getMdstSource())
        return true;
 
  return false;
}

◆ print()

void print ( ) const

Prints the contents of a Particle object to standard output.

Definition at line 1170 of file Particle.cc.

{
  B2INFO(getInfo());
}

◆ removeDaughter()

void removeDaughter	(	const Particle *	daughter,
		const bool	updateType = `true`
	)

Removes index of daughter from daughters index array.

Parameters

daughter	pointer to the daughter particle
updateType	bool whether particle type should be updated if last daughter was removed

Definition at line 688 of file Particle.cc.

{
  if (getNDaughters() == 0)
    return;
 
  for (unsigned i = 0; i < getNDaughters(); i++) {
    if (m_daughterIndices[i] == daughter->getArrayIndex()) {
      m_daughterIndices.erase(m_daughterIndices.begin() + i);
      m_daughterProperties.erase(m_daughterProperties.begin() + i);
      i--;
    }
  }
 
  if (getNDaughters() == 0 and updateType)
    m_particleSource = c_Undefined;
}

◆ removeExtraInfo()

void removeExtraInfo ( )

Remove all stored extra info fields.

Definition at line 1284 of file Particle.cc.

{
  m_extraInfo.clear();
}

◆ replaceDaughter()

bool replaceDaughter	(	const Particle *	oldDaughter,
		Particle *	newDaughter
	)

Replace index of given daughter with new daughter, return true if a replacement is made.

Parameters

oldDaughter	pointer to the daughter that will be removed
newDaughter	pointer to the particle that will be added as a daughter

Definition at line 705 of file Particle.cc.

{
  int index = oldDaughter->getArrayIndex();
 
  for (unsigned i = 0; i < getNDaughters(); i++) {
    if (m_daughterIndices[i] == index) {
      auto ite_index =  m_daughterIndices.erase(m_daughterIndices.begin() + i);
      m_daughterIndices.insert(ite_index, newDaughter->getArrayIndex());
      auto ite_property =  m_daughterProperties.erase(m_daughterProperties.begin() + i);
      m_daughterProperties.insert(ite_property, Particle::PropertyFlags::c_Ordinary);
 
      newDaughter->writeExtraInfo("original_index", index);
      return true;
    }
  }
  return false;
}

◆ replaceDaughterRecursively()

bool replaceDaughterRecursively	(	const Particle *	oldDaughter,
		Particle *	newDaughter
	)

Apply replaceDaughter to all Particles in the decay tree by looping recursively through it, return true if a replacement is made.

Parameters

oldDaughter	pointer to the daughter that will be removed
newDaughter	pointer to the particle that will be added as a daughter

Definition at line 723 of file Particle.cc.

{
  bool isReplaced = this->replaceDaughter(oldDaughter, newDaughter);
  if (isReplaced)
    return true;
  for (auto& daughter : this->getDaughters()) {
    isReplaced = daughter->replaceDaughterRecursively(oldDaughter, newDaughter);
    if (isReplaced)
      return true;
  }
  return false;
}

◆ resetErrorMatrix()

void resetErrorMatrix ( )

private

Resets 7x7 error matrix All elements are set to 0.0.

Definition at line 1079 of file Particle.cc.

{
  for (double& i : m_errMatrix)
    i = 0.0;
}

◆ resetJacobiMatrix()

void resetJacobiMatrix ( )

private

Resets 4x6 error matrix All elements are set to 0.0.

Definition at line 1085 of file Particle.cc.

{
  for (double& i : m_jacobiMatrix)
    i = 0.0;
}

◆ set4Vector()

void set4Vector ( const ROOT::Math::PxPyPzEVector & p4 )

inline

Sets Lorentz vector.

Parameters

p4	Lorentz vector

Definition at line 271 of file Particle.h.

    {
      m_px = p4.Px();
      m_py = p4.Py();
      m_pz = p4.Pz();
      m_mass = p4.M();
    }

◆ set4VectorDividingByMomentumScaling()

void set4VectorDividingByMomentumScaling ( const ROOT::Math::PxPyPzEVector & p4 )

inline

Sets Lorentz vector dividing by the momentum scaling factor.

Parameters

p4	Lorentz vector

Definition at line 283 of file Particle.h.

    {
      m_px = p4.Px() / m_momentumScale;
      m_py = p4.Py() / m_momentumScale;
      m_pz = p4.Pz() / m_momentumScale;
      m_mass = p4.M();
    }

◆ setEnergyLossCorrection()

void setEnergyLossCorrection ( double energyLossCorrection )

inline

Sets Energy loss correction.

Parameters

energyLossCorrection Correction factor

Definition at line 306 of file Particle.h.

    {
      m_energyLossCorrection = energyLossCorrection;
    }

◆ setExtraInfo()

void setExtraInfo	(	const std::string &	name,
		double	value
	)

Sets the user-defined data of given name to the given value.

throws std::runtime_error if variable isn't set.

Definition at line 1317 of file Particle.cc.

{
  if (m_extraInfo.empty())
    throw std::runtime_error(std::string("setExtraInfo: Value '") + name + "' not found in Particle!");
 
  //get index for name
  const auto mapID = (unsigned int)m_extraInfo[0];
  StoreObjPtr<ParticleExtraInfoMap> extraInfoMap;
  if (!extraInfoMap) {
    B2FATAL("ParticleExtraInfoMap not available, but needed for storing extra info in Particle!");
  }
  unsigned int index = extraInfoMap->getIndex(mapID, name);
  if (index == 0 or index >= m_extraInfo.size()) //actually indices start at 1
    throw std::runtime_error(std::string("setExtraInfo: Value '") + name + "' not found in Particle!");
 
  m_extraInfo[index] = value;
 
}

◆ setFlavorType()

void setFlavorType ( )

private

sets m_flavorType using m_pdgCode

Definition at line 1150 of file Particle.cc.

{
  m_flavorType = c_Flavored;
  if (m_pdgCode < 0) return;
  if (m_pdgCode == Const::photon.getPDGCode()) {m_flavorType = c_Unflavored; return;} // gamma
  if (m_pdgCode == Const::Kshort.getPDGCode()) {m_flavorType = c_Unflavored; return;} // K_s
  if (m_pdgCode == Const::Klong.getPDGCode()) {m_flavorType = c_Unflavored; return;} // K_L
  if (m_pdgCode == 43) {m_flavorType = c_Unflavored; return;} // Xu0
  int nnn = m_pdgCode / 10;
  int q3 = nnn % 10; nnn /= 10;
  int q2 = nnn % 10; nnn /= 10;
  int q1 = nnn % 10;
  if (q1 == 0 && q2 == q3) m_flavorType = c_Unflavored; // unflavored meson
}

◆ setJacobiMatrix()

void setJacobiMatrix ( const TMatrixF & jacobiMatrix )

Sets 4x6 jacobi matrix.

Parameters

jacobiMatrix 4x6 momentum and vertex error matrix (order: px,py,pz,E,x,y,z)

Definition at line 407 of file Particle.cc.

{
  // check if provided Jacobi Matrix is of dimension 4x6
  // if not, reset the error matrix and print warning
  if (m.GetNrows() != 4 || m.GetNcols() != 6) {
    resetJacobiMatrix();
    B2WARNING("Jacobi Matrix is not 4x6 ");
    return;
  }
  storeJacobiMatrix(m);
}

◆ setMdstArrayIndex()

void setMdstArrayIndex ( const int arrayIndex )

private

set mdst array index

Definition at line 350 of file Particle.cc.

{
  m_mdstIndex = arrayIndex;
 
  // set the identifier
  if (m_particleSource == c_ECLCluster) {
    const ECLCluster* cluster = this->getECLCluster();
    if (cluster) {
      m_identifier = cluster->getUniqueClusterId();
    } else {
      B2ERROR("Particle is of type = ECLCluster has identifier not set and no relation to ECLCluster.\n"
              "This has happen because old microDST is analysed with newer version of software.");
    }
  } else {
    m_identifier = m_mdstIndex;
  }
}

◆ setMomentumPositionErrorMatrix()

void setMomentumPositionErrorMatrix ( const TrackFitResult * trackFit )

private

Sets the momentum, position and error matrix for this particle (created from charged Track)

Definition at line 1001 of file Particle.cc.

{
  // set momentum
  m_px = trackFit->getMomentum().X();
  m_py = trackFit->getMomentum().Y();
  m_pz = trackFit->getMomentum().Z();
 
  // set position at which the momentum is given (= POCA)
  setVertex(trackFit->getPosition());
 
  // set Chi^2 probability
  m_pValue = trackFit->getPValue();
 
  // set error matrix
  const auto cov6 = trackFit->getCovariance6();
  constexpr unsigned order[] = {c_X, c_Y, c_Z, c_Px, c_Py, c_Pz};
 
  TMatrixFSym errMatrix(c_DimMatrix);
  for (int i = 0; i < 6; i++) {
    for (int j = i; j < 6; j++) {
      // although it seems to make no sense to fill all elements of the
      // symmetric matrix, it has to be (do not touch this code)
      errMatrix(order[j], order[i]) = errMatrix(order[i], order[j]) = cov6(i, j);
    }
  }
 
  /*
     E = sqrt(px^2 + py^2 + pz^2 + m^2) thus:
     cov(x,E)  = cov(px,x) *dE/dpx + cov(py,x) *dE/dpy + cov(pz,x) *dE/dpz
     cov(y,E)  = cov(px,y) *dE/dpx + cov(py,y) *dE/dpy + cov(pz,y) *dE/dpz
     cov(z,E)  = cov(px,z) *dE/dpx + cov(py,z) *dE/dpy + cov(pz,z) *dE/dpz
     cov(px,E) = cov(px,px)*dE/dpx + cov(px,py)*dE/dpy + cov(px,pz)*dE/dpz
     cov(py,E) = cov(py,px)*dE/dpx + cov(py,py)*dE/dpy + cov(py,pz)*dE/dpz
     cov(pz,E) = cov(pz,px)*dE/dpx + cov(pz,py)*dE/dpy + cov(pz,pz)*dE/dpz
     cov(E,E)  = cov(px,px)*(dE/dpx)^2 + cov(py,py)*(dE/dpy)^2 + cov(pz,pz)*(dE/dpz)^2
               + 2*cov(px,py)*dE/dpx*dE/dpy
               + 2*cov(py,pz)*dE/dpy*dE/dpz
               + 2*cov(pz,px)*dE/dpz*dE/dpx
     dE/dpx = px/E etc.
  */
 
  const double E = getEnergy();
  const double dEdp[] = {m_px / E, m_py / E, m_pz / E};
  constexpr unsigned compMom[] = {c_Px, c_Py, c_Pz};
  constexpr unsigned compPos[] = {c_X,  c_Y,  c_Z};
 
  // covariances (p,E)
  for (unsigned int i : compMom) {
    double Cov = 0;
    for (int k = 0; k < 3; k++) {
      Cov += errMatrix(i, compMom[k]) * dEdp[k];
    }
    errMatrix(i, c_E) = Cov;
  }
 
  // covariances (x,E)
  for (unsigned int comp : compPos) {
    double Cov = 0;
    for (int k = 0; k < 3; k++) {
      Cov += errMatrix(comp, compMom[k]) * dEdp[k];
    }
    errMatrix(c_E, comp) = Cov;
  }
 
  // variance (E,E)
  double Cov = 0;
  for (int i = 0; i < 3; i++) {
    Cov += errMatrix(compMom[i], compMom[i]) * dEdp[i] * dEdp[i];
  }
  for (int i = 0; i < 3; i++) {
    int k = (i + 1) % 3;
    Cov += 2 * errMatrix(compMom[i], compMom[k]) * dEdp[i] * dEdp[k];
  }
  errMatrix(c_E, c_E) = Cov;
 
  storeErrorMatrix(errMatrix);
}

◆ setMomentumScalingFactor()

void setMomentumScalingFactor ( double momentumScalingFactor )

inline

Sets momentum scaling.

Parameters

momentumScalingFactor scaling factor

Definition at line 334 of file Particle.h.

    {
      m_momentumScalingFactor = momentumScalingFactor;
      m_momentumScale = m_momentumScalingFactor * m_momentumSmearingFactor;
    }

◆ setMomentumSmearingFactor()

void setMomentumSmearingFactor ( double momentumSmearingFactor )

inline

Sets momentum smearing.

Parameters

momentumSmearingFactor scaling factor

Definition at line 344 of file Particle.h.

    {
      m_momentumSmearingFactor = momentumSmearingFactor;
      m_momentumScale = m_momentumScalingFactor * m_momentumSmearingFactor;
    }

◆ setMomentumVertexErrorMatrix()

void setMomentumVertexErrorMatrix ( const TMatrixFSym & errMatrix )

Sets 7x7 error matrix.

Parameters

errMatrix 7x7 momentum and vertex error matrix (order: px,py,pz,E,x,y,z)

Definition at line 393 of file Particle.cc.

{
  // check if provided Error Matrix is of dimension 7x7
  // if not, reset the error matrix and print warning
  if (m.GetNrows() != c_DimMatrix || m.GetNcols() != c_DimMatrix) {
    resetErrorMatrix();
    B2WARNING("Error Matrix is not 7x7 ");
    return;
  }
  storeErrorMatrix(m);
 
}

◆ setPDGCode()

void setPDGCode ( const int pdg )

inline

Sets PDG code.

Parameters

pdg PDG code

Definition at line 262 of file Particle.h.

    {
      m_pdgCode = pdg;
    }

◆ setProperty()

void setProperty ( const int properties )

inline

sets m_properties

Definition at line 374 of file Particle.h.

    {
      m_properties = properties;
    }

◆ setPValue()

void setPValue ( double pValue )

inline

Sets chi^2 probability of fit.

Parameters

pValue p-value of fit

Definition at line 366 of file Particle.h.

    {
      m_pValue = pValue;
    }

◆ setVertex()

void setVertex ( const ROOT::Math::XYZVector & vertex )

inline

Sets position (decay vertex)

Parameters

vertex position

Definition at line 295 of file Particle.h.

    {
      m_x = vertex.X();
      m_y = vertex.Y();
      m_z = vertex.Z();
    };

◆ storeErrorMatrix()

void storeErrorMatrix ( const TMatrixFSym & errMatrix )

private

Stores 7x7 error matrix into private member m_errMatrix.

Parameters

errMatrix 7x7 error matrix

Definition at line 1091 of file Particle.cc.

{
  int element = 0;
  for (int irow = 0; irow < c_DimMatrix; irow++) {
    for (int icol = irow; icol < c_DimMatrix; icol++) {
      m_errMatrix[element] = m(irow, icol);
      element++;
    }
  }
}

◆ storeJacobiMatrix()

void storeJacobiMatrix ( const TMatrixF & jacobiMatrix )

private

Stores 4x6 Jacobi matrix into private member m_jacobiMatrix.

Parameters

jacobiMatrix 4x6 error matrix

Definition at line 1102 of file Particle.cc.

{
  int element = 0;
  for (int irow = 0; irow < 4; irow++) {
    for (int icol = 0; icol < 6; icol++) {
      m_jacobiMatrix[element] = m(irow, icol);
      element++;
    }
  }
}

◆ updateJacobiMatrix()

void updateJacobiMatrix ( )

Propagate the photon energy scaling to jacobian elements that were calculated using energy.

Definition at line 257 of file Particle.cc.

{
  ClusterUtils C;
 
  const ECLCluster* cluster = this->getECLCluster();
 
  const XYZVector clustervertex = C.GetIPPosition();
 
  // Get Jacobi matrix.
  TMatrixD jacobi = C.GetJacobiMatrix4x6FromCluster(cluster, clustervertex, getECLClusterEHypothesisBit());
  storeJacobiMatrix(jacobi);
 
  // Propagate the photon energy scaling to jacobian elements that were calculated using energy.
  TMatrixD scaledJacobi(4, 6);
 
  int element = 0;
 
  for (int irow = 0; irow < 4; irow++) {
    for (int icol = 0; icol < 6; icol++) {
      if (icol != 0 && irow != 3) {
        scaledJacobi(irow, icol) = m_jacobiMatrix[element] * m_momentumScale;
      } else {
        scaledJacobi(irow, icol) = m_jacobiMatrix[element];
      }
      element++;
    }
  }
 
  storeJacobiMatrix(scaledJacobi);
 
  // Get covariance matrix of IP distribution.
  const TMatrixDSym clustervertexcovmat = C.GetIPPositionCovarianceMatrix();
 
  // Set error matrix.
  TMatrixDSym clustercovmat = C.GetCovarianceMatrix7x7FromCluster(cluster, clustervertexcovmat, scaledJacobi);
  storeErrorMatrix(clustercovmat);
}

◆ updateMass()

void updateMass ( const int pdgCode )

Updates particle mass with the mass of the particle corresponding to the given PDG.

Parameters

pdgCode PDG code of the particle with the desired mass

Definition at line 597 of file Particle.cc.

{
  if (TDatabasePDG::Instance()->GetParticle(pdgCode) == nullptr)
    B2FATAL("PDG=" << pdgCode << " ***code unknown to TDatabasePDG");
  m_mass = TDatabasePDG::Instance()->GetParticle(pdgCode)->Mass() ;
}

◆ updateMomentum()

void updateMomentum	(	const ROOT::Math::PxPyPzEVector &	p4,
		const ROOT::Math::XYZVector &	vertex,
		const TMatrixFSym &	errMatrix,
		double	pValue
	)

inline

Sets Lorentz vector, position, 7x7 error matrix and p-value.

Parameters

p4	Lorentz vector
vertex	point (position or vertex)
errMatrix	7x7 momentum and vertex error matrix (order: px,py,pz,E,x,y,z)
pValue	chi^2 probability of the fit

Definition at line 386 of file Particle.h.

    {
      set4Vector(p4);
      setVertex(vertex);
      setMomentumVertexErrorMatrix(errMatrix);
      m_pValue = pValue;
    }

◆ wasExactFitHypothesisUsed()

bool wasExactFitHypothesisUsed ( ) const

inline

Returns true if the type represented by this Particle object was used use as a mass hypothesis during the track of this Particle's parameters.

Definition at line 975 of file Particle.h.

    {
      return std::abs(m_pdgCodeUsedForFit) == std::abs(m_pdgCode);
    }

◆ writeExtraInfo()

void writeExtraInfo	(	const std::string &	name,
		const double	value
	)

Sets the user defined extraInfo.

Adds it if necessary, overwrites existing ones if they share the same name.

Definition at line 1308 of file Particle.cc.

{
  if (this->hasExtraInfo(name)) {
    this->setExtraInfo(name, value);
  } else {
    this->addExtraInfo(name, value);
  }
}

Friends And Related Function Documentation

◆ ParticleSubset

friend class ParticleSubset

friend

Definition at line 1170 of file Particle.h.

Member Data Documentation

◆ m_arrayPointer

TClonesArray* m_arrayPointer

mutableprivate

Internal pointer to DataStore array containing the daughters of this particle.

This is a transient member and will not be written to file. The pointer is set by getArrayPointer() when first called.

Definition at line 1100 of file Particle.h.

◆ m_cacheArrayIndex

int m_cacheArrayIndex

mutableprivateinherited

Cache of the index in the TClonesArray to which this object belongs.

Definition at line 432 of file RelationsObject.h.

◆ m_cacheDataStoreEntry

DataStore::StoreEntry* m_cacheDataStoreEntry

mutableprivateinherited

Cache of the data store entry to which this object belongs.

Definition at line 429 of file RelationsObject.h.

◆ m_daughterIndices

std::vector<int> m_daughterIndices

private

daughter particle indices

Definition at line 1070 of file Particle.h.

◆ m_daughterProperties

std::vector<int> m_daughterProperties

private

daughter particle properties

Definition at line 1075 of file Particle.h.

◆ m_energyLossCorrection

double m_energyLossCorrection = 0.0

private

energy loss correction.

defined as 'm_energyLossCorrection = E_measured - E_true'

Definition at line 1063 of file Particle.h.

◆ m_errMatrix

double m_errMatrix[c_SizeMatrix] = {}

private

error matrix (1D representation)

Definition at line 1067 of file Particle.h.

◆ m_extraInfo

std::vector<double> m_extraInfo

private

Stores associated user defined values.

Order is given by string -> index mapping in ParticleExtraInfoMap. entry 0 is reserved specifies which map to use.

Definition at line 1091 of file Particle.h.

◆ m_flavorType

EFlavorType m_flavorType

private

flavor type.

Definition at line 1071 of file Particle.h.

◆ m_identifier

int m_identifier = -1

private

Identifier that can be used to identify whether the particle is unique or is a copy or representation of another.

For example a kaon and pion particles constructed from the same Track are representations of the same physical object in the detector and cannot be used in the reconstruction of the same decay chain

Definition at line 1084 of file Particle.h.

◆ m_jacobiMatrix

double m_jacobiMatrix[c_SizeMatrix] = {}

private

error matrix (1D representation)

Definition at line 1068 of file Particle.h.

◆ m_mass

double m_mass

private

particle (invariant) mass

Definition at line 1056 of file Particle.h.

◆ m_mdstIndex

unsigned m_mdstIndex

private

0-based index of MDST store array object

Definition at line 1073 of file Particle.h.

◆ m_momentumScale

double m_momentumScale = 1.0

private

effective momentum scale factor

Definition at line 1060 of file Particle.h.

◆ m_momentumScalingFactor

double m_momentumScalingFactor = 1.0

private

momentum scaling factor

Definition at line 1061 of file Particle.h.

◆ m_momentumSmearingFactor

double m_momentumSmearingFactor = 1.0

private

momentum smearing factor

Definition at line 1062 of file Particle.h.

◆ m_particleSource

EParticleSourceObject m_particleSource

private

(mdst) source of particle

Definition at line 1072 of file Particle.h.

◆ m_pdgCode

int m_pdgCode

private

PDG code.

Definition at line 1054 of file Particle.h.

◆ m_pdgCodeUsedForFit

int m_pdgCodeUsedForFit = 0

private

PDG code used for the track fit.

Definition at line 1055 of file Particle.h.

◆ m_properties

int m_properties

private

particle property

Definition at line 1074 of file Particle.h.

◆ m_pValue

double m_pValue

private

chi^2 probability of the fit.

Default is nan

Definition at line 1069 of file Particle.h.

◆ m_px

double m_px

private

momentum component x

Definition at line 1057 of file Particle.h.

◆ m_py

double m_py

private

momentum component y

Definition at line 1058 of file Particle.h.

◆ m_pz

double m_pz

private

momentum component z

Definition at line 1059 of file Particle.h.

◆ m_x

double m_x

private

position component x

Definition at line 1064 of file Particle.h.

◆ m_y

double m_y

private

position component y

Definition at line 1065 of file Particle.h.

◆ m_z

double m_z

private

position component z

Definition at line 1066 of file Particle.h.

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

analysis/dataobjects/include/Particle.h
analysis/dataobjects/src/Particle.cc

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

◆ anonymous enum

◆ EFlavorType

◆ EParticleSourceObject

◆ PropertyFlags

Constructor & Destructor Documentation

◆ Particle() [1/11]

◆ Particle() [2/11]

◆ Particle() [3/11]

◆ Particle() [4/11]

◆ Particle() [5/11]

◆ Particle() [6/11]

◆ Particle() [7/11]

◆ Particle() [8/11]

◆ Particle() [9/11]

◆ Particle() [10/11]

◆ Particle() [11/11]

Member Function Documentation

◆ addExtraInfo()

◆ addRelationTo() [1/2]

◆ addRelationTo() [2/2]

◆ appendDaughter() [1/2]

◆ appendDaughter() [2/2]

◆ copyRelations()

◆ fillAllDaughters()

◆ fillDecayChain()

◆ fillFSPDaughters()

◆ forEachDaughter()

◆ generatePDGCodeFromCharge()

◆ get4Vector()

◆ getAcoplanarity()

◆ getAllDaughters()

◆ getArrayIndex()

◆ getArrayName()

◆ getArrayPointer()

◆ getCharge()

◆ getCosHelicity()

◆ getCosHelicityDaughter()

◆ getDaughter()

◆ getDaughterIndices()

◆ getDaughterProperties()

◆ getDaughters()

◆ getECLCluster()

◆ getECLClusterEHypothesisBit()

◆ getECLClusterEnergy()

◆ getEffectiveMomentumScale()

◆ getEnergy()

◆ getEnergyLossCorrection()

◆ getExtraInfo()

◆ getExtraInfoMap()

◆ getExtraInfoNames()

◆ getExtraInfoSize()

◆ getFinalStateDaughters()

◆ getFlavorType()

◆ getInfo()

◆ getInfoHTML()

◆ getKLMCluster()

◆ getMass()

◆ getMCParticle()

◆ getMdstArrayIndex()

◆ getMdstArrayIndices()

◆ getMdstSource()

◆ getMomentum()

◆ getMomentumErrorMatrix()

◆ getMomentumLossCorrectionFactor()

◆ getMomentumMagnitude()

◆ getMomentumVertexErrorMatrix()

◆ getMostLikelyTrackFitResult()

◆ getName()

◆ getNDaughters()

◆ getP()

◆ getParticleFromGeneralizedIndexString()

◆ getParticleSource()