Belle II Software development
Public Member Functions | Private Attributes | List of all members
SkimSampleCalculator Class Reference

Implementation of a calculator used in the SoftwareTriggerModule to fill a SoftwareTriggerObject for selecting particles for skimming and data quality monitoring. More...

#include <SkimSampleCalculator.h>

Inheritance diagram for SkimSampleCalculator:
SoftwareTriggerCalculation

Public Member Functions

 SkimSampleCalculator ()
 Set the default names for the store object particle lists.
 
void requireStoreArrays () override
 Require the particle list. We do not need more here.
 
void doCalculation (SoftwareTriggerObject &calculationResult) override
 Actually write out the variables into the map.
 
void writeDebugOutput (const std::unique_ptr< TTree > &debugOutputTTree)
 Function to write out debug output into the given TTree.
 
void addDebugOutput (const StoreObjPtr< SoftwareTriggerVariables > &storeObject, const std::string &prefix)
 Function to write out debug output into the given StoreObject.
 
const SoftwareTriggerObject & fillInCalculations ()
 Main function of this class: calculate the needed variables using the overwritten doCalculation function and write out the values into the results object (with their names).
 

Private Attributes

StoreObjPtr< ParticleList > m_pionParticles
 Internal storage of the tracks as particles.
 
StoreObjPtr< ParticleList > m_gammaParticles
 Internal storage of the ECL clusters as particles.
 
StoreObjPtr< ParticleList > m_pionHadParticles
 Internal storage of the tracks as particles (definition for hadronb).
 
StoreObjPtr< ParticleList > m_pionTauParticles
 Internal storage of the tracks as particles (definition for tau skims).
 
StoreObjPtr< ParticleList > m_KsParticles
 Internal storage of the K_S0's.
 
StoreObjPtr< ParticleList > m_LambdaParticles
 Internal storage of the Lambda0's.
 
StoreObjPtr< ParticleList > m_DstParticles
 Internal storage of the D*'s.
 
StoreObjPtr< ParticleList > m_offIpParticles
 Internal storage of the tracks for alignment calibration.
 
std::string m_filterL1TrgNN = ""
 HLT filter line for the TRG skim.
 
StoreObjPtr< ParticleList > m_BpParticles
 Internal storage of the B+'s.
 
StoreObjPtr< ParticleList > m_BzParticles
 Internal storage of the B0's.
 
SoftwareTriggerObject m_calculationResult
 Internal storage of the result of the calculation.
 
bool m_debugPrepared = false
 Flag to not add the branches twice to the TTree.
 

Detailed Description

Implementation of a calculator used in the SoftwareTriggerModule to fill a SoftwareTriggerObject for selecting particles for skimming and data quality monitoring.

This class implements the two main functions requireStoreArrays and doCalculation of the SoftwareTriggerCalculation class.

Definition at line 28 of file SkimSampleCalculator.h.

Constructor & Destructor Documentation

◆ SkimSampleCalculator()

SkimSampleCalculator ( )

Set the default names for the store object particle lists.

Definition at line 46 of file SkimSampleCalculator.cc.

46 :
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}
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::m_KsParticles
StoreObjPtr< ParticleList > m_KsParticles
Internal storage of the K_S0's.
Definition SkimSampleCalculator.h:49
Belle2::SoftwareTrigger::SkimSampleCalculator::m_filterL1TrgNN
std::string m_filterL1TrgNN
HLT filter line for the TRG skim.
Definition SkimSampleCalculator.h:57
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

Member Function Documentation

◆ addDebugOutput()

void addDebugOutput ( const StoreObjPtr< SoftwareTriggerVariables > & storeObject,
const std::string & prefix )
inherited

Function to write out debug output into the given StoreObject.

Needs an already prefilled calculationResult for this (probably using the fillInCalculations function). All added variables are prefixed with the given prefix string.

Definition at line 34 of file SoftwareTriggerCalculation.cc.

35 {
36 for (auto& identifierWithValue : m_calculationResult) {
37 const std::string& identifier = identifierWithValue.first;
38 const double value = identifierWithValue.second;
39
40 storeObject->append(prefix + "_" + identifier, value);
41 }
42 }

◆ doCalculation()

void doCalculation ( SoftwareTriggerObject & calculationResult)
overridevirtual

Actually write out the variables into the map.

Implements SoftwareTriggerCalculation.

Definition at line 70 of file SkimSampleCalculator.cc.

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::getDedxNoSat
double getDedxNoSat() const
Get dE/dx truncated mean without the saturation correction for this track.
Definition CDCDedxTrack.h:107
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::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)
Definition ECLCluster.h:41
Belle2::HitPatternCDC::getNHits
unsigned short getNHits() const
Get the total Number of CDC hits in the fit.
Definition HitPatternCDC.cc:47
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::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::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::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::isValid
bool isValid() const
Check whether the object was created.
Definition StoreObjPtr.h:111
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::SoftwareTriggerCutResult::c_accept
@ c_accept
Accept this event.
Definition SoftwareTriggerResult.h:23

◆ fillInCalculations()

const SoftwareTriggerObject & fillInCalculations ( )
inherited

Main function of this class: calculate the needed variables using the overwritten doCalculation function and write out the values into the results object (with their names).

Please make sure to override (or clear) the variables! Otherwise it can happen that their old values are still in the object.

What variables exactly are added to the result depends on the implementation details of the class.

Definition at line 44 of file SoftwareTriggerCalculation.cc.

45 {
46 const unsigned int sizeBeforeCheck = m_calculationResult.size();
47 doCalculation(m_calculationResult);
48
49 if (m_calculationResult.size() != sizeBeforeCheck and sizeBeforeCheck > 0) {
50 B2WARNING("Calculator added more variables (" << m_calculationResult.size() <<
51 ") than there were before (" << sizeBeforeCheck << "). Probably something strange is going on!");
52 }
53
54 return m_calculationResult;
55 }

◆ requireStoreArrays()

void requireStoreArrays ( )
overridevirtual

Require the particle list. We do not need more here.

Implements SoftwareTriggerCalculation.

Definition at line 55 of file SkimSampleCalculator.cc.

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};

◆ writeDebugOutput()

void writeDebugOutput ( const std::unique_ptr< TTree > & debugOutputTTree)
inherited

Function to write out debug output into the given TTree.

Needs an already prefilled calculationResult for this (probably using the fillInCalculations function).

Definition at line 19 of file SoftwareTriggerCalculation.cc.

20 {
21 if (not m_debugPrepared) {
22 for (auto& identifierWithValue : m_calculationResult) {
23 const std::string& identifier = identifierWithValue.first;
24 double& value = identifierWithValue.second;
25
26 debugOutputTTree->Branch(identifier.c_str(), &value);
27 }
28 m_debugPrepared = true;
29 }
30
31 debugOutputTTree->Fill();
32 }

Member Data Documentation

◆ m_BpParticles

StoreObjPtr<ParticleList> m_BpParticles
private

Internal storage of the B+'s.

Definition at line 59 of file SkimSampleCalculator.h.

◆ m_BzParticles

StoreObjPtr<ParticleList> m_BzParticles
private

Internal storage of the B0's.

Definition at line 61 of file SkimSampleCalculator.h.

◆ m_calculationResult

SoftwareTriggerObject m_calculationResult
privateinherited

Internal storage of the result of the calculation.

Definition at line 74 of file SoftwareTriggerCalculation.h.

◆ m_debugPrepared

bool m_debugPrepared = false
privateinherited

Flag to not add the branches twice to the TTree.

Definition at line 76 of file SoftwareTriggerCalculation.h.

◆ m_DstParticles

StoreObjPtr<ParticleList> m_DstParticles
private

Internal storage of the D*'s.

Definition at line 53 of file SkimSampleCalculator.h.

◆ m_filterL1TrgNN

std::string m_filterL1TrgNN = ""
private

HLT filter line for the TRG skim.

Definition at line 57 of file SkimSampleCalculator.h.

◆ m_gammaParticles

StoreObjPtr<ParticleList> m_gammaParticles
private

Internal storage of the ECL clusters as particles.

Definition at line 43 of file SkimSampleCalculator.h.

◆ m_KsParticles

StoreObjPtr<ParticleList> m_KsParticles
private

Internal storage of the K_S0's.

Definition at line 49 of file SkimSampleCalculator.h.

◆ m_LambdaParticles

StoreObjPtr<ParticleList> m_LambdaParticles
private

Internal storage of the Lambda0's.

Definition at line 51 of file SkimSampleCalculator.h.

◆ m_offIpParticles

StoreObjPtr<ParticleList> m_offIpParticles
private

Internal storage of the tracks for alignment calibration.

Definition at line 55 of file SkimSampleCalculator.h.

◆ m_pionHadParticles

StoreObjPtr<ParticleList> m_pionHadParticles
private

Internal storage of the tracks as particles (definition for hadronb).

Definition at line 45 of file SkimSampleCalculator.h.

◆ m_pionParticles

StoreObjPtr<ParticleList> m_pionParticles
private

Internal storage of the tracks as particles.

Definition at line 41 of file SkimSampleCalculator.h.

◆ m_pionTauParticles

StoreObjPtr<ParticleList> m_pionTauParticles
private

Internal storage of the tracks as particles (definition for tau skims).

Definition at line 47 of file SkimSampleCalculator.h.

The documentation for this class was generated from the following files: