Belle II Software  release-08-01-10
SkimSampleCalculator.cc
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 #include <hlt/softwaretrigger/calculations/SkimSampleCalculator.h>
10 
11 #include <hlt/softwaretrigger/calculations/utilities.h>
12 
13 #include <analysis/utility/PCmsLabTransform.h>
14 #include <analysis/utility/ReferenceFrame.h>
15 
16 #include <analysis/ClusterUtility/ClusterUtils.h>
17 #include <analysis/ContinuumSuppression/FoxWolfram.h>
18 #include <analysis/dataobjects/Particle.h>
19 
20 #include <analysis/variables/AcceptanceVariables.h>
21 #include <analysis/variables/BelleVariables.h>
22 #include <analysis/variables/ECLVariables.h>
23 #include <analysis/variables/FlightInfoVariables.h>
24 
25 #include <framework/geometry/B2Vector3.h>
26 
27 #include <mdst/dataobjects/HitPatternCDC.h>
28 #include <mdst/dataobjects/KLMCluster.h>
29 #include <mdst/dataobjects/PIDLikelihood.h>
30 #include <mdst/dataobjects/SoftwareTriggerResult.h>
31 #include <mdst/dataobjects/Track.h>
32 #include <mdst/dataobjects/TrackFitResult.h>
33 
34 #include <reconstruction/dataobjects/CDCDedxTrack.h>
35 
36 #include <numeric>
37 #include <TDatabasePDG.h>
38 
39 using namespace Belle2;
40 using namespace SoftwareTrigger;
41 
42 SkimSampleCalculator::SkimSampleCalculator() :
43  m_pionParticles("pi+:skim"), m_gammaParticles("gamma:skim"), m_pionHadParticles("pi+:hadb"), m_pionTauParticles("pi+:tau"),
44  m_KsParticles("K_S0:merged"), m_LambdaParticles("Lambda0:merged"), m_DstParticles("D*+:d0pi"), m_offIpParticles("pi+:offip"),
45  m_filterL1TrgNN("software_trigger_cut&filter&L1_trigger_nn_info"),
46  m_BpParticles("B+:BtoCharmForHLT"), m_BzParticles("B0:BtoCharmForHLT")
47 {
48 
49 }
50 
51 void SkimSampleCalculator::requireStoreArrays()
52 {
53  m_pionParticles.isRequired();
54  m_gammaParticles.isRequired();
55  m_pionHadParticles.isRequired();
56  m_pionTauParticles.isRequired();
57  m_KsParticles.isOptional();
58  m_LambdaParticles.isOptional();
59  m_DstParticles.isOptional();
60  m_offIpParticles.isRequired();
61  m_BpParticles.isOptional();
62  m_BzParticles.isOptional();
63 
64 };
65 
66 void SkimSampleCalculator::doCalculation(SoftwareTriggerObject& calculationResult)
67 {
68  // Prefetch some later needed objects/values
69  const Particle* gammaWithMaximumRho = getElementWithMaximumRho<Particle>(m_gammaParticles);
70  const Particle* gammaWithSecondMaximumRho = getElementWithMaximumRhoBelow<Particle>(m_gammaParticles,
71  getRho(gammaWithMaximumRho));
72  const Particle* trackWithMaximumRho = getElementWithMaximumRho<Particle>(m_pionParticles);
73  const Particle* trackWithSecondMaximumRho = getElementWithMaximumRhoBelow<Particle>(m_pionParticles,
74  getRho(trackWithMaximumRho));
75 
76  const double& rhoOfECLClusterWithMaximumRho = getRhoOfECLClusterWithMaximumRho(m_pionParticles, m_gammaParticles);
77  const double& rhoOfECLClusterWithSecondMaximumRho = getRhoOfECLClusterWithMaximumRhoBelow(m_pionParticles,
78  m_gammaParticles,
79  rhoOfECLClusterWithMaximumRho);
80 
81  const double& rhoOfTrackWithMaximumRho = getRho(trackWithMaximumRho);
82  const double& rhoOfTrackWithSecondMaximumRho = getRho(trackWithSecondMaximumRho);
83  const double& rhoOfGammaWithMaximumRho = getRho(gammaWithMaximumRho);
84  const double& rhoOfGammaWithSecondMaximumRho = getRho(gammaWithSecondMaximumRho);
85 
86  // Simple to calculate variables
87  // EC1CMSLE
88  calculationResult["EC1CMSLE"] = rhoOfECLClusterWithMaximumRho;
89 
90  // EC2CMSLE
91  calculationResult["EC2CMSLE"] = rhoOfECLClusterWithSecondMaximumRho;
92 
93  // EC12CMSLE
94  calculationResult["EC12CMSLE"] = rhoOfECLClusterWithMaximumRho + rhoOfECLClusterWithSecondMaximumRho;
95 
96  // nTracksLE
97  calculationResult["nTracksLE"] = m_pionParticles->getListSize();
98 
99  // nTracksTAU
100  calculationResult["nTracksTAU"] = m_pionTauParticles->getListSize();
101 
102  // nGammasLE
103  calculationResult["nGammasLE"] = m_gammaParticles->getListSize();
104 
105  // P1CMSBhabhaLE
106  calculationResult["P1CMSBhabhaLE"] = rhoOfTrackWithMaximumRho;
107 
108  // P1CMSBhabhaLE/E_beam
109  calculationResult["P1OEbeamCMSBhabhaLE"] = rhoOfTrackWithMaximumRho / BeamEnergyCMS();
110 
111  // P2CMSBhabhaLE
112  calculationResult["P2CMSBhabhaLE"] = rhoOfTrackWithSecondMaximumRho;
113 
114  // P2CMSBhabhaLE/E_beam
115  calculationResult["P2OEbeamCMSBhabhaLE"] = rhoOfTrackWithSecondMaximumRho / BeamEnergyCMS();
116 
117  // P12CMSBhabhaLE
118  calculationResult["P12CMSBhabhaLE"] = rhoOfTrackWithMaximumRho + rhoOfTrackWithSecondMaximumRho;
119 
120  //G1CMSLE, the largest energy of gamma in CMS
121  calculationResult["G1CMSBhabhaLE"] = rhoOfGammaWithMaximumRho;
122  //G1OEbeamCMSLE, the largest energy of gamma in CMS over beam energy
123  calculationResult["G1OEbeamCMSBhabhaLE"] = rhoOfGammaWithMaximumRho / BeamEnergyCMS();
124 
125  //G2CMSLE, the secondary largest energy of gamma in CMS
126  calculationResult["G2CMSBhabhaLE"] = rhoOfGammaWithSecondMaximumRho;
127  //G2OEbeamCMSLE, the largest energy of gamma in CMS over beam energy
128  calculationResult["G2OEbeamCMSBhabhaLE"] = rhoOfGammaWithSecondMaximumRho / BeamEnergyCMS();
129 
130  //G12CMSLE, the secondary largest energy of gamma in CMS
131  calculationResult["G12CMSBhabhaLE"] = rhoOfGammaWithMaximumRho + rhoOfGammaWithSecondMaximumRho;
132  //G12CMSLE, the secondary largest energy of gamma in CMS over beam energy
133  calculationResult["G12OEbeamCMSBhabhaLE"] =
134  (rhoOfGammaWithMaximumRho + rhoOfGammaWithSecondMaximumRho) / BeamEnergyCMS();
135 
136 
137  // Medium hard to calculate variables
138  // ENeutralLE
139  if (gammaWithMaximumRho) {
140  calculationResult["ENeutralLE"] = getRho(gammaWithMaximumRho);
141  } else {
142  calculationResult["ENeutralLE"] = -1;
143  }
144 
145  // nECLMatchTracksLE
146  const unsigned int numberOfTracksWithECLMatch = std::count_if(m_pionParticles->begin(), m_pionParticles->end(),
147  [](const Particle & particle) {
148  return particle.getECLCluster() != nullptr;
149  });
150  calculationResult["nECLMatchTracksLE"] = numberOfTracksWithECLMatch;
151 
152  //nECLClustersLE
153  double neclClusters = -1.;
154  double eneclClusters = 0.;
155  StoreArray<ECLCluster> eclClusters;
156  ClusterUtils Cl;
157  double PzGamma = 0.;
158  double EsumGamma = 0.;
159  if (eclClusters.isValid()) {
160  const unsigned int numberOfECLClusters = std::count_if(eclClusters.begin(), eclClusters.end(),
161  [](const ECLCluster & eclcluster) {
162  return (eclcluster.hasHypothesis(
163  ECLCluster::EHypothesisBit::c_nPhotons)
164  and eclcluster.getEnergy(
165  ECLCluster::EHypothesisBit::c_nPhotons) > 0.1);
166  });
167  neclClusters = numberOfECLClusters;
168 
169  for (int ncl = 0; ncl < eclClusters.getEntries(); ncl++) {
170  if (eclClusters[ncl]->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons)
171  && eclClusters[ncl]->getEnergy(ECLCluster::EHypothesisBit::c_nPhotons) > 0.1) {
172  eneclClusters += eclClusters[ncl]->getEnergy(ECLCluster::EHypothesisBit::c_nPhotons);
173  if (!eclClusters[ncl]->getRelatedFrom<Track>()) {
174  ROOT::Math::PxPyPzEVector V4Gamma_CMS = PCmsLabTransform::labToCms(Cl.Get4MomentumFromCluster(eclClusters[ncl],
175  ECLCluster::EHypothesisBit::c_nPhotons));
176  EsumGamma += V4Gamma_CMS.E();
177  PzGamma += V4Gamma_CMS.Pz();
178  }
179  }
180  }
181  }
182  calculationResult["nECLClustersLE"] = neclClusters;
183 
184  int nb2bcc_PhiHigh = 0;
185  int nb2bcc_PhiLow = 0;
186  int nb2bcc_3D = 0;
187  ClusterUtils C;
188  for (int i = 0; i < eclClusters.getEntries() - 1; i++) {
189  if (!eclClusters[i]->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons))
190  continue;
191  ROOT::Math::PxPyPzEVector V4g1 = C.Get4MomentumFromCluster(eclClusters[i], ECLCluster::EHypothesisBit::c_nPhotons);
192  double Eg1 = V4g1.E();
193  for (int j = i + 1; j < eclClusters.getEntries(); j++) {
194  if (!eclClusters[j]->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons))
195  continue;
196  ROOT::Math::PxPyPzEVector V4g2 = C.Get4MomentumFromCluster(eclClusters[j], ECLCluster::EHypothesisBit::c_nPhotons);
197  double Eg2 = V4g2.E();
198  const B2Vector3D V3g1 = (PCmsLabTransform::labToCms(V4g1)).Vect();
199  const B2Vector3D V3g2 = (PCmsLabTransform::labToCms(V4g2)).Vect();
200  double Thetag1 = (PCmsLabTransform::labToCms(V4g1)).Theta() * TMath::RadToDeg();
201  double Thetag2 = (PCmsLabTransform::labToCms(V4g2)).Theta() * TMath::RadToDeg();
202  double deltphi = fabs(V3g1.DeltaPhi(V3g2) * TMath::RadToDeg());
203  double Tsum = Thetag1 + Thetag2;
204  if (deltphi > 170. && (Eg1 > 0.25 && Eg2 > 0.25)) nb2bcc_PhiHigh++;
205  if (deltphi > 170. && (Eg1 < 0.25 || Eg2 < 0.25)) nb2bcc_PhiLow++;
206  if (deltphi > 160. && (Tsum > 160. && Tsum < 200.)) nb2bcc_3D++;
207  }
208  }
209 
210  calculationResult["nB2BCCPhiHighLE"] = nb2bcc_PhiHigh;
211  calculationResult["nB2BCCPhiLowLE"] = nb2bcc_PhiLow;
212  calculationResult["nB2BCC3DLE"] = nb2bcc_3D;
213 
214 
215  // AngleGTLE
216  double angleGTLE = -10.;
217  if (gammaWithMaximumRho) {
218  const B2Vector3D& V3g1 = gammaWithMaximumRho->getMomentum();
219  if (trackWithMaximumRho) {
220  const B2Vector3D& V3p1 = trackWithMaximumRho->getMomentum();
221  const double theta1 = V3g1.Angle(V3p1);
222  if (angleGTLE < theta1) angleGTLE = theta1;
223  }
224  if (trackWithSecondMaximumRho) {
225  const B2Vector3D& V3p2 = trackWithSecondMaximumRho->getMomentum();
226  const double theta2 = V3g1.Angle(V3p2);
227  if (angleGTLE < theta2) angleGTLE = theta2;
228  }
229  }
230 
231  calculationResult["AngleGTLE"] = angleGTLE;
232 
233  // AngleG1G2LE
234  double angleG1G2CMSLE = -10.;
235  if (gammaWithMaximumRho) {
236  const ROOT::Math::PxPyPzEVector& V4p1 = gammaWithMaximumRho->get4Vector();
237  if (gammaWithSecondMaximumRho) {
238  const ROOT::Math::PxPyPzEVector& V4p2 = gammaWithSecondMaximumRho->get4Vector();
239  const B2Vector3D V3p1 = (PCmsLabTransform::labToCms(V4p1)).Vect();
240  const B2Vector3D V3p2 = (PCmsLabTransform::labToCms(V4p2)).Vect();
241  angleG1G2CMSLE = V3p1.Angle(V3p2);
242  }
243  }
244 
245  calculationResult["AngleG1G2CMSLE"] = angleG1G2CMSLE;
246 
247  // maxAngleTTLE
248  double maxAngleTTLE = -10.;
249  int nJpsi = 0;
250  double Jpsi = 0.;
251  const double jPsiMasswindow = 0.11;
252  if (m_pionParticles->getListSize() >= 2) {
253  for (unsigned int i = 0; i < m_pionParticles->getListSize() - 1; i++) {
254  Particle* par1 = m_pionParticles->getParticle(i);
255  for (unsigned int j = i + 1; j < m_pionParticles->getListSize(); j++) {
256  Particle* par2 = m_pionParticles->getParticle(j);
257  ROOT::Math::PxPyPzEVector V4p1 = par1->get4Vector();
258  ROOT::Math::PxPyPzEVector V4p2 = par2->get4Vector();
259  ROOT::Math::PxPyPzEVector V4pSum = V4p1 + V4p2;
260  const auto chSum = par1->getCharge() + par2->getCharge();
261  const double mSum = V4pSum.M();
262  const double JpsidM = mSum - TDatabasePDG::Instance()->GetParticle(443)->Mass();
263  if (abs(JpsidM) < jPsiMasswindow && chSum == 0) nJpsi++;
264  const B2Vector3D V3p1 = (PCmsLabTransform::labToCms(V4p1)).Vect();
265  const B2Vector3D V3p2 = (PCmsLabTransform::labToCms(V4p2)).Vect();
266  const double temp = V3p1.Angle(V3p2);
267  if (maxAngleTTLE < temp) maxAngleTTLE = temp;
268  }
269  }
270  }
271 
272  if (nJpsi != 0) Jpsi = 1;
273 
274  calculationResult["maxAngleTTLE"] = maxAngleTTLE;
275  calculationResult["Jpsi"] = Jpsi;
276 
277  //maxAngleGGLE
278  double maxAngleGGLE = -10.;
279  if (m_gammaParticles->getListSize() >= 2) {
280  for (unsigned int i = 0; i < m_gammaParticles->getListSize() - 1; i++) {
281  Particle* par1 = m_gammaParticles->getParticle(i);
282  for (unsigned int j = i + 1; j < m_gammaParticles->getListSize(); j++) {
283  Particle* par2 = m_gammaParticles->getParticle(j);
284  ROOT::Math::PxPyPzEVector V4p1 = par1->get4Vector();
285  ROOT::Math::PxPyPzEVector V4p2 = par2->get4Vector();
286  const B2Vector3D V3p1 = (PCmsLabTransform::labToCms(V4p1)).Vect();
287  const B2Vector3D V3p2 = (PCmsLabTransform::labToCms(V4p2)).Vect();
288  const double temp = V3p1.Angle(V3p2);
289  if (maxAngleGGLE < temp) maxAngleGGLE = temp;
290  }
291  }
292  }
293 
294  calculationResult["maxAngleGGLE"] = maxAngleGGLE;
295 
296  // nEidLE
297  const unsigned int nEidLE = std::count_if(m_pionParticles->begin(), m_pionParticles->end(),
298  [](const Particle & p) {
299  const double& momentum = p.getMomentumMagnitude();
300  const double& r_rho = getRho(&p);
301  const ECLCluster* eclTrack = p.getECLCluster();
302  if (eclTrack) {
303  const double& energyOverMomentum = eclTrack->getEnergy(
304  ECLCluster::EHypothesisBit::c_nPhotons) / momentum;
305  double r_rhotoebeam = r_rho / BeamEnergyCMS();
306  return (r_rhotoebeam) > 0.35 && energyOverMomentum > 0.8;
307  }
308  return false;
309  });
310 
311  calculationResult["nEidLE"] = nEidLE;
312 
313 
314  // VisibleEnergyLE
315  const double visibleEnergyTracks = std::accumulate(m_pionParticles->begin(), m_pionParticles->end(), 0.0,
316  [](const double & visibleEnergy, const Particle & p) {
317  return visibleEnergy + p.getMomentumMagnitude();
318  });
319 
320  const double visibleEnergyGammas = std::accumulate(m_gammaParticles->begin(), m_gammaParticles->end(), 0.0,
321  [](const double & visibleEnergy, const Particle & p) {
322  return visibleEnergy + p.getMomentumMagnitude();
323  });
324 
325  calculationResult["VisibleEnergyLE"] = visibleEnergyTracks + visibleEnergyGammas;
326 
327  // EtotLE
328  const double eTotTracks = std::accumulate(m_pionParticles->begin(), m_pionParticles->end(), 0.0,
329  [](const double & eTot, const Particle & p) {
330  const ECLCluster* eclCluster = p.getECLCluster();
331  if (eclCluster) {
332  const double eclEnergy = eclCluster->getEnergy(
333  ECLCluster::EHypothesisBit::c_nPhotons);
334  if (eclEnergy > 0.1) {
335  return eTot + eclCluster->getEnergy(
336  ECLCluster::EHypothesisBit::c_nPhotons);
337  }
338  }
339  return eTot;
340  });
341 
342  const double eTotGammas = std::accumulate(m_gammaParticles->begin(), m_gammaParticles->end(), 0.0,
343  [](const double & eTot, const Particle & p) {
344  return eTot + p.getEnergy();
345  });
346  double Etot = eTotTracks + eTotGammas;
347  calculationResult["EtotLE"] = Etot;
348 
349  //KLM inforamtion
350  // The clusters with the largest pentrate layers in KLM.
351  double numMaxLayerKLM = -1.;
352  double numSecMaxLayerKLM = -1.;
353  StoreArray<KLMCluster> klmClusters;
354  if (klmClusters.isValid()) {
355  for (const auto& klmCluster : klmClusters) {
356  double klmClusterLayer = klmCluster.getLayers();
357  if (numMaxLayerKLM < klmClusterLayer) {
358  numSecMaxLayerKLM = numMaxLayerKLM;
359  numMaxLayerKLM = klmClusterLayer;
360  } else if (numSecMaxLayerKLM < klmClusterLayer)
361  numSecMaxLayerKLM = klmClusterLayer;
362  }
363  }
364  calculationResult["N1KLMLayer"] = numMaxLayerKLM;
365  calculationResult["N2KLMLayer"] = numSecMaxLayerKLM;
366 
367  //define bhabha_2trk, bhabha_1trk, eclbhabha
368  int charget1 = -10;
369  if (trackWithMaximumRho) charget1 = trackWithMaximumRho->getCharge();
370  int charget2 = -10;
371  if (trackWithSecondMaximumRho) charget2 = trackWithSecondMaximumRho->getCharge();
372 
373  double Bhabha2Trk = 0.;
374  int ntrk_bha = m_pionParticles->getListSize();
375  double rp1ob = rhoOfTrackWithMaximumRho / BeamEnergyCMS();
376  double rp2ob = rhoOfTrackWithSecondMaximumRho / BeamEnergyCMS();
377  bool bhabha2trk_tag =
378  ntrk_bha >= 2 && maxAngleTTLE > 2.88 && nEidLE >= 1 && rp1ob > 0.35 && rp2ob > 0.35 && (Etot) > 4.0
379  && (abs(charget1) == 1 && abs(charget2) == 1 && (charget1 + charget2) == 0);
380  if (bhabha2trk_tag) Bhabha2Trk = 1;
381  calculationResult["Bhabha2Trk"] = Bhabha2Trk;
382 
383  double Bhabha1Trk = 0.;
384  double rc1ob = rhoOfGammaWithMaximumRho / BeamEnergyCMS();
385  double rc2ob = rhoOfGammaWithSecondMaximumRho / BeamEnergyCMS();
386  bool bhabha1trk_tag = ntrk_bha == 1 && rp1ob > 0.35 && rc1ob > 0.35 && angleGTLE > 2.618;
387  if (bhabha1trk_tag) Bhabha1Trk = 1;
388  calculationResult["Bhabha1Trk"] = Bhabha1Trk;
389 
390  double ggSel = 0.;
391  bool gg_tag = ntrk_bha <= 1 && nEidLE == 0 && rc1ob > 0.35 && rc2ob > 0.2 && Etot > 4.0 && maxAngleGGLE > 2.618;
392  if (gg_tag) ggSel = 1;
393  calculationResult["GG"] = ggSel;
394 
395  // Bhabha skim with ECL information only (bhabhaecl)
396  double BhabhaECL = 0.;
397  ClusterUtils Cls;
398  for (int i = 0; i < eclClusters.getEntries() - 1; i++) {
399  if (!eclClusters[i]->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons))
400  continue;
401 
402  ROOT::Math::PxPyPzEVector V4g1 = PCmsLabTransform::labToCms(Cls.Get4MomentumFromCluster(eclClusters[i],
403  ECLCluster::EHypothesisBit::c_nPhotons));
404  double Eg1ob = V4g1.E() / (2 * BeamEnergyCMS());
405  for (int j = i + 1; j < eclClusters.getEntries(); j++) {
406  if (!eclClusters[j]->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons))
407  continue;
408  ROOT::Math::PxPyPzEVector V4g2 = PCmsLabTransform::labToCms(Cls.Get4MomentumFromCluster(eclClusters[j],
409  ECLCluster::EHypothesisBit::c_nPhotons));
410  double Eg2ob = V4g2.E() / (2 * BeamEnergyCMS());
411  const B2Vector3D V3g1 = V4g1.Vect();
412  const B2Vector3D V3g2 = V4g2.Vect();
413  double Thetag1 = V4g1.Theta() * TMath::RadToDeg();
414  double Thetag2 = V4g2.Theta() * TMath::RadToDeg();
415  double deltphi = fabs(V3g1.DeltaPhi(V3g2) * TMath::RadToDeg());
416  double Tsum = Thetag1 + Thetag2;
417  if ((deltphi > 165. && deltphi < 178.5) && (Eg1ob > 0.4 && Eg2ob > 0.4 && (Eg1ob > 0.45 || Eg2ob > 0.45)) && (Tsum > 178.
418  && Tsum < 182.)) BhabhaECL = 1;
419  }
420  }
421  calculationResult["BhabhaECL"] = BhabhaECL;
422 
423  // Radiative Bhabha skim (radee) for CDC dE/dx calib studies
424  double radee = 0.;
425  const double lowdEdxEdge = 0.70, highdEdxEdge = 1.30;
426  const double lowEoPEdge = 0.70, highEoPEdge = 1.30;
427 
428  if (m_pionParticles->getListSize() == 2) {
429 
430  //------------First track variables----------------
431  for (unsigned int i = 0; i < m_pionParticles->getListSize() - 1; i++) {
432 
433  Particle* part1 = m_pionParticles->getParticle(i);
434  if (!part1) continue;
435 
436  const auto chargep1 = part1->getCharge();
437  if (abs(chargep1) != 1) continue;
438 
439  const ECLCluster* eclTrack1 = part1->getECLCluster();
440  if (!eclTrack1) continue;
441  if (!eclTrack1->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons)) continue;
442 
443  const double& momentum1 = part1->getMomentumMagnitude();
444  const double& energyOverMomentum1 = eclTrack1->getEnergy(ECLCluster::EHypothesisBit::c_nPhotons) / momentum1;
445  if (energyOverMomentum1 <= lowEoPEdge || energyOverMomentum1 >= highEoPEdge) continue;
446 
447  const Track* track1 = part1->getTrack();
448  if (!track1) continue;
449 
450  const TrackFitResult* trackFit1 = track1->getTrackFitResultWithClosestMass(Const::pion);
451  if (!trackFit1) continue;
452  if (trackFit1->getHitPatternCDC().getNHits() <= 0) continue;
453 
454  const CDCDedxTrack* dedxTrack1 = track1->getRelatedTo<CDCDedxTrack>();
455  if (!dedxTrack1) continue;
456 
457  //------------Second track variables----------------
458  for (unsigned int j = i + 1; j < m_pionParticles->getListSize(); j++) {
459 
460  Particle* part2 = m_pionParticles->getParticle(j);
461  if (!part2) continue;
462 
463  const auto chargep2 = part2->getCharge();
464  if (abs(chargep2) != 1 || (chargep1 + chargep2 != 0)) continue;
465 
466  const ECLCluster* eclTrack2 = part2->getECLCluster();
467  if (!eclTrack2) continue;
468  if (!eclTrack2->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons)) continue;
469 
470  const double& momentum2 = part2->getMomentumMagnitude();
471  const double& energyOverMomentum2 = eclTrack2->getEnergy(ECLCluster::EHypothesisBit::c_nPhotons) / momentum2;
472  if (energyOverMomentum2 <= lowEoPEdge || energyOverMomentum2 >= highEoPEdge) continue;
473 
474  const Track* track2 = part2->getTrack();
475  if (!track2) continue;
476 
477  const TrackFitResult* trackFit2 = track2->getTrackFitResultWithClosestMass(Const::pion);
478  if (!trackFit2) continue;
479  if (trackFit2->getHitPatternCDC().getNHits() <= 0) continue;
480 
481  CDCDedxTrack* dedxTrack2 = track2->getRelatedTo<CDCDedxTrack>();
482  if (!dedxTrack2) continue;
483 
484  double p1_dedxnosat = dedxTrack1->getDedxNoSat();
485  double p2_dedxnosat = dedxTrack2->getDedxNoSat();
486 
487  if ((p1_dedxnosat > lowdEdxEdge && p1_dedxnosat < highdEdxEdge) || (p2_dedxnosat > lowdEdxEdge
488  && p2_dedxnosat < highdEdxEdge))radee = 1;
489 
490  }
491  }
492  }
493 
494  calculationResult["Radee"] = radee;
495 
496  // Dimuon skim (mumutight) taken from the offline skim + Radiative dimuon (radmumu)
497  double mumutight = 0.;
498  double eMumuTotGammas = 0.;
499  int nTracks = 0;
500  double radmumu = 0.;
501  int nGammas = m_gammaParticles->getListSize();
502 
503  for (int t = 0; t < nGammas; t++) {
504  const Particle* part = m_gammaParticles->getParticle(t);
505  const auto& frame = ReferenceFrame::GetCurrent();
506  eMumuTotGammas += frame.getMomentum(part).E();
507  }
508 
509  StoreArray<Track> tracks;
510  nTracks = tracks.getEntries();
511  PCmsLabTransform T;
512  const ROOT::Math::PxPyPzEVector pIN = T.getBeamFourMomentum();
513  const auto& fr = ReferenceFrame::GetCurrent();
514 
515  if (m_pionParticles->getListSize() == 2) {
516 
517  //------------First track variables----------------
518  for (unsigned int k = 0; k < m_pionParticles->getListSize() - 1; k++) {
519 
520  Particle* part1 = m_pionParticles->getParticle(k);
521  if (!part1) continue;
522 
523  const auto chargep1 = part1->getCharge();
524  if (abs(chargep1) != 1) continue;
525 
526  const ECLCluster* eclTrack1 = part1->getECLCluster();
527  if (!eclTrack1) continue;
528  if (!eclTrack1->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons)) continue;
529 
530  const Track* track1 = part1->getTrack();
531  if (!track1) continue;
532 
533  const TrackFitResult* trackFit1 = track1->getTrackFitResultWithClosestMass(Const::pion);
534  if (!trackFit1) continue;
535 
536  const ROOT::Math::PxPyPzEVector V4p1 = trackFit1->get4Momentum();
537  const B2Vector3D V3p1 = (PCmsLabTransform::labToCms(V4p1)).Vect();
538 
539  const double p1MomLab = V4p1.P();
540  double highestP = p1MomLab;
541  const double p1CDChits = trackFit1->getHitPatternCDC().getNHits();
542  const PIDLikelihood* p1Pid = part1->getPIDLikelihood();
543  bool p1hasKLMid = 0;
544  if (p1Pid) p1hasKLMid = p1Pid->isAvailable(Const::KLM);
545  const double p1isInCDC = Variable::inCDCAcceptance(part1);
546  const double p1clusPhi = Variable::eclClusterPhi(part1);
547 
548  const double Pp1 = V3p1.Mag();
549  const double Thetap1 = (V3p1).Theta() * TMath::RadToDeg();
550  const double Phip1 = (V3p1).Phi() * TMath::RadToDeg();
551 
552  const double enECLTrack1 = eclTrack1->getEnergy(ECLCluster::EHypothesisBit::c_nPhotons);
553 
554  const bool goodTrk1 = enECLTrack1 > 0 && enECLTrack1 < 0.5 && p1CDChits > 0
555  && ((p1hasKLMid == 0 && enECLTrack1 < 0.25 && p1MomLab < 2.0) || p1hasKLMid == 1) && p1isInCDC == 1;
556 
557  //------------Second track variables----------------
558  for (unsigned int l = k + 1; l < m_pionParticles->getListSize(); l++) {
559 
560  Particle* part2 = m_pionParticles->getParticle(l);
561  if (!part2) continue;
562 
563  const auto chargep2 = part2->getCharge();
564  if (abs(chargep2) != 1 || (chargep1 + chargep2 != 0)) continue;
565 
566  const ECLCluster* eclTrack2 = part2->getECLCluster();
567  if (!eclTrack2) continue;
568  if (!eclTrack2->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons)) continue;
569 
570  const Track* track2 = part2->getTrack();
571  if (!track2) continue;
572 
573  const TrackFitResult* trackFit2 = track2->getTrackFitResultWithClosestMass(Const::pion);
574  if (!trackFit2) continue;
575 
576  const ROOT::Math::PxPyPzEVector V4p2 = trackFit2->get4Momentum();
577  const B2Vector3D V3p2 = (PCmsLabTransform::labToCms(V4p2)).Vect();
578 
579  const double p2MomLab = V4p2.P();
580  double lowestP = p2MomLab;
581  const double p2CDChits = trackFit2->getHitPatternCDC().getNHits();
582  const PIDLikelihood* p2Pid = part2->getPIDLikelihood();
583  bool p2hasKLMid = 0;
584  if (p2Pid) p2hasKLMid = p2Pid->isAvailable(Const::KLM);
585  const double p2isInCDC = Variable::inCDCAcceptance(part2);
586  const double p2clusPhi = Variable::eclClusterPhi(part2);
587 
588  const double Pp2 = V3p2.Mag();
589  const double Thetap2 = (V3p2).Theta() * TMath::RadToDeg();
590  const double Phip2 = (V3p2).Phi() * TMath::RadToDeg();
591 
592  const double acopPhi = fabs(180 - fabs(Phip1 - Phip2));
593  const double acopTheta = fabs(fabs(Thetap1 + Thetap2) - 180);
594 
595  const double enECLTrack2 = eclTrack2->getEnergy(ECLCluster::EHypothesisBit::c_nPhotons);
596 
597  const bool goodTrk2 = enECLTrack2 > 0 && enECLTrack2 < 0.5 && p2CDChits > 0
598  && ((p2hasKLMid == 0 && enECLTrack2 < 0.25 && p2MomLab < 2.0) || p2hasKLMid == 1) && p2isInCDC == 1;
599 
600  double eTotMumuTracks = enECLTrack1 + enECLTrack2;
601  double EMumutot = eTotMumuTracks + eMumuTotGammas;
602 
603  bool mumutight_tag = enECLTrack1 < 0.5 && enECLTrack2 < 0.5 && EMumutot < 2 && acopPhi < 10 && acopTheta < 10 && nTracks == 2
604  && Pp1 > 0.5 && Pp2 > 0.5;
605 
606  if (mumutight_tag) mumutight = 1;
607 
608  if (p1MomLab < p2MomLab) {
609  lowestP = highestP;
610  highestP = p2MomLab;
611  }
612 
613  double diffPhi = p1clusPhi - p2clusPhi;
614  if (fabs(diffPhi) > M_PI) {
615  if (diffPhi > M_PI) {
616  diffPhi = diffPhi - 2 * M_PI;
617  } else {
618  diffPhi = 2 * M_PI + diffPhi;
619  }
620  }
621 
622  const double recoilP = fr.getMomentum(pIN - V4p1 - V4p2).P();
623 
624  const bool radmumu_tag = nTracks < 4 && goodTrk1 == 1 && goodTrk2 == 1 && highestP > 1 && lowestP < 3 && (p1hasKLMid == 1
625  || p2hasKLMid == 1) && abs(diffPhi) >= 0.5 * M_PI && recoilP > 0.1 && (enECLTrack1 <= 0.25 || enECLTrack2 <= 0.25);
626 
627  if (radmumu_tag) radmumu = 1;
628 
629  }
630  }
631  }
632 
633  calculationResult["MumuTight"] = mumutight;
634  calculationResult["Radmumu"] = radmumu;
635 
636  //Retrieve variables for HadronB skims
637  double EsumPiHad = 0;
638  double PzPiHad = 0;
639  int nHadTracks = m_pionHadParticles->getListSize();
640  double hadronb = 0;
641  double hadronb1 = 0;
642  double hadronb2 = 0;
643  std::vector<ROOT::Math::XYZVector> m_pionHadv3;
644 
645  for (int nPiHad = 0; nPiHad < nHadTracks; nPiHad++) {
646  Particle* parPiHad = m_pionHadParticles->getParticle(nPiHad);
647  ROOT::Math::PxPyPzEVector V4PiHad = PCmsLabTransform::labToCms(parPiHad->get4Vector());
648  m_pionHadv3.push_back(parPiHad->getMomentum());
649  EsumPiHad += V4PiHad.E();
650  PzPiHad += V4PiHad.Pz();
651  }
652 
653  double visibleEnergyCMSnorm = (EsumPiHad + EsumGamma) / (BeamEnergyCMS() * 2.0);
654  double EsumCMSnorm = eneclClusters / (BeamEnergyCMS() * 2.0);
655  double PzTotCMSnorm = (PzPiHad + PzGamma) / (BeamEnergyCMS() * 2.0);
656 
657  bool hadronb_tag = nHadTracks >= 3 && visibleEnergyCMSnorm > 0.2 && abs(PzTotCMSnorm) < 0.5 && neclClusters > 1
658  && EsumCMSnorm > 0.1 && EsumCMSnorm < 0.8;
659 
660  if (hadronb_tag) {
661  hadronb = 1;
662  FoxWolfram fw(m_pionHadv3);
663  fw.calculateBasicMoments();
664  double R2 = fw.getR(2);
665  if (R2 < 0.4) hadronb1 = 1;
666  if (hadronb1 && nHadTracks >= 5) hadronb2 = 1;
667  }
668 
669  calculationResult["HadronB"] = hadronb;
670  calculationResult["HadronB1"] = hadronb1;
671  calculationResult["HadronB2"] = hadronb2;
672 
673  // nKshort
674  int nKshort = 0;
675  double Kshort = 0.;
676  const double KsMassLow = 0.468;
677  const double KsMassHigh = 0.528;
678 
679  if (m_KsParticles.isValid()) {
680  for (unsigned int i = 0; i < m_KsParticles->getListSize(); i++) {
681  const Particle* mergeKsCand = m_KsParticles->getParticle(i);
682  const double isKsCandGood = Variable::goodBelleKshort(mergeKsCand);
683  const double KsCandMass = mergeKsCand->getMass();
684  if (KsCandMass > KsMassLow && KsCandMass < KsMassHigh && isKsCandGood == 1.) nKshort++;
685  }
686  }
687 
688  if (nKshort != 0) Kshort = 1;
689 
690  calculationResult["Kshort"] = Kshort;
691 
692  // 4 leptons skim
693  int nFourLep = 0;
694  double fourLep = 0.;
695 
696  const double visibleEnergyCMS = visibleEnergyCMSnorm * BeamEnergyCMS() * 2.0;
697  const unsigned int n_particles = m_pionHadParticles->getListSize();
698 
699  if (n_particles >= 2) {
700  for (unsigned int i = 0; i < n_particles - 1; i++) {
701  Particle* par1 = m_pionHadParticles->getParticle(i);
702  for (unsigned int j = i + 1; j < n_particles; j++) {
703  Particle* par2 = m_pionHadParticles->getParticle(j);
704  const auto chSum = par1->getCharge() + par2->getCharge();
705  const ROOT::Math::PxPyPzEVector V4p1 = par1->get4Vector();
706  const ROOT::Math::PxPyPzEVector V4p2 = par2->get4Vector();
707  const double opAng = V4p1.Theta() + V4p2.Theta();
708  const ROOT::Math::PxPyPzEVector V4pSum = V4p1 + V4p2;
709  const ROOT::Math::PxPyPzEVector V4pSumCMS = PCmsLabTransform::labToCms(V4pSum);
710  const double ptCMS = V4pSumCMS.Pt();
711  const double pzCMS = V4pSumCMS.Pz();
712  const double mSum = V4pSum.M();
713 
714  const bool fourLepCand = chSum == 0 && (V4p1.P() > 0.4 && V4p2.P() > 0.4) && cos(opAng) > -0.997 && ptCMS < 0.15 && abs(pzCMS) < 2.5
715  && mSum < 6;
716 
717  if (fourLepCand) nFourLep++;
718  }
719  }
720  }
721 
722  if (nFourLep != 0 && visibleEnergyCMS < 6) fourLep = 1;
723 
724  calculationResult["FourLep"] = fourLep;
725 
726  // nLambda
727  unsigned int nLambda = 0;
728 
729  if (m_LambdaParticles.isValid()) {
730  for (unsigned int i = 0; i < m_LambdaParticles->getListSize(); i++) {
731  const Particle* mergeLambdaCand = m_LambdaParticles->getParticle(i);
732  const double flightDist = Variable::flightDistance(mergeLambdaCand);
733  const double flightDistErr = Variable::flightDistanceErr(mergeLambdaCand);
734  const double flightSign = flightDist / flightDistErr;
735  const Particle* protCand = mergeLambdaCand->getDaughter(0);
736  const Particle* pionCand = mergeLambdaCand->getDaughter(1);
737  const double protMom = protCand->getP();
738  const double pionMom = pionCand->getP();
739  const double asymPDaughters = (protMom - pionMom) / (protMom + pionMom);
740  if (flightSign > 10 && asymPDaughters > 0.41) nLambda++;
741  }
742  }
743 
744  if (nLambda > 0) {
745  calculationResult["Lambda"] = 1;
746  } else {
747  calculationResult["Lambda"] = 0;
748  }
749 
750  // nDstp
751  unsigned int nDstp1 = 0;
752  unsigned int nDstp2 = 0;
753  unsigned int nDstp3 = 0;
754  unsigned int nDstp4 = 0;
755 
756  if (m_DstParticles.isValid() && (ntrk_bha >= 3 && Bhabha2Trk == 0)) {
757  for (unsigned int i = 0; i < m_DstParticles->getListSize(); i++) {
758  const Particle* allDstCand = m_DstParticles->getParticle(i);
759  const double dstDecID = allDstCand->getExtraInfo("decayModeID");
760  if (dstDecID == 1.) nDstp1++;
761  if (dstDecID == 2.) nDstp2++;
762  if (dstDecID == 3.) nDstp3++;
763  if (dstDecID == 4.) nDstp4++;
764  }
765  }
766 
767 
768  if (nDstp1 > 0) {
769  calculationResult["Dstp1"] = 1;
770  } else {
771  calculationResult["Dstp1"] = 0;
772  }
773 
774  if (nDstp2 > 0) {
775  calculationResult["Dstp2"] = 1;
776  } else {
777  calculationResult["Dstp2"] = 0;
778  }
779 
780  if (nDstp3 > 0) {
781  calculationResult["Dstp3"] = 1;
782  } else {
783  calculationResult["Dstp3"] = 0;
784  }
785 
786  if (nDstp4 > 0) {
787  calculationResult["Dstp4"] = 1;
788  } else {
789  calculationResult["Dstp4"] = 0;
790  }
791 
792  // nTracksOffIP
793  calculationResult["nTracksOffIP"] = m_offIpParticles->getListSize();
794 
795  // Flag for events with Trigger B2Link information
796  calculationResult["NeuroTRG"] = 0;
797  calculationResult["GammaGammaFilter"] = 0;
798 
799  StoreObjPtr<SoftwareTriggerResult> filter_result;
800  if (filter_result.isValid()) {
801  const std::map<std::string, int>& nonPrescaledResults = filter_result->getNonPrescaledResults();
802  if (nonPrescaledResults.find(m_filterL1TrgNN) != nonPrescaledResults.end()) {
803  const bool hasNN = (filter_result->getNonPrescaledResult(m_filterL1TrgNN) == SoftwareTriggerCutResult::c_accept);
804  if (hasNN) calculationResult["NeuroTRG"] = 1;
805  }
806  const bool ggEndcap = (filter_result->getNonPrescaledResult("software_trigger_cut&filter&ggEndcapLoose") ==
807  SoftwareTriggerCutResult::c_accept);
808  const bool ggBarrel = (filter_result->getNonPrescaledResult("software_trigger_cut&filter&ggBarrelLoose") ==
809  SoftwareTriggerCutResult::c_accept);
810  if (ggEndcap || ggBarrel) calculationResult["GammaGammaFilter"] = 1;
811  }
812 
813  //Dimuon skim with invariant mass cut allowing at most one track not to be associated with ECL clusters
814 
815  double mumuHighMass = 0.;
816 
817  if (trackWithMaximumRho && trackWithSecondMaximumRho) {
818  int hasClus = 0;
819  double eclE1 = 0., eclE2 = 0.;
820 
821  const auto charge1 = trackWithMaximumRho->getCharge();
822  const auto charge2 = trackWithSecondMaximumRho->getCharge();
823  const auto chSum = charge1 + charge2;
824 
825  const ECLCluster* eclTrack1 = trackWithMaximumRho->getECLCluster();
826  if (eclTrack1) {
827  hasClus++;
828  eclE1 = eclTrack1->getEnergy(ECLCluster::EHypothesisBit::c_nPhotons);
829  }
830 
831  const ECLCluster* eclTrack2 = trackWithSecondMaximumRho->getECLCluster();
832  if (eclTrack2) {
833  hasClus++;
834  eclE2 = eclTrack2->getEnergy(ECLCluster::EHypothesisBit::c_nPhotons);
835  }
836  const ROOT::Math::PxPyPzEVector V4p1 = PCmsLabTransform::labToCms(trackWithMaximumRho->get4Vector());
837  const ROOT::Math::PxPyPzEVector V4p2 = PCmsLabTransform::labToCms(trackWithSecondMaximumRho->get4Vector());
838 
839  const ROOT::Math::PxPyPzEVector V4pSum = V4p1 + V4p2;
840  const double mSum = V4pSum.M();
841 
842  const double thetaSumCMS = (V4p1.Theta() + V4p2.Theta()) * TMath::RadToDeg();
843  const double phi1CMS = V4p1.Phi() * TMath::RadToDeg();
844  const double phi2CMS = V4p2.Phi() * TMath::RadToDeg();
845 
846  double diffPhi = phi1CMS - phi2CMS;
847  if (fabs(diffPhi) > 180) {
848  if (diffPhi > 180) {
849  diffPhi = diffPhi - 2 * 180;
850  } else {
851  diffPhi = 2 * 180 + diffPhi;
852  }
853  }
854  const double delThetaCMS = fabs(fabs(thetaSumCMS) - 180);
855  const double delPhiCMS = fabs(180 - fabs(diffPhi));
856 
857  const bool mumuHighMassCand = chSum == 0 && (mSum > 8. && mSum < 12.) && hasClus > 0 && eclE1 <= 1
858  && eclE2 <= 1 && delThetaCMS < 10 && delPhiCMS < 10;
859 
860  if (mumuHighMassCand) mumuHighMass = 1;
861 
862  }
863 
864  calculationResult["MumuHighM"] = mumuHighMass;
865 
866  // BtoCharm skims
867  calculationResult["Bp"] = 0;
868  calculationResult["Bz"] = 0;
869 
870  if (m_BpParticles.isValid() && (ntrk_bha >= 3 && Bhabha2Trk == 0)) {
871  calculationResult["Bp"] = m_BpParticles->getListSize() >= 1;
872  }
873 
874  if (m_BzParticles.isValid() && (ntrk_bha >= 3 && Bhabha2Trk == 0)) {
875  calculationResult["Bz"] = m_BzParticles->getListSize() >= 1;
876  }
877 
878 }
Belle2::B2Vector3::Theta
DataType Theta() const
The polar angle.
Definition: B2Vector3.h:153
Belle2::B2Vector3::DeltaPhi
DataType DeltaPhi(const B2Vector3< DataType > &v) const
returns phi in the interval [-PI,PI)
Definition: B2Vector3.h:228
Belle2::B2Vector3::Mag
DataType Mag() const
The magnitude (rho in spherical coordinate system).
Definition: B2Vector3.h:159
Belle2::B2Vector3::Angle
DataType Angle(const B2Vector3< DataType > &q) const
The angle w.r.t.
Definition: B2Vector3.h:302
Belle2::CDCDedxTrack
Debug output for CDCDedxPID module.
Definition: CDCDedxTrack.h:25
Belle2::CDCDedxTrack::getDedxNoSat
double getDedxNoSat() const
Get dE/dx truncated mean without the saturation correction for this track.
Definition: CDCDedxTrack.h:106
Belle2::ClusterUtils
Class to provide momentum-related information from ECLClusters.
Definition: ClusterUtils.h:35
Belle2::ClusterUtils::Get4MomentumFromCluster
const ROOT::Math::PxPyPzEVector Get4MomentumFromCluster(const ECLCluster *cluster, ECLCluster::EHypothesisBit hypo)
Returns four momentum vector.
Definition: ClusterUtils.cc:25
Belle2::Const::pion
static const ChargedStable pion
charged pion particle
Definition: Const.h:652
Belle2::ECLCluster
ECL cluster data.
Definition: ECLCluster.h:27
Belle2::ECLCluster::hasHypothesis
bool hasHypothesis(EHypothesisBit bitmask) const
Return if specific hypothesis bit is set.
Definition: ECLCluster.h:348
Belle2::ECLCluster::getEnergy
double getEnergy(EHypothesisBit hypothesis) const
Return Energy (GeV).
Definition: ECLCluster.cc:23
Belle2::ECLCluster::EHypothesisBit::c_nPhotons
@ c_nPhotons
CR is split into n photons (N1)
Belle2::FoxWolfram
Class to calculate the Fox-Wolfram moments up to order 8.
Definition: FoxWolfram.h:28
Belle2::HitPatternCDC::getNHits
unsigned short getNHits() const
Get the total Number of CDC hits in the fit.
Definition: HitPatternCDC.cc:47
Belle2::PCmsLabTransform
Class to hold Lorentz transformations from/to CMS and boost vector.
Definition: PCmsLabTransform.h:31
Belle2::PCmsLabTransform::getBeamFourMomentum
ROOT::Math::PxPyPzEVector getBeamFourMomentum() const
Returns LAB four-momentum of e+e-, i.e.
Definition: PCmsLabTransform.h:59
Belle2::PCmsLabTransform::labToCms
static ROOT::Math::PxPyPzMVector labToCms(const ROOT::Math::PxPyPzMVector &vec)
Transforms Lorentz vector into CM System.
Definition: PCmsLabTransform.cc:13
Belle2::PIDLikelihood
Class to collect log likelihoods from TOP, ARICH, dEdx, ECL and KLM aimed for output to mdst includes...
Definition: PIDLikelihood.h:26
Belle2::PIDLikelihood::isAvailable
bool isAvailable(Const::PIDDetectorSet set) const
Check whether PID information from a given set of detectors is available.
Definition: PIDLikelihood.h:50
Belle2::Particle
Class to store reconstructed particles.
Definition: Particle.h:75
Belle2::Particle::getTrack
const Track * getTrack() const
Returns the pointer to the Track object that was used to create this Particle (ParticleType == c_Trac...
Definition: Particle.cc:849
Belle2::Particle::getECLCluster
const ECLCluster * getECLCluster() const
Returns the pointer to the ECLCluster object that was used to create this Particle (if ParticleType =...
Definition: Particle.cc:895
Belle2::Particle::getPIDLikelihood
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:875
Belle2::Particle::getCharge
double getCharge(void) const
Returns particle charge.
Definition: Particle.cc:626
Belle2::Particle::get4Vector
ROOT::Math::PxPyPzEVector get4Vector() const
Returns Lorentz vector.
Definition: Particle.h:517
Belle2::Particle::getMomentum
ROOT::Math::XYZVector getMomentum() const
Returns momentum vector.
Definition: Particle.h:526
Belle2::Particle::getMomentumMagnitude
double getMomentumMagnitude() const
Returns momentum magnitude.
Definition: Particle.h:535
Belle2::Particle::getP
double getP() const
Returns momentum magnitude (same as getMomentumMagnitude but with shorter name)
Definition: Particle.h:544
Belle2::Particle::getDaughter
const Particle * getDaughter(unsigned i) const
Returns a pointer to the i-th daughter particle.
Definition: Particle.cc:635
Belle2::Particle::getExtraInfo
double getExtraInfo(const std::string &name) const
Return given value if set.
Definition: Particle.cc:1290
Belle2::Particle::getMass
double getMass() const
Returns invariant mass (= nominal for FS particles)
Definition: Particle.h:479
Belle2::ReferenceFrame::GetCurrent
static const ReferenceFrame & GetCurrent()
Get current rest frame.
Definition: ReferenceFrame.cc:26
Belle2::SoftwareTrigger::SkimSampleCalculator::m_pionParticles
StoreObjPtr< ParticleList > m_pionParticles
Internal storage of the tracks as particles.
Definition: SkimSampleCalculator.h:41
Belle2::SoftwareTrigger::SkimSampleCalculator::m_gammaParticles
StoreObjPtr< ParticleList > m_gammaParticles
Internal storage of the ECL clusters as particles.
Definition: SkimSampleCalculator.h:43
Belle2::SoftwareTrigger::SkimSampleCalculator::m_BzParticles
StoreObjPtr< ParticleList > m_BzParticles
Internal storage of the B0's.
Definition: SkimSampleCalculator.h:61
Belle2::SoftwareTrigger::SkimSampleCalculator::m_LambdaParticles
StoreObjPtr< ParticleList > m_LambdaParticles
Internal storage of the Lambda0's.
Definition: SkimSampleCalculator.h:51
Belle2::SoftwareTrigger::SkimSampleCalculator::m_pionHadParticles
StoreObjPtr< ParticleList > m_pionHadParticles
Internal storage of the tracks as particles (definition for hadronb).
Definition: SkimSampleCalculator.h:45
Belle2::SoftwareTrigger::SkimSampleCalculator::requireStoreArrays
void requireStoreArrays() override
Require the particle list. We do not need more here.
Definition: SkimSampleCalculator.cc:51
Belle2::SoftwareTrigger::SkimSampleCalculator::doCalculation
void doCalculation(SoftwareTriggerObject &calculationResult) override
Actually write out the variables into the map.
Definition: SkimSampleCalculator.cc:66
Belle2::SoftwareTrigger::SkimSampleCalculator::SkimSampleCalculator
SkimSampleCalculator()
Set the default names for the store object particle lists.
Definition: SkimSampleCalculator.cc:42
Belle2::SoftwareTrigger::SkimSampleCalculator::m_KsParticles
StoreObjPtr< ParticleList > m_KsParticles
Internal storage of the K_S0's.
Definition: SkimSampleCalculator.h:49
Belle2::SoftwareTrigger::SkimSampleCalculator::m_DstParticles
StoreObjPtr< ParticleList > m_DstParticles
Internal storage of the D*'s.
Definition: SkimSampleCalculator.h:53
Belle2::SoftwareTrigger::SkimSampleCalculator::m_pionTauParticles
StoreObjPtr< ParticleList > m_pionTauParticles
Internal storage of the tracks as particles (definition for tau skims).
Definition: SkimSampleCalculator.h:47
Belle2::SoftwareTrigger::SkimSampleCalculator::m_BpParticles
StoreObjPtr< ParticleList > m_BpParticles
Internal storage of the B+'s.
Definition: SkimSampleCalculator.h:59
Belle2::SoftwareTrigger::SkimSampleCalculator::m_offIpParticles
StoreObjPtr< ParticleList > m_offIpParticles
Internal storage of the tracks for alignment calibration.
Definition: SkimSampleCalculator.h:55
Belle2::StoreArray
Accessor to arrays stored in the data store.
Definition: StoreArray.h:113
Belle2::StoreArray::isValid
bool isValid() const
Check wether the array was registered.
Definition: StoreArray.h:288
Belle2::StoreArray::getEntries
int getEntries() const
Get the number of objects in the array.
Definition: StoreArray.h:216
Belle2::StoreArray::end
iterator end()
Return iterator to last entry +1.
Definition: StoreArray.h:320
Belle2::StoreArray::begin
iterator begin()
Return iterator to first entry.
Definition: StoreArray.h:318
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition: StoreObjPtr.h:96
Belle2::StoreObjPtr::isValid
bool isValid() const
Check whether the object was created.
Definition: StoreObjPtr.h:111
Belle2::TrackFitResult
Values of the result of a track fit with a given particle hypothesis.
Definition: TrackFitResult.h:49
Belle2::TrackFitResult::get4Momentum
ROOT::Math::PxPyPzEVector get4Momentum() const
Getter for the 4Momentum at the closest approach of the track in the r/phi projection.
Definition: TrackFitResult.h:125
Belle2::TrackFitResult::getHitPatternCDC
HitPatternCDC getHitPatternCDC() const
Getter for the hit pattern in the CDC;.
Definition: TrackFitResult.cc:134
Belle2::Track
Class that bundles various TrackFitResults.
Definition: Track.h:25
Belle2::SoftwareTriggerCutResult::c_accept
@ c_accept
Accept this event.
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17