Belle II Software  light-2212-foldex
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 <TMatrixFSymfwd.h>
18 
19 #include <vector>
20 
21 class TClonesArray;
22 
23 namespace Belle2 {
29  // forward declarations
30  class KLMCluster;
31  class Track;
32  class TrackFitResult;
33  class MCParticle;
34  class PIDLikelihood;
35  class V0;
36 
74  class Particle : public RelationsObject {
75 
76  public:
77 
82  c_Undefined = 0,
83  c_Track = 1,
84  c_ECLCluster = 2,
85  c_KLMCluster = 3,
86  c_V0 = 4,
87  c_MCParticle = 5,
88  c_Composite = 6,
89  c_NoMDSTSource = 7
90  };
91 
93  enum EFlavorType {
95  c_Flavored = 1,
96  };
97 
101  enum {c_DimPosition = 3, c_DimMomentum = 4, c_DimMatrix = 7,
102  c_SizeMatrix = c_DimMatrix * (c_DimMatrix + 1) / 2
103  };
104 
109  enum {c_Px, c_Py, c_Pz, c_E, c_X, c_Y, c_Z};
110 
116  c_Ordinary = 0,
126  };
127 
132  Particle();
133 
140  Particle(const ROOT::Math::PxPyPzEVector& momentum, const int pdgCode);
141 
151  Particle(const ROOT::Math::PxPyPzEVector& momentum,
152  const int pdgCode,
153  EFlavorType flavorType,
154  const EParticleSourceObject particleType,
155  const unsigned mdstIndex);
156 
166  Particle(const ROOT::Math::PxPyPzEVector& momentum,
167  const int pdgCode,
168  EFlavorType flavorType,
169  const std::vector<int>& daughterIndices,
170  TClonesArray* arrayPointer = nullptr);
171 
182  Particle(const ROOT::Math::PxPyPzEVector& momentum,
183  const int pdgCode,
184  EFlavorType flavorType,
185  const std::vector<int>& daughterIndices,
186  int properties,
187  TClonesArray* arrayPointer = nullptr);
188 
200  Particle(const ROOT::Math::PxPyPzEVector& momentum,
201  const int pdgCode,
202  EFlavorType flavorType,
203  const std::vector<int>& daughterIndices,
204  int properties,
205  const std::vector<int>& daughterProperties,
206  TClonesArray* arrayPointer = nullptr);
207 
213  Particle(const Track* track,
214  const Const::ChargedStable& chargedStable);
215 
226  [[deprecated("Please use the constructor without the chargedStableUsedForFit")]]
227  Particle(const int trackArrayIndex,
228  const TrackFitResult* trackFit,
229  const Const::ChargedStable& chargedStable,
230  const Const::ChargedStable& chargedStableUsedForFit);
231 
240  Particle(int trackArrayIndex, const TrackFitResult* trackFit,
241  const Const::ChargedStable& chargedStable);
242 
248  explicit Particle(const ECLCluster* eclCluster,
249  const Const::ParticleType& type = Const::photon);
250 
256  explicit Particle(const KLMCluster* klmCluster, const int pdgCode = Const::Klong.getPDGCode());
257 
262  explicit Particle(const MCParticle* MCparticle);
263 
268 
269  public:
270 
271  // setters
272 
277  void setPDGCode(const int pdg)
278  {
279  m_pdgCode = pdg;
280  }
281 
286  void set4Vector(const ROOT::Math::PxPyPzEVector& p4)
287  {
288  m_px = p4.Px();
289  m_py = p4.Py();
290  m_pz = p4.Pz();
291  m_mass = p4.M();
292  }
293 
298  void set4VectorDividingByMomentumScaling(const ROOT::Math::PxPyPzEVector& p4)
299  {
300  m_px = p4.Px() / m_momentumScale;
301  m_py = p4.Py() / m_momentumScale;
302  m_pz = p4.Pz() / m_momentumScale;
303  m_mass = p4.M();
304  }
305 
310  void setVertex(const ROOT::Math::XYZVector& vertex)
311  {
312  m_x = vertex.X();
313  m_y = vertex.Y();
314  m_z = vertex.Z();
315  };
316 
321  void setMomentumScalingFactor(double momentumScalingFactor)
322  {
323  m_momentumScalingFactor = momentumScalingFactor;
325  }
326 
331  void setMomentumSmearingFactor(double momentumSmearingFactor)
332  {
333  m_momentumSmearingFactor = momentumSmearingFactor;
335  }
336 
341  void setJacobiMatrix(const TMatrixF& jacobiMatrix);
342 
347  void setMomentumVertexErrorMatrix(const TMatrixFSym& errMatrix);
348 
353  void setPValue(double pValue)
354  {
355  m_pValue = pValue;
356  }
357 
361  void setProperty(const int properties)
362  {
363  m_properties = properties;
364  }
365 
373  void updateMomentum(const ROOT::Math::PxPyPzEVector& p4,
374  const ROOT::Math::XYZVector& vertex,
375  const TMatrixFSym& errMatrix,
376  double pValue)
377  {
378  set4Vector(p4);
379  setVertex(vertex);
380  setMomentumVertexErrorMatrix(errMatrix);
381  m_pValue = pValue;
382  }
383 
388  void updateMass(const int pdgCode);
389 
396  void appendDaughter(const Particle* daughter, const bool updateType = true, const int daughterProperty = c_Ordinary);
397 
403  void appendDaughter(int particleIndex, const bool updateType = true)
404  {
405  if (updateType) {
406  // is it a composite particle or fsr corrected?
407  m_particleSource = c_Composite;
408  }
409  m_daughterIndices.push_back(particleIndex);
410  m_daughterProperties.push_back(c_Ordinary);
411  }
412 
418  void removeDaughter(const Particle* daughter, const bool updateType = true);
419 
425  bool replaceDaughter(const Particle* oldDaughter, const Particle* newDaughter);
426 
433  bool replaceDaughterRecursively(const Particle* oldDaughter, const Particle* newDaughter);
434 
435  // getters
436 
441  int getPDGCode(void) const
442  {
443  return m_pdgCode;
444  }
445 
450  double getCharge(void) const;
451 
457  {
458  return m_flavorType;
459  }
460 
466  {
467  return m_particleSource;
468  }
469 
474  unsigned getMdstArrayIndex(void) const
475  {
476  return m_mdstIndex;
477  }
478 
485  int getProperty() const
486  {
487  return m_properties;
488  }
489 
494  double getMass() const
495  {
496  return m_mass;
497  }
498 
504  //double getMassError() const;
505 
510  double getPDGMass(void) const;
511 
516  double getPDGLifetime() const;
517 
522  double getEnergy() const
523  {
526  }
527 
532  ROOT::Math::PxPyPzEVector get4Vector() const
533  {
534  return ROOT::Math::PxPyPzEVector(m_momentumScale * m_px, m_momentumScale * m_py, m_momentumScale * m_pz, getEnergy());
535  }
536 
541  ROOT::Math::XYZVector getMomentum() const
542  {
543  return m_momentumScale * ROOT::Math::XYZVector(m_px, m_py, m_pz);
544  };
545 
550  double getMomentumMagnitude() const
551  {
552  return m_momentumScale * sqrt(m_px * m_px + m_py * m_py + m_pz * m_pz);
553  };
554 
559  double getP() const
560  {
561  return m_momentumScale * sqrt(m_px * m_px + m_py * m_py + m_pz * m_pz);
562  };
563 
568  double getPx() const
569  {
570  return m_momentumScale * m_px;
571  }
572 
577  double getPy() const
578  {
579  return m_momentumScale * m_py;
580  }
581 
586  double getPz() const
587  {
588  return m_momentumScale * m_pz;
589  }
590 
596  {
597  return m_momentumScale;
598  }
599 
604  ROOT::Math::XYZVector getVertex() const
605  {
606  return ROOT::Math::XYZVector(m_x, m_y, m_z);
607  };
608 
613  double getX() const
614  {
615  return m_x;
616  }
617 
622  double getY() const
623  {
624  return m_y;
625  }
626 
631  double getZ() const
632  {
633  return m_z;
634  }
635 
640  double getPValue() const
641  {
642  return m_pValue;
643  }
644 
649  TMatrixFSym getMomentumVertexErrorMatrix() const;
650 
655  TMatrixFSym getMomentumErrorMatrix() const;
656 
661  TMatrixFSym getVertexErrorMatrix() const;
662 
672  double getCosHelicity(const Particle* mother = nullptr) const;
673 
680  double getCosHelicityDaughter(unsigned iDaughter, unsigned iGrandDaughter = 0) const;
681 
687  double getAcoplanarity() const;
688 
689 
694  int getMdstSource() const;
695 
700  unsigned getNDaughters(void) const
701  {
702  return m_daughterIndices.size();
703  }
704 
709  const std::vector<int>& getDaughterIndices() const
710  {
711  return m_daughterIndices;
712  }
713 
718  const std::vector<int>& getDaughterProperties() const
719  {
720  return m_daughterProperties;
721  }
722 
728  const Particle* getDaughter(unsigned i) const;
729 
739  bool forEachDaughter(const std::function<bool(const Particle*)>& function,
740  bool recursive = true, bool includeSelf = true) const;
741 
746  std::vector<Belle2::Particle*> getDaughters() const;
747  //Need namespace qualifier because ROOT CINT has troubles otherwise
748 
753  std::vector<const Belle2::Particle*> getFinalStateDaughters() const;
754  //Need namespace qualifier because ROOT CINT has troubles otherwise
755 
760  std::vector<const Belle2::Particle*> getAllDaughters() const;
761  //Need namespace qualifier because ROOT CINT has troubles otherwise
762 
769  std::vector<int> getMdstArrayIndices(EParticleSourceObject type) const;
770 
776  bool overlapsWith(const Particle* oParticle) const;
777 
799  bool isCopyOf(const Particle* oParticle, bool doDetailedComparison = false) const;
800 
806  const Track* getTrack() const;
807 
813  const TrackFitResult* getTrackFitResult() const;
814 
821  const V0* getV0() const;
822 
831  const PIDLikelihood* getPIDLikelihood() const;
832 
839  const ECLCluster* getECLCluster() const;
840 
846  double getECLClusterEnergy() const;
847 
854  const KLMCluster* getKLMCluster() const;
855 
863  const MCParticle* getMCParticle() const;
864 
866  std::string getName() const override;
867 
869  std::string getInfoHTML() const override;
870 
874  void print() const;
875 
877  std::vector<std::string> getExtraInfoNames() const;
878 
882  void removeExtraInfo();
883 
888  double getExtraInfo(const std::string& name) const;
889 
891  bool hasExtraInfo(const std::string& name) const;
892 
894  int getExtraInfoMap() const
895  {
896  return !m_extraInfo.empty() ? m_extraInfo[0] : -1;
897  }
898 
900  unsigned int getExtraInfoSize() const
901  {
902  return m_extraInfo.size();
903  }
904 
908  void writeExtraInfo(const std::string& name, const double value);
909 
914  void setExtraInfo(const std::string& name, double value);
915 
920  void addExtraInfo(const std::string& name, double value);
921 
926  TClonesArray* getArrayPointer() const
927  {
928  if (!m_arrayPointer)
930  return m_arrayPointer;
931  }
932 
939  {
940  return std::abs(m_pdgCodeUsedForFit);
941  }
942 
949  {
950  return std::abs(m_pdgCodeUsedForFit) == std::abs(m_pdgCode);
951  }
952 
957  bool isMostLikely() const;
958 
963  std::pair<Const::ChargedStable, const TrackFitResult*> getMostLikelyTrackFitResult() const;
964 
969  bool isMostLikelyTrackFitResult() const;
970 
975  {
976  const int pdg = abs(getPDGCode());
977  if ((pdg == Const::photon.getPDGCode())
978  or (pdg == Const::electron.getPDGCode())
979  or (pdg == Const::muon.getPDGCode())
980  or (pdg == Const::pion.getPDGCode())
981  or (pdg == Const::kaon.getPDGCode())
982  or (pdg == Const::proton.getPDGCode())
983  or (pdg == Const::deuteron.getPDGCode())) {
985  } else if ((pdg == Const::Klong.getPDGCode())
986  or (pdg == Const::neutron.getPDGCode())) {
988  } else {
990  }
991  }
992 
1000  const Particle* getParticleFromGeneralizedIndexString(const std::string& generalizedIndex) const;
1001 
1005  void updateJacobiMatrix();
1006 
1007  private:
1008 
1009  // persistent data members
1012  double m_mass;
1013  double m_px;
1014  double m_py;
1015  double m_pz;
1016  double m_momentumScale = 1.0;
1019  double m_x;
1020  double m_y;
1021  double m_z;
1022  double m_errMatrix[c_SizeMatrix] = {};
1023  double m_jacobiMatrix[c_SizeMatrix] = {};
1024  double m_pValue;
1025  std::vector<int> m_daughterIndices;
1028  unsigned m_mdstIndex;
1030  std::vector<int> m_daughterProperties;
1039  int m_identifier = -1;
1040 
1046  std::vector<double> m_extraInfo;
1047 
1048  // transient data members
1055  mutable TClonesArray* m_arrayPointer;
1056 
1057  // private methods
1061  void setMomentumPositionErrorMatrix(const TrackFitResult* trackFit);
1062 
1067  void resetErrorMatrix();
1068 
1073  void resetJacobiMatrix();
1074 
1079  void storeErrorMatrix(const TMatrixFSym& errMatrix);
1080 
1085  void storeJacobiMatrix(const TMatrixF& jacobiMatrix);
1092  void fillFSPDaughters(std::vector<const Belle2::Particle*>& fspDaughters) const;
1099  void fillAllDaughters(std::vector<const Belle2::Particle*>& allDaughters) const;
1100 
1108  // TODO: this can be optimized for speed
1109  void fillDecayChain(std::vector<int>& decayChain) const;
1110 
1114  void setFlavorType();
1115 
1119  void setMdstArrayIndex(const int arrayIndex);
1120 
1126  int generatePDGCodeFromCharge(const int chargedSign, const Const::ChargedStable& chargedStable);
1127 
1129  // v8: added identifier, changed getMdstSource
1130  // v9: added m_pdgCodeUsedForFit
1131  // v10: added m_properties
1132  // v11: added m_daughterProperties
1133  // v12: renamed EParticleType m_particleType to EParticleSourceObject m_particleSource
1134  // v13: added m_momentumScale
1135  // v14: added m_jacobiMatrix
1136  // v15: added m_momentumScalingFactor and m_momentumSmearingFactor
1137  // v16: use double precision for private members
1138 
1139  friend class ParticleSubset;
1140  };
1141 
1143 } // end namespace Belle2
Provides a type-safe way to pass members of the chargedStableSet set.
Definition: Const.h:580
The ParticleType class for identifying different particle types.
Definition: Const.h:399
static const ParticleType neutron
neutron particle
Definition: Const.h:666
static const ChargedStable muon
muon particle
Definition: Const.h:651
static const ChargedStable pion
charged pion particle
Definition: Const.h:652
static const ParticleType Klong
K^0_L particle.
Definition: Const.h:668
static const ChargedStable proton
proton particle
Definition: Const.h:654
static const ChargedStable kaon
charged kaon particle
Definition: Const.h:653
static const ParticleType photon
photon particle
Definition: Const.h:664
static const ChargedStable electron
electron particle
Definition: Const.h:650
static const ChargedStable deuteron
deuteron particle
Definition: Const.h:655
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:26
Specialised SelectSubset<Particle> that also fixes daughter indices and all ParticleLists.
Class to store reconstructed particles.
Definition: Particle.h:74
void setProperty(const int properties)
sets m_properties
Definition: Particle.h:361
void removeExtraInfo()
Remove all stored extra info fields.
Definition: Particle.cc:1311
double getPx() const
Returns x component of momentum.
Definition: Particle.h:568
void updateJacobiMatrix()
Propagate the photon energy scaling to jacobian elements that were calculated using energy.
Definition: Particle.cc:285
TMatrixFSym getVertexErrorMatrix() const
Returns the 3x3 position error sub-matrix.
Definition: Particle.cc:479
bool isMostLikely() const
Returns true if the (track-based) particle is created with its most likely mass hypothesis based on P...
Definition: Particle.cc:1418
const KLMCluster * getKLMCluster() const
Returns the pointer to the KLMCluster object that was used to create this Particle (ParticleType == c...
Definition: Particle.cc:956
double m_momentumSmearingFactor
momentum smearing factor
Definition: Particle.h:1018
const Track * getTrack() const
Returns the pointer to the Track object that was used to create this Particle (ParticleType == c_Trac...
Definition: Particle.cc:875
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.
void setMomentumPositionErrorMatrix(const TrackFitResult *trackFit)
Sets the momentum, position and error matrix for this particle (created from charged Track)
Definition: Particle.cc:1031
void storeErrorMatrix(const TMatrixFSym &errMatrix)
Stores 7x7 error matrix into private member m_errMatrix.
Definition: Particle.cc:1121
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:1385
std::vector< const Belle2::Particle * > getFinalStateDaughters() const
Returns a vector of pointers to Final State daughter particles.
Definition: Particle.cc:681
const MCParticle * getMCParticle() const
Returns the pointer to the MCParticle object that was used to create this Particle (ParticleType == c...
Definition: Particle.cc:972
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:708
const ECLCluster * getECLCluster() const
Returns the pointer to the ECLCluster object that was used to create this Particle (if ParticleType =...
Definition: Particle.cc:921
void setExtraInfo(const std::string &name, double value)
Sets the user-defined data of given name to the given value.
Definition: Particle.cc:1344
EParticleSourceObject
particle source enumerators
Definition: Particle.h:81
double m_pValue
chi^2 probability of the fit.
Definition: Particle.h:1024
double m_pz
momentum component z
Definition: Particle.h:1015
int m_pdgCodeUsedForFit
PDG code used for the track fit.
Definition: Particle.h:1011
double m_momentumScale
effective momentum scale factor
Definition: Particle.h:1016
std::string getName() const override
Return name of this particle.
Definition: Particle.cc:1195
bool overlapsWith(const Particle *oParticle) const
Returns true if final state ancestors of oParticle overlap.
Definition: Particle.cc:767
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:534
TClonesArray * getArrayPointer() const
Returns the pointer to the store array which holds the daughter particles.
Definition: Particle.h:926
double getPz() const
Returns z component of momentum.
Definition: Particle.h:586
std::vector< std::string > getExtraInfoNames() const
get a list of the extra info names
Definition: Particle.cc:1205
double getX() const
Returns x component of vertex position.
Definition: Particle.h:613
bool isCopyOf(const Particle *oParticle, bool doDetailedComparison=false) const
Returns true if this Particle and oParticle are copies of each other.
Definition: Particle.cc:782
void writeExtraInfo(const std::string &name, const double value)
Sets the user defined extraInfo.
Definition: Particle.cc:1335
void setVertex(const ROOT::Math::XYZVector &vertex)
Sets position (decay vertex)
Definition: Particle.h:310
std::vector< int > getMdstArrayIndices(EParticleSourceObject type) const
Returns a vector of StoreArray indices of given MDST dataobjects.
Definition: Particle.cc:697
double m_jacobiMatrix[c_SizeMatrix]
error matrix (1D representation)
Definition: Particle.h:1023
void resetJacobiMatrix()
Resets 4x6 error matrix All elements are set to 0.0.
Definition: Particle.cc:1115
void set4VectorDividingByMomentumScaling(const ROOT::Math::PxPyPzEVector &p4)
Sets Lorentz vector dividing by the momentum scaling factor.
Definition: Particle.h:298
void storeJacobiMatrix(const TMatrixF &jacobiMatrix)
Stores 4x6 Jacobi matrix into private member m_jacobiMatrix.
Definition: Particle.cc:1132
bool isMostLikelyTrackFitResult() const
Returns true if the (track-based) particle is created with its most likely mass hypothesis based on T...
Definition: Particle.cc:1443
std::vector< double > m_extraInfo
Stores associated user defined values.
Definition: Particle.h:1046
double getEffectiveMomentumScale() const
Returns effective momentum scale which is the product of the momentum scaling and smearing factors.
Definition: Particle.h:595
unsigned m_mdstIndex
0-based index of MDST store array object
Definition: Particle.h:1028
double getPValue() const
Returns chi^2 probability of fit if done or -1.
Definition: Particle.h:640
Particle(const ROOT::Math::PxPyPzEVector &momentum, const int pdgCode)
Constructor from a Lorentz vector and PDG code.
void setFlavorType()
sets m_flavorType using m_pdgCode
Definition: Particle.cc:1180
double getEnergy() const
Returns total energy.
Definition: Particle.h:522
void setMomentumScalingFactor(double momentumScalingFactor)
Sets momentum scaling.
Definition: Particle.h:321
int getMdstSource() const
Returns unique identifier of final state particle (needed in particle combiner)
Definition: Particle.cc:399
ROOT::Math::XYZVector getVertex() const
Returns vertex position (POCA for charged, IP for neutral FS particles)
Definition: Particle.h:604
void fillAllDaughters(std::vector< const Belle2::Particle * > &allDaughters) const
Fill all generations' daughters into a vector.
Definition: Particle.cc:1157
bool hasExtraInfo(const std::string &name) const
Return whether the extra info with the given name is set.
Definition: Particle.cc:1293
std::string getInfoHTML() const override
Return a short summary of this object's contents in HTML format.
Definition: Particle.cc:1218
void setMdstArrayIndex(const int arrayIndex)
set mdst array index
Definition: Particle.cc:378
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:986
unsigned getMdstArrayIndex(void) const
Returns 0-based index of MDST store array object (0 for composite particles)
Definition: Particle.h:474
double m_py
momentum component y
Definition: Particle.h:1014
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:938
double m_x
position component x
Definition: Particle.h:1019
double m_px
momentum component x
Definition: Particle.h:1013
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:1425
EFlavorType getFlavorType() const
Returns flavor type of the decay (for FS particles: flavor type of particle)
Definition: Particle.h:456
~Particle()
Destructor.
void fillFSPDaughters(std::vector< const Belle2::Particle * > &fspDaughters) const
Fill final state particle daughters into a vector.
Definition: Particle.cc:1144
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:901
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:910
TClonesArray * m_arrayPointer
Internal pointer to DataStore array containing the daughters of this particle.
Definition: Particle.h:1055
EParticleSourceObject m_particleSource
(mdst) source of particle
Definition: Particle.h:1027
void fillDecayChain(std::vector< int > &decayChain) const
Fill vector with (PDGCode, MdstSource) pairs for the entire decay chain.
Definition: Particle.cc:1170
int getPDGCode(void) const
Returns PDG code.
Definition: Particle.h:441
double getPy() const
Returns y component of momentum.
Definition: Particle.h:577
bool wasExactFitHypothesisUsed() const
Returns true if the type represented by this Particle object was used use as a mass hypothesis during...
Definition: Particle.h:948
int getProperty() const
Returns particle property as a bit pattern The values are defined in the PropertyFlags enum and descr...
Definition: Particle.h:485
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:491
double m_momentumScalingFactor
momentum scaling factor
Definition: Particle.h:1017
unsigned getNDaughters(void) const
Returns number of daughter particles.
Definition: Particle.h:700
std::vector< Belle2::Particle * > getDaughters() const
Returns a vector of pointers to daughter particles.
Definition: Particle.cc:669
const std::vector< int > & getDaughterIndices() const
Returns a vector of store array indices of daughter particles.
Definition: Particle.h:709
double getZ() const
Returns z component of vertex position.
Definition: Particle.h:631
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.
void resetErrorMatrix()
Resets 7x7 error matrix All elements are set to 0.0.
Definition: Particle.cc:1109
double getPDGMass(void) const
Returns uncertainty on the invariant mass (requires valid momentum error matrix)
Definition: Particle.cc:636
void setMomentumSmearingFactor(double momentumSmearingFactor)
Sets momentum smearing.
Definition: Particle.h:331
EFlavorType m_flavorType
flavor type.
Definition: Particle.h:1026
int generatePDGCodeFromCharge(const int chargedSign, const Const::ChargedStable &chargedStable)
Generate the PDG code with correct sign, using the charge.
Definition: Particle.cc:1409
double getCharge(void) const
Returns particle charge.
Definition: Particle.cc:654
ROOT::Math::PxPyPzEVector get4Vector() const
Returns Lorentz vector.
Definition: Particle.h:532
void appendDaughter(int particleIndex, const bool updateType=true)
Appends index of daughter to daughters index array.
Definition: Particle.h:403
Particle()
Default constructor.
Definition: Particle.cc:45
TMatrixFSym getMomentumErrorMatrix() const
Returns the 4x4 momentum error matrix.
Definition: Particle.cc:467
double m_mass
particle (invariant) mass
Definition: Particle.h:1012
std::vector< const Belle2::Particle * > getAllDaughters() const
Returns a vector of pointers to all generations' daughter particles.
Definition: Particle.cc:689
double getAcoplanarity() const
Returns acoplanarity angle defined as the angle between the decay planes of the grand daughters in th...
Definition: Particle.cc:565
std::vector< int > m_daughterProperties
daughter particle properties
Definition: Particle.h:1030
double m_errMatrix[c_SizeMatrix]
error matrix (1D representation)
Definition: Particle.h:1022
std::vector< int > m_daughterIndices
daughter particle indices
Definition: Particle.h:1025
double getY() const
Returns y component of vertex position.
Definition: Particle.h:622
void addExtraInfo(const std::string &name, double value)
Sets the user-defined data of given name to the given value.
Definition: Particle.cc:1363
void set4Vector(const ROOT::Math::PxPyPzEVector &p4)
Sets Lorentz vector.
Definition: Particle.h:286
void setJacobiMatrix(const TMatrixF &jacobiMatrix)
Sets 4x6 jacobi matrix.
Definition: Particle.cc:439
int getExtraInfoMap() const
Return the id of the associated ParticleExtraInfoMap or -1 if no map is set.
Definition: Particle.h:894
double getPDGLifetime() const
Returns particle nominal lifetime.
Definition: Particle.cc:645
void setMomentumVertexErrorMatrix(const TMatrixFSym &errMatrix)
Sets 7x7 error matrix.
Definition: Particle.cc:425
ROOT::Math::XYZVector getMomentum() const
Returns momentum vector.
Definition: Particle.h:541
void setPValue(double pValue)
Sets chi^2 probability of fit.
Definition: Particle.h:353
EParticleSourceObject getParticleSource() const
Returns particle source as defined with enum EParticleSourceObject.
Definition: Particle.h:465
void updateMass(const int pdgCode)
Updates particle mass with the mass of the particle corresponding to the given PDG.
Definition: Particle.cc:629
double m_z
position component z
Definition: Particle.h:1021
void print() const
Prints the contents of a Particle object to standard output.
Definition: Particle.cc:1200
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:373
EFlavorType
describes flavor type, see getFlavorType().
Definition: Particle.h:93
@ c_Unflavored
Is its own antiparticle or we don't know whether it is a particle/antiparticle.
Definition: Particle.h:94
@ c_Flavored
Is either particle or antiparticle.
Definition: Particle.h:95
int m_pdgCode
PDG code.
Definition: Particle.h:1010
TMatrixFSym getMomentumVertexErrorMatrix() const
Returns 7x7 error matrix.
Definition: Particle.cc:452
PropertyFlags
Flags that describe the particle property, which are used in the MC matching.
Definition: Particle.h:115
@ c_IsIgnoreNeutrino
Is the particle MC matched with the ignore missing neutrino flag set?
Definition: Particle.h:121
@ c_IsIgnoreRadiatedPhotons
Is the particle MC matched with the ignore radiated photon flag set?
Definition: Particle.h:118
@ c_IsIgnoreGamma
Is the particle MC matched with the ignore missing gamma flag set?
Definition: Particle.h:122
@ c_IsUnspecified
Ordinary particles.
Definition: Particle.h:117
@ c_IsIgnoreBrems
Is the particle MC matched with the ignore added Brems gamma flag set?
Definition: Particle.h:123
@ c_IsIgnoreDecayInFlight
Is the particle MC matched with the ignore DecayInFlight flag set?
Definition: Particle.h:125
@ c_IsIgnoreMisID
Is the particle MC matched with the ignore MisID flag set?
Definition: Particle.h:124
@ c_IsIgnoreIntermediate
Is the particle MC matched with the ignore intermediate resonances flag set?
Definition: Particle.h:119
@ c_IsIgnoreMassive
Is the particle MC matched with the ignore missing massive particle flag set?
Definition: Particle.h:120
double getECLClusterEnergy() const
Returns the energy of the ECLCluster for the particle.
Definition: Particle.cc:949
bool replaceDaughter(const Particle *oldDaughter, const Particle *newDaughter)
Replace index of given daughter with new daughter, return true if a replacement is made.
Definition: Particle.cc:737
const TrackFitResult * getTrackFitResult() const
Returns the pointer to the TrackFitResult that was used to create this Particle (ParticleType == c_Tr...
Definition: Particle.cc:884
double getMomentumMagnitude() const
Returns momentum magnitude.
Definition: Particle.h:550
Particle(const ROOT::Math::PxPyPzEVector &momentum, const int pdgCode, EFlavorType flavorType, const EParticleSourceObject particleType, const unsigned mdstIndex)
Constructor for final state particles.
void removeDaughter(const Particle *daughter, const bool updateType=true)
Removes index of daughter from daughters index array.
Definition: Particle.cc:720
double getP() const
Returns momentum magnitude (same as getMomentumMagnitude but with shorter name)
Definition: Particle.h:559
double m_y
position component y
Definition: Particle.h:1020
void setPDGCode(const int pdg)
Sets PDG code.
Definition: Particle.h:277
unsigned int getExtraInfoSize() const
Return the size of the extra info array.
Definition: Particle.h:900
int m_identifier
Identifier that can be used to identify whether the particle is unique or is a copy or representation...
Definition: Particle.h:1039
bool replaceDaughterRecursively(const Particle *oldDaughter, const Particle *newDaughter)
Apply replaceDaughter to all Particles in the decay tree by looping recursively through it,...
Definition: Particle.cc:753
const std::vector< int > & getDaughterProperties() const
Returns a vector of properties of daughter particles.
Definition: Particle.h:718
int m_properties
particle property
Definition: Particle.h:1029
const Particle * getDaughter(unsigned i) const
Returns a pointer to the i-th daughter particle.
Definition: Particle.cc:663
ClassDefOverride(Particle, 16)
Class to store reconstructed particles.
double getExtraInfo(const std::string &name) const
Return given value if set.
Definition: Particle.cc:1316
ECLCluster::EHypothesisBit getECLClusterEHypothesisBit() const
Returns the ECLCluster EHypothesisBit for this Particle.
Definition: Particle.h:974
Particle(const ROOT::Math::PxPyPzEVector &momentum, const int pdgCode, EFlavorType flavorType, const std::vector< int > &daughterIndices, TClonesArray *arrayPointer=nullptr)
Constructor for composite particles.
double getMass() const
Returns invariant mass (= nominal for FS particles)
Definition: Particle.h:494
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:30
Abstract base class for different kinds of events.
Definition: ClusterUtils.h:23