Belle II Software development
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 <mdst/dataobjects/HitPatternCDC.h>
26#include <mdst/dataobjects/KLMCluster.h>
27#include <mdst/dataobjects/PIDLikelihood.h>
28#include <mdst/dataobjects/SoftwareTriggerResult.h>
29#include <mdst/dataobjects/Track.h>
30#include <mdst/dataobjects/TrackFitResult.h>
31
32#include <cdc/dataobjects/CDCDedxTrack.h>
33
34#include <TDatabasePDG.h>
35#include <Math/Vector3D.h>
36#include <Math/Vector4D.h>
37#include <Math/VectorUtil.h>
38
39#include <cmath>
40#include <numeric>
41
42
43using namespace Belle2;
44using namespace SoftwareTrigger;
45
46SkimSampleCalculator::SkimSampleCalculator() :
47 m_pionParticles("pi+:skim"), m_gammaParticles("gamma:skim"), m_pionHadParticles("pi+:hadb"), m_pionTauParticles("pi+:tau"),
48 m_KsParticles("K_S0:merged"), m_LambdaParticles("Lambda0:merged"), m_DstParticles("D*+:d0pi"), m_offIpParticles("pi+:offip"),
49 m_filterL1TrgNN("software_trigger_cut&filter&L1_trigger_nn_info"),
50 m_BpParticles("B+:BtoCharmForHLT"), m_BzParticles("B0:BtoCharmForHLT")
51{
52
53}
54
55void SkimSampleCalculator::requireStoreArrays()
56{
57 m_pionParticles.isRequired();
58 m_gammaParticles.isRequired();
59 m_pionHadParticles.isRequired();
60 m_pionTauParticles.isRequired();
61 m_KsParticles.isOptional();
62 m_LambdaParticles.isOptional();
63 m_DstParticles.isOptional();
64 m_offIpParticles.isRequired();
65 m_BpParticles.isOptional();
66 m_BzParticles.isOptional();
67
68};
69
70void SkimSampleCalculator::doCalculation(SoftwareTriggerObject& calculationResult)
71{
72 // Prefetch some later needed objects/values
73 const Particle* gammaWithMaximumRho = getElementWithMaximumRho<Particle>(m_gammaParticles);
74 const Particle* gammaWithSecondMaximumRho = getElementWithMaximumRhoBelow<Particle>(m_gammaParticles,
75 getRho(gammaWithMaximumRho));
76 const Particle* trackWithMaximumRho = getElementWithMaximumRho<Particle>(m_pionParticles);
77 const Particle* trackWithSecondMaximumRho = getElementWithMaximumRhoBelow<Particle>(m_pionParticles,
78 getRho(trackWithMaximumRho));
79
80 const double& rhoOfECLClusterWithMaximumRho = getRhoOfECLClusterWithMaximumRho(m_pionParticles, m_gammaParticles);
81 const double& rhoOfECLClusterWithSecondMaximumRho = getRhoOfECLClusterWithMaximumRhoBelow(m_pionParticles,
82 m_gammaParticles,
83 rhoOfECLClusterWithMaximumRho);
84
85 const double& rhoOfTrackWithMaximumRho = getRho(trackWithMaximumRho);
86 const double& rhoOfTrackWithSecondMaximumRho = getRho(trackWithSecondMaximumRho);
87 const double& rhoOfGammaWithMaximumRho = getRho(gammaWithMaximumRho);
88 const double& rhoOfGammaWithSecondMaximumRho = getRho(gammaWithSecondMaximumRho);
89
90 // Simple to calculate variables
91 // EC1CMSLE
92 calculationResult["EC1CMSLE"] = rhoOfECLClusterWithMaximumRho;
93
94 // EC2CMSLE
95 calculationResult["EC2CMSLE"] = rhoOfECLClusterWithSecondMaximumRho;
96
97 // EC12CMSLE
98 calculationResult["EC12CMSLE"] = rhoOfECLClusterWithMaximumRho + rhoOfECLClusterWithSecondMaximumRho;
99
100 // nTracksLE
101 calculationResult["nTracksLE"] = m_pionParticles->getListSize();
102
103 // nTracksTAU
104 calculationResult["nTracksTAU"] = m_pionTauParticles->getListSize();
105
106 // nGammasLE
107 calculationResult["nGammasLE"] = m_gammaParticles->getListSize();
108
109 // P1CMSBhabhaLE
110 calculationResult["P1CMSBhabhaLE"] = rhoOfTrackWithMaximumRho;
111
112 // P1CMSBhabhaLE/E_beam
113 calculationResult["P1OEbeamCMSBhabhaLE"] = rhoOfTrackWithMaximumRho / BeamEnergyCMS();
114
115 // P2CMSBhabhaLE
116 calculationResult["P2CMSBhabhaLE"] = rhoOfTrackWithSecondMaximumRho;
117
118 // P2CMSBhabhaLE/E_beam
119 calculationResult["P2OEbeamCMSBhabhaLE"] = rhoOfTrackWithSecondMaximumRho / BeamEnergyCMS();
120
121 // P12CMSBhabhaLE
122 calculationResult["P12CMSBhabhaLE"] = rhoOfTrackWithMaximumRho + rhoOfTrackWithSecondMaximumRho;
123
124 //G1CMSLE, the largest energy of gamma in CMS
125 calculationResult["G1CMSBhabhaLE"] = rhoOfGammaWithMaximumRho;
126 //G1OEbeamCMSLE, the largest energy of gamma in CMS over beam energy
127 calculationResult["G1OEbeamCMSBhabhaLE"] = rhoOfGammaWithMaximumRho / BeamEnergyCMS();
128
129 //G2CMSLE, the secondary largest energy of gamma in CMS
130 calculationResult["G2CMSBhabhaLE"] = rhoOfGammaWithSecondMaximumRho;
131 //G2OEbeamCMSLE, the largest energy of gamma in CMS over beam energy
132 calculationResult["G2OEbeamCMSBhabhaLE"] = rhoOfGammaWithSecondMaximumRho / BeamEnergyCMS();
133
134 //G12CMSLE, the secondary largest energy of gamma in CMS
135 calculationResult["G12CMSBhabhaLE"] = rhoOfGammaWithMaximumRho + rhoOfGammaWithSecondMaximumRho;
136 //G12CMSLE, the secondary largest energy of gamma in CMS over beam energy
137 calculationResult["G12OEbeamCMSBhabhaLE"] =
138 (rhoOfGammaWithMaximumRho + rhoOfGammaWithSecondMaximumRho) / BeamEnergyCMS();
139
140
141 // Medium hard to calculate variables
142 // ENeutralLE
143 if (gammaWithMaximumRho) {
144 calculationResult["ENeutralLE"] = getRho(gammaWithMaximumRho);
145 } else {
146 calculationResult["ENeutralLE"] = -1;
147 }
148
149 // nECLMatchTracksLE
150 const unsigned int numberOfTracksWithECLMatch = std::count_if(m_pionParticles->begin(), m_pionParticles->end(),
151 [](const Particle & particle) {
152 return particle.getECLCluster() != nullptr;
153 });
154 calculationResult["nECLMatchTracksLE"] = numberOfTracksWithECLMatch;
155
156 //nECLClustersLE
157 double neclClusters = -1.;
158 double eneclClusters = 0.;
159 StoreArray<ECLCluster> eclClusters;
160 ClusterUtils Cl;
161 double PzGamma = 0.;
162 double EsumGamma = 0.;
163 if (eclClusters.isValid()) {
164 const unsigned int numberOfECLClusters = std::count_if(eclClusters.begin(), eclClusters.end(),
165 [](const ECLCluster & eclcluster) {
166 return (eclcluster.hasHypothesis(
167 ECLCluster::EHypothesisBit::c_nPhotons)
168 and eclcluster.getEnergy(
169 ECLCluster::EHypothesisBit::c_nPhotons) > 0.1);
170 });
171 neclClusters = numberOfECLClusters;
172
173 for (int ncl = 0; ncl < eclClusters.getEntries(); ncl++) {
174 if (eclClusters[ncl]->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons)
175 && eclClusters[ncl]->getEnergy(ECLCluster::EHypothesisBit::c_nPhotons) > 0.1) {
176 eneclClusters += eclClusters[ncl]->getEnergy(ECLCluster::EHypothesisBit::c_nPhotons);
177 if (!eclClusters[ncl]->getRelatedFrom<Track>()) {
178 ROOT::Math::PxPyPzEVector V4Gamma_CMS = PCmsLabTransform::labToCms(Cl.Get4MomentumFromCluster(eclClusters[ncl],
179 ECLCluster::EHypothesisBit::c_nPhotons));
180 EsumGamma += V4Gamma_CMS.E();
181 PzGamma += V4Gamma_CMS.Pz();
182 }
183 }
184 }
185 }
186 calculationResult["nECLClustersLE"] = neclClusters;
187
188 int nb2bcc_PhiHigh = 0;
189 int nb2bcc_PhiLow = 0;
190 int nb2bcc_3D = 0;
191 ClusterUtils C;
192 for (int i = 0; i < eclClusters.getEntries() - 1; i++) {
193 if (!eclClusters[i]->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons))
194 continue;
195 ROOT::Math::PxPyPzEVector V4g1 = C.Get4MomentumFromCluster(eclClusters[i], ECLCluster::EHypothesisBit::c_nPhotons);
196 double Eg1 = V4g1.E();
197 for (int j = i + 1; j < eclClusters.getEntries(); j++) {
198 if (!eclClusters[j]->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons))
199 continue;
200 ROOT::Math::PxPyPzEVector V4g2 = C.Get4MomentumFromCluster(eclClusters[j], ECLCluster::EHypothesisBit::c_nPhotons);
201 double Eg2 = V4g2.E();
202 const ROOT::Math::PxPyPzEVector V4g1CMS = PCmsLabTransform::labToCms(V4g1);
203 const ROOT::Math::PxPyPzEVector V4g2CMS = PCmsLabTransform::labToCms(V4g2);
204 double Thetag1 = V4g1CMS.Theta() * TMath::RadToDeg();
205 double Thetag2 = V4g2CMS.Theta() * TMath::RadToDeg();
206 double deltphi = std::abs(ROOT::Math::VectorUtil::DeltaPhi(V4g1CMS, V4g2CMS) * TMath::RadToDeg());
207 double Tsum = Thetag1 + Thetag2;
208 if (deltphi > 170. && (Eg1 > 0.25 && Eg2 > 0.25)) nb2bcc_PhiHigh++;
209 if (deltphi > 170. && (Eg1 < 0.25 || Eg2 < 0.25)) nb2bcc_PhiLow++;
210 if (deltphi > 160. && (Tsum > 160. && Tsum < 200.)) nb2bcc_3D++;
211 }
212 }
213
214 calculationResult["nB2BCCPhiHighLE"] = nb2bcc_PhiHigh;
215 calculationResult["nB2BCCPhiLowLE"] = nb2bcc_PhiLow;
216 calculationResult["nB2BCC3DLE"] = nb2bcc_3D;
217
218
219 // AngleGTLE
220 double angleGTLE = -10.;
221 if (gammaWithMaximumRho) {
222 const ROOT::Math::XYZVector& V3g1 = gammaWithMaximumRho->getMomentum();
223 if (trackWithMaximumRho) {
224 const ROOT::Math::XYZVector& V3p1 = trackWithMaximumRho->getMomentum();
225 const double theta1 = ROOT::Math::VectorUtil::Angle(V3g1, V3p1);
226 if (angleGTLE < theta1) angleGTLE = theta1;
227 }
228 if (trackWithSecondMaximumRho) {
229 const ROOT::Math::XYZVector& V3p2 = trackWithSecondMaximumRho->getMomentum();
230 const double theta2 = ROOT::Math::VectorUtil::Angle(V3g1, V3p2);
231 if (angleGTLE < theta2) angleGTLE = theta2;
232 }
233 }
234
235 calculationResult["AngleGTLE"] = angleGTLE;
236
237 // AngleG1G2LE
238 double angleG1G2CMSLE = -10.;
239 if (gammaWithMaximumRho) {
240 const ROOT::Math::PxPyPzEVector& V4p1 = PCmsLabTransform::labToCms(gammaWithMaximumRho->get4Vector());
241 if (gammaWithSecondMaximumRho) {
242 const ROOT::Math::PxPyPzEVector& V4p2 = PCmsLabTransform::labToCms(gammaWithSecondMaximumRho->get4Vector());
243 angleG1G2CMSLE = ROOT::Math::VectorUtil::Angle(V4p1, V4p2);
244 }
245 }
246
247 calculationResult["AngleG1G2CMSLE"] = angleG1G2CMSLE;
248
249 // maxAngleTTLE
250 double maxAngleTTLE = -10.;
251 int nJpsi = 0;
252 double Jpsi = 0.;
253 const double jPsiMasswindow = 0.11;
254 if (m_pionParticles->getListSize() >= 2) {
255 for (unsigned int i = 0; i < m_pionParticles->getListSize() - 1; i++) {
256 Particle* par1 = m_pionParticles->getParticle(i);
257 for (unsigned int j = i + 1; j < m_pionParticles->getListSize(); j++) {
258 Particle* par2 = m_pionParticles->getParticle(j);
259 ROOT::Math::PxPyPzEVector V4p1 = par1->get4Vector();
260 ROOT::Math::PxPyPzEVector V4p2 = par2->get4Vector();
261 ROOT::Math::PxPyPzEVector V4pSum = V4p1 + V4p2;
262 const auto chSum = par1->getCharge() + par2->getCharge();
263 const double mSum = V4pSum.M();
264 const double JpsidM = mSum - TDatabasePDG::Instance()->GetParticle(443)->Mass();
265 if (std::abs(JpsidM) < jPsiMasswindow && chSum == 0) nJpsi++;
266 const ROOT::Math::PxPyPzEVector V4p1CMS = PCmsLabTransform::labToCms(V4p1);
267 const ROOT::Math::PxPyPzEVector V4p2CMS = PCmsLabTransform::labToCms(V4p2);
268 const double temp = ROOT::Math::VectorUtil::Angle(V4p1CMS, V4p2CMS);
269 if (maxAngleTTLE < temp) maxAngleTTLE = temp;
270 }
271 }
272 }
273
274 if (nJpsi != 0) Jpsi = 1;
275
276 calculationResult["maxAngleTTLE"] = maxAngleTTLE;
277 calculationResult["Jpsi"] = Jpsi;
278
279 //maxAngleGGLE
280 double maxAngleGGLE = -10.;
281 if (m_gammaParticles->getListSize() >= 2) {
282 for (unsigned int i = 0; i < m_gammaParticles->getListSize() - 1; i++) {
283 Particle* par1 = m_gammaParticles->getParticle(i);
284 for (unsigned int j = i + 1; j < m_gammaParticles->getListSize(); j++) {
285 Particle* par2 = m_gammaParticles->getParticle(j);
286 ROOT::Math::PxPyPzEVector V4p1 = PCmsLabTransform::labToCms(par1->get4Vector());
287 ROOT::Math::PxPyPzEVector V4p2 = PCmsLabTransform::labToCms(par2->get4Vector());
288 const double temp = ROOT::Math::VectorUtil::Angle(V4p1, V4p2);
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 information
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 && (std::abs(charget1) == 1 && std::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 double Thetag1 = V4g1.Theta() * TMath::RadToDeg();
412 double Thetag2 = V4g2.Theta() * TMath::RadToDeg();
413 double deltphi = std::abs(ROOT::Math::VectorUtil::DeltaPhi(V4g1, V4g2) * TMath::RadToDeg());
414 double Tsum = Thetag1 + Thetag2;
415 if ((deltphi > 165. && deltphi < 178.5) && (Eg1ob > 0.4 && Eg2ob > 0.4 && (Eg1ob > 0.45 || Eg2ob > 0.45)) && (Tsum > 178.
416 && Tsum < 182.)) BhabhaECL = 1;
417 }
418 }
419 calculationResult["BhabhaECL"] = BhabhaECL;
420
421 // Radiative Bhabha skim (radee) for CDC dE/dx calib studies
422 double radee = 0.;
423 const double lowdEdxEdge = 0.70, highdEdxEdge = 1.30;
424 const double lowEoPEdge = 0.70, highEoPEdge = 1.30;
425
426 if (m_pionParticles->getListSize() == 2) {
427
428 //------------First track variables----------------
429 for (unsigned int i = 0; i < m_pionParticles->getListSize() - 1; i++) {
430
431 Particle* part1 = m_pionParticles->getParticle(i);
432 if (!part1) continue;
433
434 const auto chargep1 = part1->getCharge();
435 if (std::abs(chargep1) != 1) continue;
436
437 const ECLCluster* eclTrack1 = part1->getECLCluster();
438 if (!eclTrack1) continue;
439 if (!eclTrack1->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons)) continue;
440
441 const double& momentum1 = part1->getMomentumMagnitude();
442 const double& energyOverMomentum1 = eclTrack1->getEnergy(ECLCluster::EHypothesisBit::c_nPhotons) / momentum1;
443 if (energyOverMomentum1 <= lowEoPEdge || energyOverMomentum1 >= highEoPEdge) continue;
444
445 const Track* track1 = part1->getTrack();
446 if (!track1) continue;
447
448 const TrackFitResult* trackFit1 = track1->getTrackFitResultWithClosestMass(Const::pion);
449 if (!trackFit1) continue;
450 if (trackFit1->getHitPatternCDC().getNHits() <= 0) continue;
451
452 const CDCDedxTrack* dedxTrack1 = track1->getRelatedTo<CDCDedxTrack>();
453 if (!dedxTrack1) continue;
454
455 //------------Second track variables----------------
456 for (unsigned int j = i + 1; j < m_pionParticles->getListSize(); j++) {
457
458 Particle* part2 = m_pionParticles->getParticle(j);
459 if (!part2) continue;
460
461 const auto chargep2 = part2->getCharge();
462 if (std::abs(chargep2) != 1 || (chargep1 + chargep2 != 0)) continue;
463
464 const ECLCluster* eclTrack2 = part2->getECLCluster();
465 if (!eclTrack2) continue;
466 if (!eclTrack2->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons)) continue;
467
468 const double& momentum2 = part2->getMomentumMagnitude();
469 const double& energyOverMomentum2 = eclTrack2->getEnergy(ECLCluster::EHypothesisBit::c_nPhotons) / momentum2;
470 if (energyOverMomentum2 <= lowEoPEdge || energyOverMomentum2 >= highEoPEdge) continue;
471
472 const Track* track2 = part2->getTrack();
473 if (!track2) continue;
474
475 const TrackFitResult* trackFit2 = track2->getTrackFitResultWithClosestMass(Const::pion);
476 if (!trackFit2) continue;
477 if (trackFit2->getHitPatternCDC().getNHits() <= 0) continue;
478
479 CDCDedxTrack* dedxTrack2 = track2->getRelatedTo<CDCDedxTrack>();
480 if (!dedxTrack2) continue;
481
482 double p1_dedxnosat = dedxTrack1->getDedxNoSat();
483 double p2_dedxnosat = dedxTrack2->getDedxNoSat();
484
485 if ((p1_dedxnosat > lowdEdxEdge && p1_dedxnosat < highdEdxEdge) || (p2_dedxnosat > lowdEdxEdge
486 && p2_dedxnosat < highdEdxEdge)) radee = 1;
487
488 }
489 }
490 }
491
492 calculationResult["Radee"] = radee;
493
494 // Dimuon skim (mumutight) taken from the offline skim + Radiative dimuon (radmumu)
495 double mumutight = 0.;
496 double eMumuTotGammas = 0.;
497 int nTracks = 0;
498 double radmumu = 0.;
499 int nGammas = m_gammaParticles->getListSize();
500
501 for (int t = 0; t < nGammas; t++) {
502 const Particle* part = m_gammaParticles->getParticle(t);
503 const auto& frame = ReferenceFrame::GetCurrent();
504 eMumuTotGammas += frame.getMomentum(part).E();
505 }
506
507 StoreArray<Track> tracks;
508 nTracks = tracks.getEntries();
509 PCmsLabTransform T;
510 const ROOT::Math::PxPyPzEVector pIN = T.getBeamFourMomentum();
511 const auto& fr = ReferenceFrame::GetCurrent();
512
513 if (m_pionParticles->getListSize() == 2) {
514
515 //------------First track variables----------------
516 for (unsigned int k = 0; k < m_pionParticles->getListSize() - 1; k++) {
517
518 Particle* part1 = m_pionParticles->getParticle(k);
519 if (!part1) continue;
520
521 const auto chargep1 = part1->getCharge();
522 if (std::abs(chargep1) != 1) continue;
523
524 const ECLCluster* eclTrack1 = part1->getECLCluster();
525 if (!eclTrack1) continue;
526 if (!eclTrack1->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons)) continue;
527
528 const Track* track1 = part1->getTrack();
529 if (!track1) continue;
530
531 const TrackFitResult* trackFit1 = track1->getTrackFitResultWithClosestMass(Const::pion);
532 if (!trackFit1) continue;
533
534 const ROOT::Math::PxPyPzEVector V4p1 = trackFit1->get4Momentum();
535 const ROOT::Math::PxPyPzEVector V4p1CMS = PCmsLabTransform::labToCms(V4p1);
536
537 const double p1MomLab = V4p1.P();
538 double highestP = p1MomLab;
539 const double p1CDChits = trackFit1->getHitPatternCDC().getNHits();
540 const PIDLikelihood* p1Pid = part1->getPIDLikelihood();
541 bool p1hasKLMid = 0;
542 if (p1Pid) p1hasKLMid = p1Pid->isAvailable(Const::KLM);
543 const double p1isInCDC = Variable::inCDCAcceptance(part1);
544 const double p1clusPhi = Variable::eclClusterPhi(part1);
545
546 const double Pp1 = V4p1CMS.R();
547 const double Thetap1 = V4p1CMS.Theta() * TMath::RadToDeg();
548 const double Phip1 = V4p1CMS.Phi() * TMath::RadToDeg();
549
550 const double enECLTrack1 = eclTrack1->getEnergy(ECLCluster::EHypothesisBit::c_nPhotons);
551
552 const bool goodTrk1 = enECLTrack1 > 0 && enECLTrack1 < 0.5 && p1CDChits > 0
553 && ((p1hasKLMid == 0 && enECLTrack1 < 0.25 && p1MomLab < 2.0) || p1hasKLMid == 1) && p1isInCDC == 1;
554
555 //------------Second track variables----------------
556 for (unsigned int l = k + 1; l < m_pionParticles->getListSize(); l++) {
557
558 Particle* part2 = m_pionParticles->getParticle(l);
559 if (!part2) continue;
560
561 const auto chargep2 = part2->getCharge();
562 if (std::abs(chargep2) != 1 || (chargep1 + chargep2 != 0)) continue;
563
564 const ECLCluster* eclTrack2 = part2->getECLCluster();
565 if (!eclTrack2) continue;
566 if (!eclTrack2->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons)) continue;
567
568 const Track* track2 = part2->getTrack();
569 if (!track2) continue;
570
571 const TrackFitResult* trackFit2 = track2->getTrackFitResultWithClosestMass(Const::pion);
572 if (!trackFit2) continue;
573
574 const ROOT::Math::PxPyPzEVector V4p2 = trackFit2->get4Momentum();
575 const ROOT::Math::PxPyPzEVector V4p2CMS = PCmsLabTransform::labToCms(V4p2);
576
577 const double p2MomLab = V4p2.P();
578 double lowestP = p2MomLab;
579 const double p2CDChits = trackFit2->getHitPatternCDC().getNHits();
580 const PIDLikelihood* p2Pid = part2->getPIDLikelihood();
581 bool p2hasKLMid = 0;
582 if (p2Pid) p2hasKLMid = p2Pid->isAvailable(Const::KLM);
583 const double p2isInCDC = Variable::inCDCAcceptance(part2);
584 const double p2clusPhi = Variable::eclClusterPhi(part2);
585
586 const double Pp2 = V4p2CMS.R();
587 const double Thetap2 = V4p2CMS.Theta() * TMath::RadToDeg();
588 const double Phip2 = V4p2CMS.Phi() * TMath::RadToDeg();
589
590 const double acopPhi = std::abs(180 - std::abs(Phip1 - Phip2));
591 const double acopTheta = std::abs(std::abs(Thetap1 + Thetap2) - 180);
592
593 const double enECLTrack2 = eclTrack2->getEnergy(ECLCluster::EHypothesisBit::c_nPhotons);
594
595 const bool goodTrk2 = enECLTrack2 > 0 && enECLTrack2 < 0.5 && p2CDChits > 0
596 && ((p2hasKLMid == 0 && enECLTrack2 < 0.25 && p2MomLab < 2.0) || p2hasKLMid == 1) && p2isInCDC == 1;
597
598 double eTotMumuTracks = enECLTrack1 + enECLTrack2;
599 double EMumutot = eTotMumuTracks + eMumuTotGammas;
600
601 bool mumutight_tag = enECLTrack1 < 0.5 && enECLTrack2 < 0.5 && EMumutot < 2 && acopPhi < 10 && acopTheta < 10 && nTracks == 2
602 && Pp1 > 0.5 && Pp2 > 0.5;
603
604 if (mumutight_tag) mumutight = 1;
605
606 if (p1MomLab < p2MomLab) {
607 lowestP = highestP;
608 highestP = p2MomLab;
609 }
610
611 double diffPhi = p1clusPhi - p2clusPhi;
612 if (std::abs(diffPhi) > M_PI) {
613 if (diffPhi > M_PI) {
614 diffPhi = diffPhi - 2 * M_PI;
615 } else {
616 diffPhi = 2 * M_PI + diffPhi;
617 }
618 }
619
620 const double recoilP = fr.getMomentum(pIN - V4p1 - V4p2).P();
621
622 const bool radmumu_tag = nTracks < 4 && goodTrk1 == 1 && goodTrk2 == 1 && highestP > 1 && lowestP < 3
623 && (p1hasKLMid == 1 || p2hasKLMid == 1) && std::abs(diffPhi) >= 0.5 * M_PI && recoilP > 0.1
624 && (enECLTrack1 <= 0.25 || enECLTrack2 <= 0.25);
625
626 if (radmumu_tag) radmumu = 1;
627
628 }
629 }
630 }
631
632 calculationResult["MumuTight"] = mumutight;
633 calculationResult["Radmumu"] = radmumu;
634
635 //Retrieve variables for HadronB skims
636 double EsumPiHad = 0;
637 double PzPiHad = 0;
638 int nHadTracks = m_pionHadParticles->getListSize();
639 double hadronb = 0;
640 double hadronb1 = 0;
641 double hadronb2 = 0;
642 std::vector<ROOT::Math::PxPyPzEVector> m_pionHad;
643
644 for (int nPiHad = 0; nPiHad < nHadTracks; nPiHad++) {
645 Particle* parPiHad = m_pionHadParticles->getParticle(nPiHad);
646 ROOT::Math::PxPyPzEVector V4PiHad = PCmsLabTransform::labToCms(parPiHad->get4Vector());
647 m_pionHad.push_back(V4PiHad);
648 EsumPiHad += V4PiHad.E();
649 PzPiHad += V4PiHad.Pz();
650 }
651
652 double visibleEnergyCMSnorm = (EsumPiHad + EsumGamma) / (BeamEnergyCMS() * 2.0);
653 double EsumCMSnorm = eneclClusters / (BeamEnergyCMS() * 2.0);
654 double PzTotCMSnorm = (PzPiHad + PzGamma) / (BeamEnergyCMS() * 2.0);
655
656 bool hadronb_tag = nHadTracks >= 3 && visibleEnergyCMSnorm > 0.2 && std::abs(PzTotCMSnorm) < 0.5 && neclClusters > 1
657 && EsumCMSnorm > 0.1 && EsumCMSnorm < 0.8;
658
659 if (hadronb_tag) {
660 hadronb = 1;
661 FoxWolfram fw(m_pionHad);
662 fw.calculateBasicMoments();
663 double R2 = fw.getR(2);
664 if (R2 < 0.4) hadronb1 = 1;
665 if (hadronb1 && nHadTracks >= 5) hadronb2 = 1;
666 }
667
668 calculationResult["HadronB"] = hadronb;
669 calculationResult["HadronB1"] = hadronb1;
670 calculationResult["HadronB2"] = hadronb2;
671
672 // nKshort
673 int nKshort = 0;
674 double Kshort = 0.;
675 const double KsMassLow = 0.468;
676 const double KsMassHigh = 0.528;
677
678 if (m_KsParticles.isValid()) {
679 for (unsigned int i = 0; i < m_KsParticles->getListSize(); i++) {
680 const Particle* mergeKsCand = m_KsParticles->getParticle(i);
681 const double isKsCandGood = Variable::goodBelleKshort(mergeKsCand);
682 const double KsCandMass = mergeKsCand->getMass();
683 if (KsCandMass > KsMassLow && KsCandMass < KsMassHigh && isKsCandGood == 1.) nKshort++;
684 }
685 }
686
687 if (nKshort != 0) Kshort = 1;
688
689 calculationResult["Kshort"] = Kshort;
690
691 // 4 leptons skim
692 int nFourLep = 0;
693 double fourLep = 0.;
694
695 const double visibleEnergyCMS = visibleEnergyCMSnorm * BeamEnergyCMS() * 2.0;
696 const unsigned int n_particles = m_pionHadParticles->getListSize();
697
698 if (n_particles >= 2) {
699 for (unsigned int i = 0; i < n_particles - 1; i++) {
700 Particle* par1 = m_pionHadParticles->getParticle(i);
701 for (unsigned int j = i + 1; j < n_particles; j++) {
702 Particle* par2 = m_pionHadParticles->getParticle(j);
703 const auto chSum = par1->getCharge() + par2->getCharge();
704 const ROOT::Math::PxPyPzEVector V4p1 = par1->get4Vector();
705 const ROOT::Math::PxPyPzEVector V4p2 = par2->get4Vector();
706 const double opAng = V4p1.Theta() + V4p2.Theta();
707 const ROOT::Math::PxPyPzEVector V4pSum = V4p1 + V4p2;
708 const ROOT::Math::PxPyPzEVector V4pSumCMS = PCmsLabTransform::labToCms(V4pSum);
709 const double ptCMS = V4pSumCMS.Pt();
710 const double pzCMS = V4pSumCMS.Pz();
711 const double mSum = V4pSum.M();
712
713 const bool fourLepCand = chSum == 0 && (V4p1.P() > 0.4 && V4p2.P() > 0.4) && cos(opAng) > -0.997 && ptCMS < 0.15
714 && std::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 (std::abs(diffPhi) > 180) {
848 if (diffPhi > 180) {
849 diffPhi = diffPhi - 2 * 180;
850 } else {
851 diffPhi = 2 * 180 + diffPhi;
852 }
853 }
854 const double delThetaCMS = std::abs(std::abs(thetaSumCMS) - 180);
855 const double delPhiCMS = std::abs(180 - std::abs(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::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:107
Belle2::ClusterUtils
Class to provide momentum-related information from ECLClusters.
Definition: ClusterUtils.h:38
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:661
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:351
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:29
Belle2::PCmsLabTransform::getBeamFourMomentum
ROOT::Math::PxPyPzEVector getBeamFourMomentum() const
Returns LAB four-momentum of e+e-, i.e.
Definition: PCmsLabTransform.h:57
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:29
Belle2::PIDLikelihood::isAvailable
bool isAvailable(Const::PIDDetectorSet set=Const::PIDDetectorSet::set()) const
Check whether PID information is available for at least one of the detectors in a given set.
Definition: PIDLikelihood.cc:67
Belle2::Particle
Class to store reconstructed particles.
Definition: Particle.h:76
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:916
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:976
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:947
Belle2::Particle::getCharge
double getCharge(void) const
Returns particle charge.
Definition: Particle.cc:653
Belle2::Particle::get4Vector
ROOT::Math::PxPyPzEVector get4Vector() const
Returns Lorentz vector.
Definition: Particle.h:567
Belle2::Particle::getMomentum
ROOT::Math::XYZVector getMomentum() const
Returns momentum vector.
Definition: Particle.h:580
Belle2::Particle::getMomentumMagnitude
double getMomentumMagnitude() const
Returns momentum magnitude.
Definition: Particle.h:589
Belle2::Particle::getP
double getP() const
Returns momentum magnitude (same as getMomentumMagnitude but with shorter name)
Definition: Particle.h:598
Belle2::Particle::getDaughter
const Particle * getDaughter(unsigned i) const
Returns a pointer to the i-th daughter particle.
Definition: Particle.cc:662
Belle2::Particle::getExtraInfo
double getExtraInfo(const std::string &name) const
Return given value if set.
Definition: Particle.cc:1374
Belle2::Particle::getMass
double getMass() const
Returns invariant mass (= nominal for FS particles)
Definition: Particle.h:527
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:55
Belle2::SoftwareTrigger::SkimSampleCalculator::doCalculation
void doCalculation(SoftwareTriggerObject &calculationResult) override
Actually write out the variables into the map.
Definition: SkimSampleCalculator.cc:70
Belle2::SoftwareTrigger::SkimSampleCalculator::SkimSampleCalculator
SkimSampleCalculator()
Set the default names for the store object particle lists.
Definition: SkimSampleCalculator.cc:46
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 whether 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