Belle II Software  light-2212-foldex
ParticleBase.cc
1 /**************************************************************************
2  * basf2 (Belle II Analysis Software Framework) *
3  * Author: The Belle II Collaboration *
4  * External Contributor: Wouter Hulsbergen *
5  * *
6  * See git log for contributors and copyright holders. *
7  * This file is licensed under LGPL-3.0, see LICENSE.md. *
8  **************************************************************************/
9 
10 //Creates a particle. Base class for all other particle classes.
11 
12 #include <TDatabasePDG.h>
13 
14 #include <analysis/VertexFitting/TreeFitter/ParticleBase.h>
15 #include <analysis/VertexFitting/TreeFitter/InternalParticle.h>
16 #include <analysis/VertexFitting/TreeFitter/RecoComposite.h>
17 #include <analysis/VertexFitting/TreeFitter/RecoResonance.h>
18 #include <analysis/VertexFitting/TreeFitter/RecoTrack.h>
19 
20 #include <analysis/VertexFitting/TreeFitter/RecoPhoton.h>
21 #include <analysis/VertexFitting/TreeFitter/RecoKlong.h>
22 #include <analysis/VertexFitting/TreeFitter/Resonance.h>
23 #include <analysis/VertexFitting/TreeFitter/Origin.h>
24 #include <analysis/VertexFitting/TreeFitter/FitParams.h>
25 
26 #include <framework/geometry/BFieldManager.h>
27 
28 namespace TreeFitter {
29 
31  m_particle(particle),
32  m_mother(mother),
33  m_isStronglyDecayingResonance(false),
34  m_config(config),
35  m_index(0),
36  m_name("Unknown")
37  {
38  if (particle) {
40  const int pdgcode = particle->getPDGCode();
41  if (pdgcode) { // PDG code != 0
42  m_name = particle->getName();
43  }
44  }
45  }
46 
48  m_particle(particle),
49  m_mother(mother),
50  m_isStronglyDecayingResonance(false),
51  m_config(nullptr),
52  m_index(0),
53  m_name("Unknown")
54  {
55  if (particle) {
57  const int pdgcode = particle->getPDGCode();
58  if (pdgcode) { // PDG code != 0
59  m_name = particle->getName();
60  }
61  }
62  }
63 
64  ParticleBase::ParticleBase(const std::string& name) :
65  m_particle(nullptr),
66  m_mother(nullptr),
67  m_isStronglyDecayingResonance(false),
68  m_config(nullptr),
69  m_index(0),
70  m_name(name)
71  {}
72 
73 
75  {
76  for (auto daughter : m_daughters) {
77  delete daughter;
78  }
79  m_daughters.clear();
80  }
81 
83  {
84  auto newDaughter = ParticleBase::createParticle(cand, this, config, forceFitAll);
85  m_daughters.push_back(newDaughter);
86  return m_daughters.back();
87  }
88 
89 
91  {
92  auto iter = std::find(m_daughters.begin(), m_daughters.end(), pb);
93  if (iter != m_daughters.end()) {
94  delete *iter;
95  m_daughters.erase(iter);
96  } else {
97  B2ERROR("Cannot remove particle, because not found ...");
98  }
99  }
100 
101  void ParticleBase::updateIndex(int& offset)
102  {
103  for (auto* daughter : m_daughters) {
104  daughter->updateIndex(offset);
105  }
106  m_index = offset;
107  offset += dim();
108  }
109 
111  Belle2::Particle* daughter,
112  const ConstraintConfiguration& config,
113  bool forceFitAll
114  )
115  {
116  return new Origin(daughter, config, forceFitAll);
117  }
118 
120  const ConstraintConfiguration& config, bool forceFitAll)
121  {
122  ParticleBase* rc = nullptr;
123 
124  if (!mother) { // 'head of tree' particles
125  if (!particle->getMdstArrayIndex()) { //0 means it's a composite
126  rc = new InternalParticle(particle, nullptr, config, forceFitAll);
127 
128  } else {
129 
130  rc = new InternalParticle(particle, nullptr, config,
131  forceFitAll); //FIXME obsolete not touching it now god knows where this might be needed
132 
133  }
134  } else if (particle->hasExtraInfo("bremsCorrected")) { // Has Bremsstrahlungs-recovery
135  if (particle->getExtraInfo("bremsCorrected") == 0.) { // No gammas assigned -> simple track
136  rc = new RecoTrack(particle, mother);
137  } else { // Got gammas -> composite particle
138  rc = new RecoComposite(particle, mother, config, true);
139  }
140  } else if (particle->hasExtraInfo("treeFitterTreatMeAsInvisible")
141  && particle->getExtraInfo("treeFitterTreatMeAsInvisible") == 1) { // dummy particles with invisible flag
142  rc = new RecoResonance(particle, mother, config);
143 
144  } else if (particle->getMdstArrayIndex() ||
145  particle->getTrack() ||
146  particle->getECLCluster() ||
147  particle->getKLMCluster()) { // external particles and final states
148  if (particle->getTrack()) {
149  rc = new RecoTrack(particle, mother);
150  } else if (particle->getECLCluster()) {
151  rc = new RecoPhoton(particle, mother);
152 
153  } else if (particle->getKLMCluster()) {
154  rc = new RecoKlong(particle, mother);
155 
156  } else if (isAResonance(particle)) {
157  rc = new RecoResonance(particle, mother, config);
158 
159  } else {
160  rc = new InternalParticle(particle, mother, config, forceFitAll);
161 
162  }
163 
164  } else { // 'internal' particles
165 
166  if (false) { // fitted composites //JFK::eventually implement prefitting mechanic to prefit composites with other fitters
167  if (isAResonance(particle)) {
168 
169  rc = new RecoResonance(particle, mother, config);
170 
171  } else {
172  rc = new RecoComposite(particle, mother, config);
173  }
174 
175  } else { // unfitted composites
176 
177  if (isAResonance(particle)) {
178  rc = new Resonance(particle, mother, config, forceFitAll);
179 
180  } else {
181  rc = new InternalParticle(particle, mother, config, forceFitAll);
182  }
183  }
184  }
185  return rc;
186  }
187 
189  {
190  bool rc = false ;
191  const int pdgcode = std::abs(particle->getPDGCode());
192 
193  if (pdgcode && !(particle->getMdstArrayIndex())) {
194  switch (pdgcode) {
195  case 22: //photon conversion
196  rc = false;
197  break ;
198 
199  case -11: //bremsstrahlung
200  case 11:
201  rc = true ;
202  break ;
203  default: //everything with boosted flight length less than 1 micrometer
204  rc = (pdgcode && particle->getPDGLifetime() < 1e-14);
205  }
206  }
207  return rc ;
208  }
209 
210  void ParticleBase::collectVertexDaughters(std::vector<ParticleBase*>& particles, int posindex)
211  {
212  if (mother() && mother()->posIndex() == posindex) {
213  particles.push_back(this);
214  }
215 
216  for (auto* daughter : m_daughters) {
217  daughter->collectVertexDaughters(particles, posindex);
218  }
219  }
220 
222  {
223  // this is very sensitive and can heavily affect the efficiency of the fit
224  ErrCode status;
225 
226  const int posindex = posIndex();
227  if (posindex >= 0) {
228  for (int i = 0; i < 3; ++i) {
229  fitparams.getCovariance()(posindex + i, posindex + i) = 1;
230  }
231  }
232 
233  const int momindex = momIndex();
234  if (momindex >= 0) {
235  const int maxrow = hasEnergy() ? 4 : 3;
236  for (int i = 0; i < maxrow; ++i) {
237  fitparams.getCovariance()(momindex + i, momindex + i) = 10.;
238  }
239  }
240 
241  const int tauindex = tauIndex();
242  if (tauindex >= 0) {
243  fitparams.getCovariance()(tauindex, tauindex) = 1.;
244  }
245  return status;
246  }
247 
248  std::string ParticleBase::parname(int thisindex) const
249  {
250  std::string rc = m_name;
251  switch (thisindex) {
252  case 0: rc += "_x "; break;
253  case 1: rc += "_y "; break;
254  case 2: rc += "_z "; break;
255  case 3: rc += "_tau"; break;
256  case 4: rc += "_px "; break;
257  case 5: rc += "_py "; break;
258  case 6: rc += "_pz "; break;
259  case 7: rc += "_E "; break;
260  default:;
261  }
262  return rc;
263  }
264 
266  {
267  const ParticleBase* rc = (m_particle == particle) ? this : nullptr;
268  if (!rc) {
269  for (auto* daughter : m_daughters) {
270  rc = daughter->locate(particle);
271  if (rc) {break;}
272  }
273  }
274  return rc;
275  }
276 
278  {
279  map.push_back(std::pair<const ParticleBase*, int>(this, index()));
280  for (auto* daughter : m_daughters) {
281  daughter->retrieveIndexMap(map);
282  }
283  }
284 
285  double ParticleBase::chiSquare(const FitParams& fitparams) const
286  {
287  double rc = 0;
288  for (auto* daughter : m_daughters) {
289  rc += daughter->chiSquare(fitparams);
290  }
291  return rc;
292  }
293 
295  {
296  int rc = 0;
297  for (auto* daughter : m_daughters) {
298  rc += daughter->nFinalChargedCandidates();
299  }
300  return rc;
301  }
302 
304  {
305  assert(m_config);
306  // only allow 2d for head of tree particles that are beam constrained
307  const int dim = m_config->m_originDimension == 2 && std::abs(m_particle->getPDGCode()) == m_config->m_headOfTreePDG ? 2 : 3;
308  const int posindexmother = mother()->posIndex();
309  const int posindex = posIndex();
310  const int tauindex = tauIndex();
311  const int momindex = momIndex();
312 
313  const double tau = fitparams.getStateVector()(tauindex);
314  Eigen::Matrix < double, 1, -1, 1, 1, 3 > x_vec = fitparams.getStateVector().segment(posindex, dim);
315  Eigen::Matrix < double, 1, -1, 1, 1, 3 > x_m = fitparams.getStateVector().segment(posindexmother, dim);
316  Eigen::Matrix < double, 1, -1, 1, 1, 3 > p_vec = fitparams.getStateVector().segment(momindex, dim);
317  const double mom = p_vec.norm();
318  const double mom3 = mom * mom * mom;
319 
320  if (3 == dim) {
321  // we can already set these
322  //diagonal momentum
323  p.getH()(0, momindex) = tau * (p_vec(1) * p_vec(1) + p_vec(2) * p_vec(2)) / mom3 ;
324  p.getH()(1, momindex + 1) = tau * (p_vec(0) * p_vec(0) + p_vec(2) * p_vec(2)) / mom3 ;
325  p.getH()(2, momindex + 2) = tau * (p_vec(0) * p_vec(0) + p_vec(1) * p_vec(1)) / mom3 ;
326 
327  //offdiagonal momentum
328  p.getH()(0, momindex + 1) = - tau * p_vec(0) * p_vec(1) / mom3 ;
329  p.getH()(0, momindex + 2) = - tau * p_vec(0) * p_vec(2) / mom3 ;
330 
331  p.getH()(1, momindex + 0) = - tau * p_vec(1) * p_vec(0) / mom3 ;
332  p.getH()(1, momindex + 2) = - tau * p_vec(1) * p_vec(2) / mom3 ;
333 
334  p.getH()(2, momindex + 0) = - tau * p_vec(2) * p_vec(0) / mom3 ;
335  p.getH()(2, momindex + 1) = - tau * p_vec(2) * p_vec(1) / mom3 ;
336 
337  } else if (2 == dim) {
338 
339  // NOTE THAT THESE ARE DIFFERENT IN 2d
340  p.getH()(0, momindex) = tau * (p_vec(1) * p_vec(1)) / mom3 ;
341  p.getH()(1, momindex + 1) = tau * (p_vec(0) * p_vec(0)) / mom3 ;
342 
343  //offdiagonal momentum
344  p.getH()(0, momindex + 1) = - tau * p_vec(0) * p_vec(1) / mom3 ;
345  p.getH()(1, momindex + 0) = - tau * p_vec(1) * p_vec(0) / mom3 ;
346  } else {
347  B2FATAL("Dimension of Geometric constraint is not 2 or 3. This will crash many things. You should feel bad.");
348  }
349 
350  for (int row = 0; row < dim; ++row) {
351 
352  double posxmother = x_m(row);
353  double posx = x_vec(row);
354  double momx = p_vec(row);
355 
359  p.getResiduals()(row) = posxmother + tau * momx / mom - posx ;
360  p.getH()(row, posindexmother + row) = 1;
361  p.getH()(row, posindex + row) = -1;
362  p.getH()(row, tauindex) = momx / mom;
363  }
364 
365  return ErrCode(ErrCode::Status::success);
366  }
367 
368  void inline setExtraInfo(Belle2::Particle* part, const std::string& name, const double value)
369  {
370  if (part) {
371  if (part->hasExtraInfo(name)) {
372  part->setExtraInfo(name, value);
373  } else {
374  part->addExtraInfo(name, value);
375  }
376  }
377  }
378 
380  Projection& p) const
381  {
382  const double mass = particle()->getPDGMass();
383  const double mass2 = mass * mass;
384  double px = 0;
385  double py = 0;
386  double pz = 0;
387  double E = 0;
388 
389  // the parameters of the daughters must be used otherwise the mass constraint does not have an effect on the extracted daughter momenta
390  for (const auto* daughter : m_daughters) {
391  const int momindex = daughter->momIndex();
392  // in most cases the daughters will be final states so we cache the value to use it in the energy column
393  const double px_daughter = fitparams.getStateVector()(momindex);
394  const double py_daughter = fitparams.getStateVector()(momindex + 1);
395  const double pz_daughter = fitparams.getStateVector()(momindex + 2);
396 
397  px += px_daughter;
398  py += py_daughter;
399  pz += pz_daughter;
400  if (daughter->hasEnergy()) {
401  E += fitparams.getStateVector()(momindex + 3);
402  } else {
403  // final states dont have an energy index
404  const double m = daughter->particle()->getPDGMass();
405  E += std::sqrt(m * m + px_daughter * px_daughter + py_daughter * py_daughter + pz_daughter * pz_daughter);
406  }
407  }
408 
412  p.getResiduals()(0) = mass2 - E * E + px * px + py * py + pz * pz;
413 
414  for (const auto* daughter : m_daughters) {
415  //dr/dx = d/dx m2-{E1+E2+...}^2+{p1+p2+...}^2 = 2*x (x= E or p)
416  const int momindex = daughter->momIndex();
417  p.getH()(0, momindex) = 2.0 * px;
418  p.getH()(0, momindex + 1) = 2.0 * py;
419  p.getH()(0, momindex + 2) = 2.0 * pz;
420 
421  if (daughter->hasEnergy()) {
422  p.getH()(0, momindex + 3) = -2.0 * E;
423  } else {
424  const double px_daughter = fitparams.getStateVector()(momindex);
425  const double py_daughter = fitparams.getStateVector()(momindex + 1);
426  const double pz_daughter = fitparams.getStateVector()(momindex + 2);
427  const double m = daughter->particle()->getPDGMass();
428 
429  const double E_daughter = std::sqrt(m * m + px_daughter * px_daughter + py_daughter * py_daughter + pz_daughter * pz_daughter);
430  const double E_by_E_daughter = E / E_daughter;
431  p.getH()(0, momindex) -= 2.0 * E_by_E_daughter * px_daughter;
432  p.getH()(0, momindex + 1) -= 2.0 * E_by_E_daughter * py_daughter;
433  p.getH()(0, momindex + 2) -= 2.0 * E_by_E_daughter * pz_daughter;
434  }
435 
436  }
437  return ErrCode(ErrCode::Status::success);
438  }
439 
441  Projection& p) const
442  {
443  const double mass = particle()->getPDGMass();
444  const double mass2 = mass * mass;
445  const int momindex = momIndex();
446  const double px = fitparams.getStateVector()(momindex);
447  const double py = fitparams.getStateVector()(momindex + 1);
448  const double pz = fitparams.getStateVector()(momindex + 2);
449  const double E = fitparams.getStateVector()(momindex + 3);
450 
454  p.getResiduals()(0) = mass2 - E * E + px * px + py * py + pz * pz;
455 
456  p.getH()(0, momindex) = 2.0 * px;
457  p.getH()(0, momindex + 1) = 2.0 * py;
458  p.getH()(0, momindex + 2) = 2.0 * pz;
459  p.getH()(0, momindex + 3) = -2.0 * E;
460 
461  // TODO 0 in most cases -> needs special treatment if width=0 to not crash chi2 calculation
462  // const double width = TDatabasePDG::Instance()->GetParticle(particle()->getPDGCode())->Width();
463  // transport measurement uncertainty into residual system
464  // f' = sigma_x^2 * (df/dx)^2
465  // p.getV()(0) = width * width * 4 * mass2;
466 
467  return ErrCode(ErrCode::Status::success);
468  }
469 
471  Projection& p) const
472  {
473  assert(m_config);
474  if (m_config->m_massConstraintType == 0) {
475  return projectMassConstraintParticle(fitparams, p);
476  } else {
477  return projectMassConstraintDaughters(fitparams, p);
478  }
479  }
480 
482  {
483  if (type == Constraint::mass) {
484  return projectMassConstraint(fitparams, p);
485  } else {
486  B2FATAL("Trying to project constraint of ParticleBase type. This is undefined.");
487  }
488  return ErrCode(ErrCode::Status::badsetup);
489  }
490 
492  {
493  const int tauindex = tauIndex();
494  if (tauindex >= 0 && hasPosition()) {
495 
496  const int posindex = posIndex();
497  const int mother_ps_index = mother()->posIndex();
498  const int dim = m_config->m_originDimension; // TODO can we configure this to be particle specific?
499 
500  // tau has different meaning depending on the dimension of the constraint
501  // 2-> use x-y projection
502  const Eigen::Matrix < double, 1, -1, 1, 1, 3 > vertex_dist =
503  fitparams.getStateVector().segment(posindex, dim) - fitparams.getStateVector().segment(mother_ps_index, dim);
504  const Eigen::Matrix < double, 1, -1, 1, 1, 3 >
505  mom = fitparams.getStateVector().segment(posindex, dim) - fitparams.getStateVector().segment(mother_ps_index, dim);
506 
507  // if an intermediate vertex is not well defined by a track or so it will be initialised with 0
508  // same for the momentum of for example B0, it might be initialised with 0
509  // in those cases use pdg value
510  const double mom_norm = mom.norm();
511  const double dot = std::abs(vertex_dist.dot(mom));
512  const double tau = dot / mom_norm;
513  if (0 == mom_norm || 0 == dot) {
514  const double mass = m_particle->getPDGMass();
515  if (mass > 0)
516  fitparams.getStateVector()(tauindex) = m_particle->getPDGLifetime() * 1e9 * Belle2::Const::speedOfLight / mass;
517  else
518  fitparams.getStateVector()(tauindex) = 0;
519  } else {
520  fitparams.getStateVector()(tauindex) = tau;
521  }
522  }
523 
524  return ErrCode(ErrCode::Status::success);
525  }
526 } //end namespace TreeFitter
527 
static const double speedOfLight
[cm/ns]
Definition: Const.h:685
Class to store reconstructed particles.
Definition: Particle.h:74
const KLMCluster * getKLMCluster() const
Returns the pointer to the KLMCluster object that was used to create this Particle (ParticleType == c...
Definition: Particle.cc:956
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
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
std::string getName() const override
Return name of this particle.
Definition: Particle.cc:1195
bool hasExtraInfo(const std::string &name) const
Return whether the extra info with the given name is set.
Definition: Particle.cc:1293
unsigned getMdstArrayIndex(void) const
Returns 0-based index of MDST store array object (0 for composite particles)
Definition: Particle.h:474
int getPDGCode(void) const
Returns PDG code.
Definition: Particle.h:441
double getPDGMass(void) const
Returns uncertainty on the invariant mass (requires valid momentum error matrix)
Definition: Particle.cc:636
void addExtraInfo(const std::string &name, double value)
Sets the user-defined data of given name to the given value.
Definition: Particle.cc:1363
double getPDGLifetime() const
Returns particle nominal lifetime.
Definition: Particle.cc:645
double getExtraInfo(const std::string &name) const
Return given value if set.
Definition: Particle.cc:1316
const int m_originDimension
dimension of the origin constraint and ALL geometric gcosntraints
int m_headOfTreePDG
PDG code of the head particle.
const bool m_massConstraintType
const flag for the type of the mass constraint
Type
type of constraints the order of these constraints is important: it is the order in which they are ap...
Definition: Constraint.h:27
abstract errorocode be aware that the default is success
Definition: ErrCode.h:14
Class to store and manage fitparams (statevector)
Definition: FitParams.h:20
Eigen::Matrix< double, -1, -1, 0, MAX_MATRIX_SIZE, MAX_MATRIX_SIZE > & getCovariance()
getter for the states covariance
Definition: FitParams.h:53
Eigen::Matrix< double, -1, 1, 0, MAX_MATRIX_SIZE, 1 > & getStateVector()
getter for the fit parameters/statevector
Definition: FitParams.h:65
another unnecessary layer of abstraction
representation of the beamspot as a particle
Definition: Origin.h:19
base class for all particles
Definition: ParticleBase.h:25
ParticleBase(Belle2::Particle *particle, const ParticleBase *mother, const ConstraintConfiguration *config)
default constructor
Definition: ParticleBase.cc:30
Belle2::Particle * particle() const
get basf2 particle
Definition: ParticleBase.h:96
virtual void updateIndex(int &offset)
this sets the index for momentum, position, etc.
virtual ErrCode projectMassConstraintParticle(const FitParams &, Projection &) const
project mass constraint using the particles parameters
ErrCode initTau(FitParams &par) const
initialises tau as a length
virtual ParticleBase * addDaughter(Belle2::Particle *, const ConstraintConfiguration &config, bool forceFitAll=false)
add daughter
Definition: ParticleBase.cc:82
static ParticleBase * createOrigin(Belle2::Particle *daughter, const ConstraintConfiguration &config, bool forceFitAll)
create a custom origin particle or a beamspot
static ParticleBase * createParticle(Belle2::Particle *particle, const ParticleBase *mother, const ConstraintConfiguration &config, bool forceFitAll=false)
create the according treeFitter particle obj for a basf2 particle type
virtual int dim() const =0
get dimension of constraint
virtual int nFinalChargedCandidates() const
number of charged candidates
virtual void retrieveIndexMap(indexmap &anindexmap) const
get index map
virtual ErrCode projectMassConstraint(const FitParams &, Projection &) const
project mass constraint abstract
const ConstraintConfiguration * m_config
has all the constraint config
Definition: ParticleBase.h:208
virtual std::string parname(int index) const
get name of parameter i
static bool isAResonance(Belle2::Particle *particle)
controls if a particle is treated as a resonance(lifetime=0) or a particle that has a finite lifetime...
virtual ErrCode projectConstraint(Constraint::Type, const FitParams &, Projection &) const
project constraint.
virtual ErrCode projectMassConstraintDaughters(const FitParams &, Projection &) const
project mass constraint using the parameters of the daughters
const ParticleBase * locate(Belle2::Particle *particle) const
get particle base from basf2 particle
virtual void removeDaughter(const ParticleBase *pb)
remove daughter
Definition: ParticleBase.cc:90
bool m_isStronglyDecayingResonance
decay length less than 1 micron
Definition: ParticleBase.h:205
virtual ErrCode initCovariance(FitParams &) const
init covariance matrix
virtual int type() const =0
get particle type
Belle2::Particle * m_particle
pointer to framework type
Definition: ParticleBase.h:196
virtual ErrCode projectGeoConstraint(const FitParams &, Projection &) const
project geometrical constraint
virtual double chiSquare(const FitParams &) const
get chi2
virtual int posIndex() const
get vertex index (in statevector!)
Definition: ParticleBase.h:126
std::vector< std::pair< const ParticleBase *, int > > indexmap
alias
Definition: ParticleBase.h:59
virtual int momIndex() const
get momentum index
Definition: ParticleBase.h:132
int index() const
get index
Definition: ParticleBase.h:99
virtual bool hasEnergy() const
get momentum dimension
Definition: ParticleBase.h:136
std::vector< ParticleBase * > m_daughters
daughter container
Definition: ParticleBase.h:202
std::string m_name
name
Definition: ParticleBase.h:215
virtual ~ParticleBase()
destructor, actually does something
Definition: ParticleBase.cc:74
void collectVertexDaughters(std::vector< ParticleBase * > &particles, int posindex)
get vertex daughters
virtual int tauIndex() const
get tau index
Definition: ParticleBase.h:129
virtual bool hasPosition() const
get false
Definition: ParticleBase.h:139
const ParticleBase * mother() const
getMother() / hasMother()
Definition: ParticleBase.h:102
class to store the projected residuals and the corresponding jacobian as well as the covariance matri...
Definition: Projection.h:18
A class for composite particles.
Definition: RecoComposite.h:16
representation of the Klong constraint
Definition: RecoKlong.h:16
representation of the photon constraint
Definition: RecoPhoton.h:16
A class for resonances.
Definition: RecoResonance.h:17
representation of all charged final states FIXME rename since this name is taken in tracking
Definition: RecoTrack.h:18
class for resonances as internal particles
Definition: Resonance.h:17