Belle II Software light-2406-ragdoll
Particle.h
1/**************************************************************************
2 * basf2 (Belle II Analysis Software Framework) *
3 * Author: The Belle II Collaboration *
4 * *
5 * See git log for contributors and copyright holders. *
6 * This file is licensed under LGPL-3.0, see LICENSE.md. *
7 **************************************************************************/
8
9#pragma once
10
11#include <framework/datastore/RelationsObject.h>
12#include <framework/gearbox/Const.h>
13#include <mdst/dataobjects/ECLCluster.h>
14
15#include <Math/Vector3D.h>
16#include <Math/Vector4D.h>
17#include <TMatrixFfwd.h>
18#include <TMatrixFSymfwd.h>
19
20#include <vector>
21
22class TClonesArray;
23
24namespace Belle2 {
30 // forward declarations
31 class KLMCluster;
32 class Track;
33 class TrackFitResult;
34 class MCParticle;
35 class PIDLikelihood;
36 class V0;
37
75 class Particle : public RelationsObject {
76
77 public:
78
83 c_Undefined = 0,
84 c_Track = 1,
85 c_ECLCluster = 2,
86 c_KLMCluster = 3,
87 c_V0 = 4,
88 c_MCParticle = 5,
89 c_Composite = 6,
90 c_NoMDSTSource = 7
91 };
92
97 };
98
102 enum {c_DimPosition = 3, c_DimMomentum = 4, c_DimMatrix = 7,
103 c_SizeMatrix = c_DimMatrix * (c_DimMatrix + 1) / 2
104 };
105
110 enum {c_Px, c_Py, c_Pz, c_E, c_X, c_Y, c_Z};
111
117 c_Ordinary = 0,
127 };
128
133 Particle();
134
141 Particle(const ROOT::Math::PxPyPzEVector& momentum, const int pdgCode);
142
152 Particle(const ROOT::Math::PxPyPzEVector& momentum,
153 const int pdgCode,
154 EFlavorType flavorType,
155 const EParticleSourceObject particleType,
156 const unsigned mdstIndex);
157
167 Particle(const ROOT::Math::PxPyPzEVector& momentum,
168 const int pdgCode,
169 EFlavorType flavorType,
170 const std::vector<int>& daughterIndices,
171 TClonesArray* arrayPointer = nullptr);
172
183 Particle(const ROOT::Math::PxPyPzEVector& momentum,
184 const int pdgCode,
185 EFlavorType flavorType,
186 const std::vector<int>& daughterIndices,
187 int properties,
188 TClonesArray* arrayPointer = nullptr);
189
201 Particle(const ROOT::Math::PxPyPzEVector& momentum,
202 const int pdgCode,
203 EFlavorType flavorType,
204 const std::vector<int>& daughterIndices,
205 int properties,
206 const std::vector<int>& daughterProperties,
207 TClonesArray* arrayPointer = nullptr);
208
214 Particle(const Track* track,
215 const Const::ChargedStable& chargedStable);
216
225 Particle(int trackArrayIndex, const TrackFitResult* trackFit,
226 const Const::ChargedStable& chargedStable);
227
233 explicit Particle(const ECLCluster* eclCluster,
234 const Const::ParticleType& type = Const::photon);
235
241 explicit Particle(const KLMCluster* klmCluster, const int pdgCode = Const::Klong.getPDGCode());
242
247 explicit Particle(const MCParticle* MCparticle);
248
253
254 public:
255
256 // setters
257
262 void setPDGCode(const int pdg)
263 {
264 m_pdgCode = pdg;
265 }
266
271 void set4Vector(const ROOT::Math::PxPyPzEVector& p4)
272 {
273 m_px = p4.Px();
274 m_py = p4.Py();
275 m_pz = p4.Pz();
276 m_mass = p4.M();
277 }
278
283 void set4VectorDividingByMomentumScaling(const ROOT::Math::PxPyPzEVector& p4)
284 {
285 m_px = p4.Px() / m_momentumScale;
286 m_py = p4.Py() / m_momentumScale;
287 m_pz = p4.Pz() / m_momentumScale;
288 m_mass = p4.M();
289 }
290
295 void setVertex(const ROOT::Math::XYZVector& vertex)
296 {
297 m_x = vertex.X();
298 m_y = vertex.Y();
299 m_z = vertex.Z();
300 };
301
306 void setEnergyLossCorrection(double energyLossCorrection)
307 {
308 m_energyLossCorrection = energyLossCorrection;
309 }
310
316 {
317 if (m_energyLossCorrection == 0.0) {
318 return 1.0;
319 }
320 double origP = m_momentumScale * sqrt(m_px * m_px + m_py * m_py + m_pz * m_pz);
321 if (origP == 0.0) {
322 return 1.0;
323 }
324 double origE = sqrt(origP * origP + m_mass * m_mass);
325
326 double newP = sqrt((origE - m_energyLossCorrection) * (origE - m_energyLossCorrection) - m_mass * m_mass);
327 return newP / origP;
328 }
329
334 void setMomentumScalingFactor(double momentumScalingFactor)
335 {
336 m_momentumScalingFactor = momentumScalingFactor;
338 }
339
344 void setMomentumSmearingFactor(double momentumSmearingFactor)
345 {
346 m_momentumSmearingFactor = momentumSmearingFactor;
348 }
349
354 void setJacobiMatrix(const TMatrixF& jacobiMatrix);
355
360 void setMomentumVertexErrorMatrix(const TMatrixFSym& errMatrix);
361
366 void setPValue(double pValue)
367 {
368 m_pValue = pValue;
369 }
370
374 void setProperty(const int properties)
375 {
376 m_properties = properties;
377 }
378
386 void updateMomentum(const ROOT::Math::PxPyPzEVector& p4,
387 const ROOT::Math::XYZVector& vertex,
388 const TMatrixFSym& errMatrix,
389 double pValue)
390 {
391 set4Vector(p4);
392 setVertex(vertex);
394 m_pValue = pValue;
395 }
396
401 void updateMass(const int pdgCode);
402
409 void appendDaughter(const Particle* daughter, const bool updateType = true, const int daughterProperty = c_Ordinary);
410
416 void appendDaughter(int particleIndex, const bool updateType = true)
417 {
418 if (updateType) {
419 // is it a composite particle or fsr corrected?
420 m_particleSource = c_Composite;
421 }
422 m_daughterIndices.push_back(particleIndex);
423 m_daughterProperties.push_back(c_Ordinary);
424 }
425
431 void removeDaughter(const Particle* daughter, const bool updateType = true);
432
438 bool replaceDaughter(const Particle* oldDaughter, Particle* newDaughter);
439
446 bool replaceDaughterRecursively(const Particle* oldDaughter, Particle* newDaughter);
447
448 // getters
449
454 int getPDGCode(void) const
455 {
456 return m_pdgCode;
457 }
458
463 double getCharge(void) const;
464
470 {
471 return m_flavorType;
472 }
473
479 {
480 return m_particleSource;
481 }
482
487 unsigned getMdstArrayIndex(void) const
488 {
489 return m_mdstIndex;
490 }
491
498 int getProperty() const
499 {
500 return m_properties;
501 }
502
507 double getMass() const
508 {
509 return m_mass;
510 }
511
517 //double getMassError() const;
518
523 double getPDGMass(void) const;
524
529 double getPDGLifetime() const;
530
535 double getEnergy() const
536 {
537 return sqrt(m_momentumScale * m_momentumScale * m_px * m_px +
541 }
542
547 ROOT::Math::PxPyPzEVector get4Vector() const
548 {
549 double correction = getMomentumLossCorrectionFactor();
550 return ROOT::Math::PxPyPzEVector(m_momentumScale * correction * m_px,
551 m_momentumScale * correction * m_py,
552 m_momentumScale * correction * m_pz,
553 getEnergy());
554 }
555
560 ROOT::Math::XYZVector getMomentum() const
561 {
562 return m_momentumScale * getMomentumLossCorrectionFactor() * ROOT::Math::XYZVector(m_px, m_py, m_pz);
563 };
564
569 double getMomentumMagnitude() const
570 {
571 return getP();
572 };
573
578 double getP() const
579 {
581 };
582
587 double getPx() const
588 {
590 }
591
596 double getPy() const
597 {
599 }
600
605 double getPz() const
606 {
608 }
609
615 {
616 return m_momentumScale;
617 }
618
624 {
626 }
631 ROOT::Math::XYZVector getVertex() const
632 {
633 return ROOT::Math::XYZVector(m_x, m_y, m_z);
634 };
635
640 double getX() const
641 {
642 return m_x;
643 }
644
649 double getY() const
650 {
651 return m_y;
652 }
653
658 double getZ() const
659 {
660 return m_z;
661 }
662
667 double getPValue() const
668 {
669 return m_pValue;
670 }
671
676 TMatrixFSym getMomentumVertexErrorMatrix() const;
677
682 TMatrixFSym getMomentumErrorMatrix() const;
683
688 TMatrixFSym getVertexErrorMatrix() const;
689
699 double getCosHelicity(const Particle* mother = nullptr) const;
700
707 double getCosHelicityDaughter(unsigned iDaughter, unsigned iGrandDaughter = 0) const;
708
714 double getAcoplanarity() const;
715
716
721 int getMdstSource() const;
722
727 unsigned getNDaughters(void) const
728 {
729 return m_daughterIndices.size();
730 }
731
736 const std::vector<int>& getDaughterIndices() const
737 {
738 return m_daughterIndices;
739 }
740
745 const std::vector<int>& getDaughterProperties() const
746 {
748 }
749
755 const Particle* getDaughter(unsigned i) const;
756
766 bool forEachDaughter(const std::function<bool(const Particle*)>& function,
767 bool recursive = true, bool includeSelf = true) const;
768
773 std::vector<Belle2::Particle*> getDaughters() const;
774 //Need namespace qualifier because ROOT CINT has troubles otherwise
775
780 std::vector<const Belle2::Particle*> getFinalStateDaughters() const;
781 //Need namespace qualifier because ROOT CINT has troubles otherwise
782
787 std::vector<const Belle2::Particle*> getAllDaughters() const;
788 //Need namespace qualifier because ROOT CINT has troubles otherwise
789
796 std::vector<int> getMdstArrayIndices(EParticleSourceObject type) const;
797
803 bool overlapsWith(const Particle* oParticle) const;
804
826 bool isCopyOf(const Particle* oParticle, bool doDetailedComparison = false) const;
827
833 const Track* getTrack() const;
834
840 const TrackFitResult* getTrackFitResult() const;
841
848 const V0* getV0() const;
849
858 const PIDLikelihood* getPIDLikelihood() const;
859
866 const ECLCluster* getECLCluster() const;
867
873 double getECLClusterEnergy() const;
874
881 const KLMCluster* getKLMCluster() const;
882
890 const MCParticle* getMCParticle() const;
891
893 std::string getName() const override;
894
896 std::string getInfoHTML() const override;
897
901 void print() const;
902
904 std::vector<std::string> getExtraInfoNames() const;
905
909 void removeExtraInfo();
910
915 double getExtraInfo(const std::string& name) const;
916
918 bool hasExtraInfo(const std::string& name) const;
919
921 int getExtraInfoMap() const
922 {
923 return !m_extraInfo.empty() ? m_extraInfo[0] : -1;
924 }
925
927 unsigned int getExtraInfoSize() const
928 {
929 return m_extraInfo.size();
930 }
931
935 void writeExtraInfo(const std::string& name, const double value);
936
941 void setExtraInfo(const std::string& name, double value);
942
947 void addExtraInfo(const std::string& name, double value);
948
953 TClonesArray* getArrayPointer() const
954 {
955 if (!m_arrayPointer)
957 return m_arrayPointer;
958 }
959
966 {
967 return std::abs(m_pdgCodeUsedForFit);
968 }
969
976 {
977 return std::abs(m_pdgCodeUsedForFit) == std::abs(m_pdgCode);
978 }
979
984 bool isMostLikely() const;
985
990 std::pair<Const::ChargedStable, const TrackFitResult*> getMostLikelyTrackFitResult() const;
991
996 bool isMostLikelyTrackFitResult() const;
997
1002 {
1003 const int pdg = abs(getPDGCode());
1004 if ((pdg == Const::photon.getPDGCode())
1005 or (pdg == Const::electron.getPDGCode())
1006 or (pdg == Const::muon.getPDGCode())
1007 or (pdg == Const::pion.getPDGCode())
1008 or (pdg == Const::kaon.getPDGCode())
1009 or (pdg == Const::proton.getPDGCode())
1010 or (pdg == Const::deuteron.getPDGCode())) {
1012 } else if ((pdg == Const::Klong.getPDGCode())
1013 or (pdg == Const::neutron.getPDGCode())) {
1015 } else {
1017 }
1018 }
1019
1027 const Particle* getParticleFromGeneralizedIndexString(const std::string& generalizedIndex) const;
1028
1032 void updateJacobiMatrix();
1033
1040 void fillFSPDaughters(std::vector<const Belle2::Particle*>& fspDaughters) const;
1041
1048 void fillAllDaughters(std::vector<const Belle2::Particle*>& allDaughters) const;
1049
1050
1051 private:
1052
1053 // persistent data members
1056 double m_mass;
1057 double m_px;
1058 double m_py;
1059 double m_pz;
1060 double m_momentumScale = 1.0;
1064 double m_x;
1065 double m_y;
1066 double m_z;
1067 double m_errMatrix[c_SizeMatrix] = {};
1068 double m_jacobiMatrix[c_SizeMatrix] = {};
1069 double m_pValue;
1070 std::vector<int> m_daughterIndices;
1073 unsigned m_mdstIndex;
1075 std::vector<int> m_daughterProperties;
1085
1091 std::vector<double> m_extraInfo;
1092
1093 // transient data members
1100 mutable TClonesArray* m_arrayPointer;
1101
1102 // private methods
1106 void setMomentumPositionErrorMatrix(const TrackFitResult* trackFit);
1107
1112 void resetErrorMatrix();
1113
1118 void resetJacobiMatrix();
1119
1124 void storeErrorMatrix(const TMatrixFSym& errMatrix);
1125
1130 void storeJacobiMatrix(const TMatrixF& jacobiMatrix);
1131
1139 // TODO: this can be optimized for speed
1140 void fillDecayChain(std::vector<int>& decayChain) const;
1141
1145 void setFlavorType();
1146
1150 void setMdstArrayIndex(const int arrayIndex);
1151
1157 int generatePDGCodeFromCharge(const int chargedSign, const Const::ChargedStable& chargedStable);
1158
1160 // v8: added identifier, changed getMdstSource
1161 // v9: added m_pdgCodeUsedForFit
1162 // v10: added m_properties
1163 // v11: added m_daughterProperties
1164 // v12: renamed EParticleType m_particleType to EParticleSourceObject m_particleSource
1165 // v13: added m_momentumScale
1166 // v14: added m_jacobiMatrix
1167 // v15: added m_momentumScalingFactor and m_momentumSmearingFactor
1168 // v16: use double precision for private members
1169 // v17: added m_energyLossCorrection
1170 friend class ParticleSubset;
1171 };
1172
1174} // end namespace Belle2
Provides a type-safe way to pass members of the chargedStableSet set.
Definition: Const.h:589
The ParticleType class for identifying different particle types.
Definition: Const.h:408
static const ParticleType neutron
neutron particle
Definition: Const.h:675
static const ChargedStable muon
muon particle
Definition: Const.h:660
static const ChargedStable pion
charged pion particle
Definition: Const.h:661
static const ParticleType Klong
K^0_L particle.
Definition: Const.h:678
static const ChargedStable proton
proton particle
Definition: Const.h:663
static const ChargedStable kaon
charged kaon particle
Definition: Const.h:662
static const ParticleType photon
photon particle
Definition: Const.h:673
static const ChargedStable electron
electron particle
Definition: Const.h:659
static const ChargedStable deuteron
deuteron particle
Definition: Const.h:664
ECL cluster data.
Definition: ECLCluster.h:27
EHypothesisBit
The hypothesis bits for this ECLCluster (Connected region (CR) is split using this hypothesis.
Definition: ECLCluster.h:31
@ c_nPhotons
CR is split into n photons (N1)
@ c_neutralHadron
CR is reconstructed as a neutral hadron (N2)
@ c_none
None as initializer.
KLM cluster data.
Definition: KLMCluster.h:28
A Class to store the Monte Carlo particle information.
Definition: MCParticle.h:32
Class to collect log likelihoods from TOP, ARICH, dEdx, ECL and KLM aimed for output to mdst includes...
Definition: PIDLikelihood.h:29
Specialised SelectSubset<Particle> that also fixes daughter indices and all ParticleLists.
Class to store reconstructed particles.
Definition: Particle.h:75
void setProperty(const int properties)
sets m_properties
Definition: Particle.h:374
void removeExtraInfo()
Remove all stored extra info fields.
Definition: Particle.cc:1284
double getPx() const
Returns x component of momentum.
Definition: Particle.h:587
ClassDefOverride(Particle, 17)
Class to store reconstructed particles.
void updateJacobiMatrix()
Propagate the photon energy scaling to jacobian elements that were calculated using energy.
Definition: Particle.cc:257
TMatrixFSym getVertexErrorMatrix() const
Returns the 3x3 position error sub-matrix.
Definition: Particle.cc:447
bool isMostLikely() const
Returns true if the (track-based) particle is created with its most likely mass hypothesis based on P...
Definition: Particle.cc:1391
const KLMCluster * getKLMCluster() const
Returns the pointer to the KLMCluster object that was used to create this Particle (ParticleType == c...
Definition: Particle.cc:926
double m_momentumSmearingFactor
momentum smearing factor
Definition: Particle.h:1062
bool replaceDaughter(const Particle *oldDaughter, Particle *newDaughter)
Replace index of given daughter with new daughter, return true if a replacement is made.
Definition: Particle.cc:705
const Track * getTrack() const
Returns the pointer to the Track object that was used to create this Particle (ParticleType == c_Trac...
Definition: Particle.cc:845
void setMomentumPositionErrorMatrix(const TrackFitResult *trackFit)
Sets the momentum, position and error matrix for this particle (created from charged Track)
Definition: Particle.cc:1001
const std::vector< int > & getDaughterIndices() const
Returns a vector of store array indices of daughter particles.
Definition: Particle.h:736
void storeErrorMatrix(const TMatrixFSym &errMatrix)
Stores 7x7 error matrix into private member m_errMatrix.
Definition: Particle.cc:1091
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.
Definition: Particle.cc:1358
std::vector< const Belle2::Particle * > getFinalStateDaughters() const
Returns a vector of pointers to Final State daughter particles.
Definition: Particle.cc:649
const MCParticle * getMCParticle() const
Returns the pointer to the MCParticle object that was used to create this Particle (ParticleType == c...
Definition: Particle.cc:942
void appendDaughter(const Particle *daughter, const bool updateType=true, const int daughterProperty=c_Ordinary)
Appends index of daughter to daughters index array.
Definition: Particle.cc:676
const ECLCluster * getECLCluster() const
Returns the pointer to the ECLCluster object that was used to create this Particle (if ParticleType =...
Definition: Particle.cc:891
void setExtraInfo(const std::string &name, double value)
Sets the user-defined data of given name to the given value.
Definition: Particle.cc:1317
EParticleSourceObject
particle source enumerators
Definition: Particle.h:82
double m_pValue
chi^2 probability of the fit.
Definition: Particle.h:1069
double m_pz
momentum component z
Definition: Particle.h:1059
int m_pdgCodeUsedForFit
PDG code used for the track fit.
Definition: Particle.h:1055
double m_momentumScale
effective momentum scale factor
Definition: Particle.h:1060
std::string getName() const override
Return name of this particle.
Definition: Particle.cc:1165
bool overlapsWith(const Particle *oParticle) const
Returns true if final state ancestors of oParticle overlap.
Definition: Particle.cc:737
double getCosHelicityDaughter(unsigned iDaughter, unsigned iGrandDaughter=0) const
Returns cosine of the helicity angle of the given daughter defined by given grand daughter.
Definition: Particle.cc:502
double getPz() const
Returns z component of momentum.
Definition: Particle.h:605
std::vector< std::string > getExtraInfoNames() const
get a list of the extra info names
Definition: Particle.cc:1175
double getX() const
Returns x component of vertex position.
Definition: Particle.h:640
bool isCopyOf(const Particle *oParticle, bool doDetailedComparison=false) const
Returns true if this Particle and oParticle are copies of each other.
Definition: Particle.cc:752
const std::vector< int > & getDaughterProperties() const
Returns a vector of properties of daughter particles.
Definition: Particle.h:745
void writeExtraInfo(const std::string &name, const double value)
Sets the user defined extraInfo.
Definition: Particle.cc:1308
void setVertex(const ROOT::Math::XYZVector &vertex)
Sets position (decay vertex)
Definition: Particle.h:295
std::vector< int > getMdstArrayIndices(EParticleSourceObject type) const
Returns a vector of StoreArray indices of given MDST dataobjects.
Definition: Particle.cc:665
double m_jacobiMatrix[c_SizeMatrix]
error matrix (1D representation)
Definition: Particle.h:1068
void resetJacobiMatrix()
Resets 4x6 error matrix All elements are set to 0.0.
Definition: Particle.cc:1085
void set4VectorDividingByMomentumScaling(const ROOT::Math::PxPyPzEVector &p4)
Sets Lorentz vector dividing by the momentum scaling factor.
Definition: Particle.h:283
void storeJacobiMatrix(const TMatrixF &jacobiMatrix)
Stores 4x6 Jacobi matrix into private member m_jacobiMatrix.
Definition: Particle.cc:1102
bool isMostLikelyTrackFitResult() const
Returns true if the (track-based) particle is created with its most likely mass hypothesis based on T...
Definition: Particle.cc:1416
std::vector< double > m_extraInfo
Stores associated user defined values.
Definition: Particle.h:1091
double getEffectiveMomentumScale() const
Returns effective momentum scale which is the product of the momentum scaling and smearing factors.
Definition: Particle.h:614
unsigned m_mdstIndex
0-based index of MDST store array object
Definition: Particle.h:1073
double getPValue() const
Returns chi^2 probability of fit if done or -1.
Definition: Particle.h:667
void setFlavorType()
sets m_flavorType using m_pdgCode
Definition: Particle.cc:1150
double getEnergy() const
Returns total energy.
Definition: Particle.h:535
void setMomentumScalingFactor(double momentumScalingFactor)
Sets momentum scaling.
Definition: Particle.h:334
int getMdstSource() const
Returns unique identifier of final state particle (needed in particle combiner)
Definition: Particle.cc:369
ROOT::Math::XYZVector getVertex() const
Returns vertex position (POCA for charged, IP for neutral FS particles)
Definition: Particle.h:631
void fillAllDaughters(std::vector< const Belle2::Particle * > &allDaughters) const
Fill all generations' daughters into a vector.
Definition: Particle.cc:1127
bool hasExtraInfo(const std::string &name) const
Return whether the extra info with the given name is set.
Definition: Particle.cc:1266
std::string getInfoHTML() const override
Return a short summary of this object's contents in HTML format.
Definition: Particle.cc:1188
void setMdstArrayIndex(const int arrayIndex)
set mdst array index
Definition: Particle.cc:350
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...
Definition: Particle.cc:956
unsigned getMdstArrayIndex(void) const
Returns 0-based index of MDST store array object (0 for composite particles)
Definition: Particle.h:487
double m_py
momentum component y
Definition: Particle.h:1058
int getPDGCodeUsedForFit() const
Return the always positive PDG code which was used for the track fit (if there was a track fit) of th...
Definition: Particle.h:965
double m_x
position component x
Definition: Particle.h:1064
double m_px
momentum component x
Definition: Particle.h:1057
double getMomentumLossCorrectionFactor() const
Returns effect of energy correction on the particle momentum.
Definition: Particle.h:315
std::pair< Const::ChargedStable, const TrackFitResult * > getMostLikelyTrackFitResult() const
For a (track-based) particle, returns the charged stable mass hypothesis associated to the most proba...
Definition: Particle.cc:1398
EFlavorType getFlavorType() const
Returns flavor type of the decay (for FS particles: flavor type of particle)
Definition: Particle.h:469
~Particle()
Destructor.
void fillFSPDaughters(std::vector< const Belle2::Particle * > &fspDaughters) const
Fill final state particle daughters into a vector.
Definition: Particle.cc:1114
const PIDLikelihood * getPIDLikelihood() const
Returns the pointer to the PIDLikelihood object that is related to the Track, which was used to creat...
Definition: Particle.cc:871
const V0 * getV0() const
Returns the pointer to the V0 object that was used to create this Particle (if ParticleType == c_V0).
Definition: Particle.cc:880
TClonesArray * m_arrayPointer
Internal pointer to DataStore array containing the daughters of this particle.
Definition: Particle.h:1100
EParticleSourceObject m_particleSource
(mdst) source of particle
Definition: Particle.h:1072
void fillDecayChain(std::vector< int > &decayChain) const
Fill vector with (PDGCode, MdstSource) pairs for the entire decay chain.
Definition: Particle.cc:1140
int getPDGCode(void) const
Returns PDG code.
Definition: Particle.h:454
double getPy() const
Returns y component of momentum.
Definition: Particle.h:596
bool wasExactFitHypothesisUsed() const
Returns true if the type represented by this Particle object was used use as a mass hypothesis during...
Definition: Particle.h:975
int getProperty() const
Returns particle property as a bit pattern The values are defined in the PropertyFlags enum and descr...
Definition: Particle.h:498
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 ...
Definition: Particle.cc:459
double m_momentumScalingFactor
momentum scaling factor
Definition: Particle.h:1061
unsigned getNDaughters(void) const
Returns number of daughter particles.
Definition: Particle.h:727
std::vector< Belle2::Particle * > getDaughters() const
Returns a vector of pointers to daughter particles.
Definition: Particle.cc:637
TClonesArray * getArrayPointer() const
Returns the pointer to the store array which holds the daughter particles.
Definition: Particle.h:953
double getZ() const
Returns z component of vertex position.
Definition: Particle.h:658
void resetErrorMatrix()
Resets 7x7 error matrix All elements are set to 0.0.
Definition: Particle.cc:1079
double getPDGMass(void) const
Returns uncertainty on the invariant mass (requires valid momentum error matrix)
Definition: Particle.cc:604
void setMomentumSmearingFactor(double momentumSmearingFactor)
Sets momentum smearing.
Definition: Particle.h:344
EFlavorType m_flavorType
flavor type.
Definition: Particle.h:1071
double m_energyLossCorrection
energy loss correction.
Definition: Particle.h:1063
int generatePDGCodeFromCharge(const int chargedSign, const Const::ChargedStable &chargedStable)
Generate the PDG code with correct sign, using the charge.
Definition: Particle.cc:1382
double getCharge(void) const
Returns particle charge.
Definition: Particle.cc:622
ROOT::Math::PxPyPzEVector get4Vector() const
Returns Lorentz vector.
Definition: Particle.h:547
void appendDaughter(int particleIndex, const bool updateType=true)
Appends index of daughter to daughters index array.
Definition: Particle.h:416
Particle()
Default constructor.
Definition: Particle.cc:45
TMatrixFSym getMomentumErrorMatrix() const
Returns the 4x4 momentum error matrix.
Definition: Particle.cc:435
double m_mass
particle (invariant) mass
Definition: Particle.h:1056
std::vector< const Belle2::Particle * > getAllDaughters() const
Returns a vector of pointers to all generations' daughter particles.
Definition: Particle.cc:657
double getAcoplanarity() const
Returns acoplanarity angle defined as the angle between the decay planes of the grand daughters in th...
Definition: Particle.cc:533
std::vector< int > m_daughterProperties
daughter particle properties
Definition: Particle.h:1075
double m_errMatrix[c_SizeMatrix]
error matrix (1D representation)
Definition: Particle.h:1067
std::vector< int > m_daughterIndices
daughter particle indices
Definition: Particle.h:1070
double getY() const
Returns y component of vertex position.
Definition: Particle.h:649
void addExtraInfo(const std::string &name, double value)
Sets the user-defined data of given name to the given value.
Definition: Particle.cc:1336
void set4Vector(const ROOT::Math::PxPyPzEVector &p4)
Sets Lorentz vector.
Definition: Particle.h:271
void setEnergyLossCorrection(double energyLossCorrection)
Sets Energy loss correction.
Definition: Particle.h:306
void setJacobiMatrix(const TMatrixF &jacobiMatrix)
Sets 4x6 jacobi matrix.
Definition: Particle.cc:407
int getExtraInfoMap() const
Return the id of the associated ParticleExtraInfoMap or -1 if no map is set.
Definition: Particle.h:921
double getPDGLifetime() const
Returns particle nominal lifetime.
Definition: Particle.cc:613
void setMomentumVertexErrorMatrix(const TMatrixFSym &errMatrix)
Sets 7x7 error matrix.
Definition: Particle.cc:393
ROOT::Math::XYZVector getMomentum() const
Returns momentum vector.
Definition: Particle.h:560
void setPValue(double pValue)
Sets chi^2 probability of fit.
Definition: Particle.h:366
EParticleSourceObject getParticleSource() const
Returns particle source as defined with enum EParticleSourceObject.
Definition: Particle.h:478
void updateMass(const int pdgCode)
Updates particle mass with the mass of the particle corresponding to the given PDG.
Definition: Particle.cc:597
double m_z
position component z
Definition: Particle.h:1066
void print() const
Prints the contents of a Particle object to standard output.
Definition: Particle.cc:1170
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.
Definition: Particle.h:386
EFlavorType
describes flavor type, see getFlavorType().
Definition: Particle.h:94
@ c_Unflavored
Is its own antiparticle or we don't know whether it is a particle/antiparticle.
Definition: Particle.h:95
@ c_Flavored
Is either particle or antiparticle.
Definition: Particle.h:96
int m_pdgCode
PDG code.
Definition: Particle.h:1054
TMatrixFSym getMomentumVertexErrorMatrix() const
Returns 7x7 error matrix.
Definition: Particle.cc:420
PropertyFlags
Flags that describe the particle property, which are used in the MC matching.
Definition: Particle.h:116
@ c_IsIgnoreNeutrino
Is the particle MC matched with the ignore missing neutrino flag set?
Definition: Particle.h:122
@ c_IsIgnoreRadiatedPhotons
Is the particle MC matched with the ignore radiated photon flag set?
Definition: Particle.h:119
@ c_IsIgnoreGamma
Is the particle MC matched with the ignore missing gamma flag set?
Definition: Particle.h:123
@ c_IsUnspecified
Ordinary particles.
Definition: Particle.h:118
@ c_IsIgnoreBrems
Is the particle MC matched with the ignore added Brems gamma flag set?
Definition: Particle.h:124
@ c_IsIgnoreDecayInFlight
Is the particle MC matched with the ignore DecayInFlight flag set?
Definition: Particle.h:126
@ c_IsIgnoreMisID
Is the particle MC matched with the ignore MisID flag set?
Definition: Particle.h:125
@ c_IsIgnoreIntermediate
Is the particle MC matched with the ignore intermediate resonances flag set?
Definition: Particle.h:120
@ c_IsIgnoreMassive
Is the particle MC matched with the ignore missing massive particle flag set?
Definition: Particle.h:121
double getEnergyLossCorrection() const
Returns Energy Loss Correction.
Definition: Particle.h:623
double getECLClusterEnergy() const
Returns the energy of the ECLCluster for the particle.
Definition: Particle.cc:919
const TrackFitResult * getTrackFitResult() const
Returns the pointer to the TrackFitResult that was used to create this Particle (ParticleType == c_Tr...
Definition: Particle.cc:854
double getMomentumMagnitude() const
Returns momentum magnitude.
Definition: Particle.h:569
void removeDaughter(const Particle *daughter, const bool updateType=true)
Removes index of daughter from daughters index array.
Definition: Particle.cc:688
double getP() const
Returns momentum magnitude (same as getMomentumMagnitude but with shorter name)
Definition: Particle.h:578
double m_y
position component y
Definition: Particle.h:1065
void setPDGCode(const int pdg)
Sets PDG code.
Definition: Particle.h:262
unsigned int getExtraInfoSize() const
Return the size of the extra info array.
Definition: Particle.h:927
int m_identifier
Identifier that can be used to identify whether the particle is unique or is a copy or representation...
Definition: Particle.h:1084
int m_properties
particle property
Definition: Particle.h:1074
const Particle * getDaughter(unsigned i) const
Returns a pointer to the i-th daughter particle.
Definition: Particle.cc:631
double getExtraInfo(const std::string &name) const
Return given value if set.
Definition: Particle.cc:1289
ECLCluster::EHypothesisBit getECLClusterEHypothesisBit() const
Returns the ECLCluster EHypothesisBit for this Particle.
Definition: Particle.h:1001
bool replaceDaughterRecursively(const Particle *oldDaughter, Particle *newDaughter)
Apply replaceDaughter to all Particles in the decay tree by looping recursively through it,...
Definition: Particle.cc:723
double getMass() const
Returns invariant mass (= nominal for FS particles)
Definition: Particle.h:507
Defines interface for accessing relations of objects in StoreArray.
TClonesArray * getArrayPointer() const
Returns the pointer to the raw DataStore array holding this object (protected since these arrays are ...
Values of the result of a track fit with a given particle hypothesis.
Class that bundles various TrackFitResults.
Definition: Track.h:25
Object holding information for V0s.
Definition: V0.h:34
Abstract base class for different kinds of events.
Definition: ClusterUtils.h:24