hpstr
The Heavy Photon Search Toolkit for Reconstruction (hpstr) provides an interface to physics data from the HPS experiment saved in the LCIO format and converts it into an ROOT based format.
Loading...
Searching...
No Matches
PreselectAndCategorize2021.cxx
Go to the documentation of this file.
1/*
2 * @file PreselectAndCategorize2021.cxx
3 * @author Sarah Gaiser adapting Tom Eichlersmith's PreselectAndCategorize
4 * @date Apr 2025
5 */
6
8
10 // Track corrections (z0 offsets / calibration, data scale corrections, MC smearing) are
11 // configured by one JSON for TrackCorrector; the per-job settings stay parameters here.
12 trackCorrectionsCfg_ = parameters.getString("trackCorrectionsCfg", "");
13 smearingSeed_ = parameters.getInteger("smearingSeed", smearingSeed_);
14 doSmearing_ = parameters.getInteger("doSmearing", 0) != 0;
15 // These settings moved into the trackCorrectionsCfg JSON; refuse them rather than ignore them.
16 for (const char* moved : {"smearingCfg", "pSmearingFile", "trackBiasCfg", "z0CalibCfg", "z0CalibMcCfg"}) {
17 if (!parameters.getString(moved, "").empty())
18 throw std::runtime_error(std::string("PreselectAndCategorize2021: parameter '") + moved +
19 "' moved to the trackCorrectionsCfg JSON");
20 }
21
22 // Debug output flag
23 debug_ = parameters.getInteger("debug", 0) != 0;
24
25 // Disable all vertex-level preselection cuts (default: cuts enabled)
26 disablePreselection_ = parameters.getInteger("disablePreselection", 0) != 0;
27 disableTimingCuts_ = parameters.getInteger("disableTimingCuts", 0) != 0;
28 disableVertexChi2Cut_ = parameters.getInteger("disableVertexChi2Cut", 0) != 0;
29
30 // If true (default), veto events with >=2 preselected vertices. If false, keep the event
31 // and select the preselected vertex with the lowest vertex chi2 instead of vetoing.
32 requireSingleVertex_ = parameters.getInteger("requireSingleVertex", 1) != 0;
33
34 // Momentum source for the e+/e- used in psum and the per-track momentum cuts: vertex-fitted
35 // (default) or standalone track-fit. Defaults to true to preserve prior behavior.
36 useVertexMomentum_ = parameters.getInteger("useVertexMomentum", 1) != 0;
37
38 // Minimum number of 2D tracker hits required per track (default 10). The electron and
39 // positron can be controlled independently via eleMinHits/posMinHits; each defaults to
40 // minHits when not set explicitly.
41 minHits_ = parameters.getInteger("minHits", minHits_);
42 eleMinHits_ = parameters.getInteger("eleMinHits", minHits_);
43 posMinHits_ = parameters.getInteger("posMinHits", minHits_);
44
45 // Which trigger to require: "singles2" (default: singles2||singles3) or "pairs"
46 triggerSelection_ = parameters.getString("triggerSelection", triggerSelection_);
47
48 // Optional minimum psum cut; disabled (default) when < 0
49 psumCut_ = parameters.getDouble("psumCut", psumCut_);
50
51 // Beam parameters used to infer the recoil-electron direction
52 beamE_ = parameters.getDouble("beamE", beamE_);
53 thetaBeamMrad_ = parameters.getDouble("thetaBeamMrad", thetaBeamMrad_);
54
55 // Require truth match for smearing: -1 (default) uses the trackCorrectionsCfg value
56 requireTruthMatch_ = parameters.getInteger("requireTruthMatch", -1);
57
58 // Save all tracks in the event
59 saveAllTracks_ = parameters.getInteger("saveAllTracks", 0) != 0;
60 // Calculate variables that depend on multiple tracks
61 calcMultiTrackVars_ = parameters.getInteger("calcMultiTrackVars", 0) != 0;
62 // Hit requirement for the extra tracks; < 0 = eleMinHits/posMinHits
63 extraTrackMinHits_ = parameters.getInteger("extraTrackMinHits", extraTrackMinHits_);
64
65
66
67 auto beamPosCfg = parameters.getString("beamPosCfg");
68 if (not beamPosCfg.empty()) {
69 std::cout << "Loading beamspot corrections from " << beamPosCfg << std::endl;
70 auto beamspot_corrections_json = preselect_json_load(beamPosCfg);
71 for (const auto& [run, entry] : beamspot_corrections_json.items()) {
72 beamspot_corrections_[std::stoi(run)] = {entry["beamspot_x"], entry["beamspot_y"], entry["beamspot_z"]};
73 }
74 }
75
76 auto v0ProjectionFitsCfg = parameters.getString("v0ProjectionFitsCfg");
77 if (not v0ProjectionFitsCfg.empty()) {
78 std::cout << "Loading projection fits from " << v0ProjectionFitsCfg << std::endl;
79 v0proj_fits_ = preselect_json_load(v0ProjectionFitsCfg);
80 }
81
82
83 auto vtxColl = parameters.getString("vtxCollection");
84 if (not vtxColl.empty()) {
85 std::cout << "Setting vertex collection to : " << vtxColl << std::endl;
86 setVtxColl(vtxColl);
87 }
88
89 calTimeOffset_ = parameters.getDouble("calTimeOffset");
90 isData_ = parameters.getInteger("isData") != 0;
91 isSimpSignal_ = parameters.getInteger("isSimpSignal") != 0;
92 isApSignal_ = parameters.getInteger("isApSignal") != 0;
93 if (isSimpSignal_ || isApSignal_) isSignal_ = true;
94 apPDG_ = parameters.getInteger("apPDG", 622);
95
96 if (not trackCorrectionsCfg_.empty()) {
98 opts.isData = isData_;
99 opts.seed = smearingSeed_;
100 opts.doSmearing = doSmearing_;
102 opts.debug = debug_;
103 corrector_ = std::make_shared<TrackCorrector>(trackCorrectionsCfg_, opts);
104 corrector_->printConfig();
105 }
106}
107
108std::vector<double> PreselectAndCategorize2021::determine_time_cuts(bool isData, int runNumber) {
109 std::vector<double> time_cuts;
110
111 if (isData) {
112 // Apply data-specific time cuts
113 time_cuts = {6.0, 5.1, 7.8}; // v9 values
114 } else {
115 // Apply MC-specific time cuts
116 time_cuts = {6.0, 5.7, 9.2}; // MC with track time smearing
117 //time_cuts = {18.0, 17.1, 27.6}; // MC with track time smearing
118 // time_cuts = {3.0, 3.0, 4.2}; // MC without track time smearing
119 }
120
121 return time_cuts;
122}
123
124double PreselectAndCategorize2021::calculate_theta_R(const TVector3& ele_mom, const TVector3& pos_mom) const {
125 // Beam 4-momentum (assume m_e ~ 0 for the beam)
126 double theta_beam = thetaBeamMrad_ / 1000.0; // convert to radians
127 double beam_px = beamE_ * std::sin(theta_beam);
128 double beam_py = 0.0;
129 double beam_pz = beamE_ * std::cos(theta_beam);
130
131 // Inferred recoil 3-momentum from momentum conservation
132 double recoil_px = beam_px - ele_mom.X() - pos_mom.X();
133 double recoil_py = beam_py - ele_mom.Y() - pos_mom.Y();
134 double recoil_pz = beam_pz - ele_mom.Z() - pos_mom.Z();
135
136 TVector3 recoil_mom(recoil_px, recoil_py, recoil_pz);
137 double p_recoil_mag = recoil_mom.Mag();
138 if (p_recoil_mag <= 0.0) return -9999.0;
139
140 // Beam direction (unit vector)
141 TVector3 beam_dir(std::sin(theta_beam), 0.0, std::cos(theta_beam));
142
143 // Angle between recoil and beam directions, in mrad
144 double cos_theta = recoil_mom.Dot(beam_dir) / p_recoil_mag;
145 cos_theta = std::max(-1.0, std::min(1.0, cos_theta));
146 return std::acos(cos_theta) * 1000.0;
147}
148
150
151 Track inferredTrack;
152
153 TVector3 ele_mom(ele_track->getMomentum()[0], ele_track->getMomentum()[1], ele_track->getMomentum()[2]);
154 TVector3 pos_mom(pos_track->getMomentum()[0], pos_track->getMomentum()[1], pos_track->getMomentum()[2]);
155
156 // Beam 4-momentum (assume m_e ~ 0 for the beam)
157 double theta_beam = thetaBeamMrad_ / 1000.0; // convert to radians
158 double beam_px = beamE_ * std::sin(theta_beam);
159 double beam_py = 0.0;
160 double beam_pz = beamE_ * std::cos(theta_beam);
161
162 // Inferred recoil 3-momentum from momentum conservation
163 double recoil_px = beam_px - ele_mom.X() - pos_mom.X();
164 double recoil_py = beam_py - ele_mom.Y() - pos_mom.Y();
165 double recoil_pz = beam_pz - ele_mom.Z() - pos_mom.Z();
166
167 float inferredCharge = -1; // Third track is an electron
168 float pT = std::sqrt(ele_mom.X()*ele_mom.X() + ele_mom.Z()*ele_mom.Z());
169 float cB = pT * fabs(ele_track->getOmega());
170
171
172
173 float target_pos = -1.1;
174 // Calculate track parameters
175 std::vector<float> params = TrackTools::calculateTrackParameters(
176 vtx->getX(), vtx->getY(), vtx->getZ(),
177 recoil_px, recoil_py, recoil_pz, inferredCharge, cB, target_pos);
178
179 inferredTrack.setTrackParameters(
180 params[0], // d0
181 params[1], // phi0
182 params[2], // omega
183 params[4], // tanLambda
184 params[3] // z0
185 );
186
187 TMatrixD covVertex = TrackTools::getVertexCovariance(vtx);
188
189 TMatrixD eleCovMomentum = TrackTools::momentumCovarianceFromTrack(ele_track);
190 TMatrixD posCovMomentum = TrackTools::momentumCovarianceFromTrack(pos_track);
191
192 TMatrixD covMomentum = eleCovMomentum + posCovMomentum;
193
194 // Calculate track parameter covariance
195 TMatrixD covTrackParams = TrackTools::calculateTrackCovariance(
196 vtx->getX(), vtx->getY(), vtx->getZ(),
197 recoil_px, recoil_py, recoil_pz,
198 covVertex, covMomentum,
199 inferredCharge, cB, target_pos);
200
201
202 // Order: [d0, phi0, omega, z0, tanLambda]
203 std::vector<float> covArray;
204 covArray.reserve(15);
205
206 for (int i = 0; i < 5; i++) {
207 for (int j = 0; j <= i; j++) {
208 covArray.push_back(covTrackParams(j, i));
209 }
210 }
211
212 inferredTrack.setCov(covArray);
213
214 // Set momentum
215 inferredTrack.setMomentum(recoil_px, recoil_py, recoil_pz);
216
217 return inferredTrack;
218
219}
220
221
223 // chi2/ndf <= 20
224 if (trk->getChi2Ndf() > 20.0) return false;
225
226 // n_hits: the per-charge preselection cuts by default, or an explicit override
227 int required = (extraTrackMinHits_ >= 0)
229 : (trk->getCharge() < 0 ? eleMinHits_ : posMinHits_);
230 int nhits = trk->getTrackerHitCount();
231 if (!trk->isKalmanTrack()) nhits *= 2;
232 if (nhits < required) return false;
233
234 // p >= 0.4
235 double p = trk->getP();
236 if (p < 0.4) return false;
237
238 // for electrons (charge = -1), p <= 2.9
239 if (trk->getCharge() < 0 && p > 2.9) return false;
240
241 // Timing cuts relative to preselection positron
242 double trk_time = trk->getTrackTime();
243 double pos_trk_time = pos.getTrack().getTrackTime();
244 double pos_clu_time = pos.getCluster().getTime();
245
246 if (!disableTimingCuts_) {
247 if (trk->getCharge() < 0) {
248 if (std::fabs(trk_time - pos_clu_time) > time_cuts_[0]) return false;
249 if (std::fabs(trk_time - pos_trk_time) > time_cuts_[2]) return false;
250 } else if (trk->getCharge() > 0) {
251 if (std::fabs(trk_time - pos_clu_time) > time_cuts_[1]) return false;
252 if (std::fabs(trk_time - pos_trk_time) > time_cuts_[2]) return false;
253 }
254 }
255
256 return true;
257}
258
260 const std::vector<Track*>& all_tracks,
261 Particle& ele,
262 Particle& pos)
263{
264 // Select quality tracks with good timing relative to preselection positron
265 std::vector<Track> electrons, positrons;
266 std::vector<Track> all_good_tracks;
267
268 // include the preselected electron and positron first
269 Track ele_trk = ele.getTrack();
270 Track pos_trk = pos.getTrack();
271
272 if (ele_trk.getCharge() < 0) {
273 electrons.push_back(ele_trk);
274 if (saveAllTracks_) all_good_tracks.push_back(ele_trk);
275 }
276
277 if (pos_trk.getCharge() > 0) {
278 positrons.push_back(pos_trk);
279 if (saveAllTracks_) all_good_tracks.push_back(pos_trk);
280 }
281
282 // Track which tracks from the collection we've already included
283 std::set<int> included_track_ids;
284 if (ele_trk.getID() >= 0) included_track_ids.insert(ele_trk.getID());
285 if (pos_trk.getID() >= 0) included_track_ids.insert(pos_trk.getID());
286
287 // Then check additional tracks from the collection
288 for (auto* trk : all_tracks) {
289 // Skip if this is the same track as preselected electron or positron
290 if (trk->getID() >= 0 && included_track_ids.count(trk->getID()) > 0) {
291 continue;
292 }
293
294 if (!isQualityTrack(trk, pos)) continue;
295
296 // Store a copy of the good track
297 if (saveAllTracks_) {
298 all_good_tracks.push_back(*trk);
299 }
300
301 if (trk->getCharge() < 0) {
302 electrons.push_back(*trk);
303 } else if (trk->getCharge() > 0) {
304 positrons.push_back(*trk);
305 }
306 }
307
308 // Save all good tracks if enabled
309 if (saveAllTracks_) {
310 bus_.set("all_preselected_tracks", all_good_tracks);
311 }
312
313 // Initialize extrema values
314 double min_dTanLambda = 9999.0, max_dTanLambda = -9999.0;
315 double min_opening = 9999.0, max_opening = -9999.0;
316 double min_mass = 9999.0, max_mass = -9999.0;
317 double min_asym = 9999.0, max_asym = -9999.0;
318 double min_dPhi = 9999.0, max_dPhi = -9999.0;
319
320 const double me = 0.000511;
321
322 // Loop over all e+/e- pairs
323 for (auto& ele_track : electrons) {
324 const std::vector<double>& ele_mom = ele_track.getMomentum();
325 TVector3 pe(ele_mom[0], ele_mom[1], ele_mom[2]);
326 double pe_mag = pe.Mag();
327 double ele_tanLambda = ele_track.getTanLambda();
328 double ele_phi0 = ele_track.getPhi();
329
330 for (auto& pos_track : positrons) {
331 const std::vector<double>& pos_mom = pos_track.getMomentum();
332 TVector3 pp(pos_mom[0], pos_mom[1], pos_mom[2]);
333 double pp_mag = pp.Mag();
334 double pos_tanLambda = pos_track.getTanLambda();
335 double pos_phi0 = pos_track.getPhi();
336
337 // TanLambda difference
338 double dTanLambda = std::fabs(ele_tanLambda - pos_tanLambda);
339 min_dTanLambda = std::min(min_dTanLambda, dTanLambda);
340 max_dTanLambda = std::max(max_dTanLambda, dTanLambda);
341
342 // Phi difference
343 double dPhi = std::fabs(ele_phi0 - pos_phi0);
344 min_dPhi = std::min(min_dPhi, dPhi);
345 max_dPhi = std::max(max_dPhi, dPhi);
346
347 // Opening angle
348 double cos_theta = pe.Dot(pp) / (pe_mag * pp_mag);
349 cos_theta = std::max(-1.0, std::min(1.0, cos_theta));
350 double opening_angle = std::acos(cos_theta);
351 min_opening = std::min(min_opening, opening_angle);
352 max_opening = std::max(max_opening, opening_angle);
353
354 // Invariant mass
355 double Ee = std::sqrt(pe_mag * pe_mag + me * me);
356 double Ep = std::sqrt(pp_mag * pp_mag + me * me);
357 TVector3 p_tot = pe + pp;
358 double E_tot = Ee + Ep;
359 double m2 = E_tot * E_tot - p_tot.Mag2();
360 double mass = (m2 > 0) ? std::sqrt(m2) : 0.0;
361 min_mass = std::min(min_mass, mass);
362 max_mass = std::max(max_mass, mass);
363
364 // Asymmetry
365 double asymmetry = std::fabs(pe_mag - pp_mag) / (pe_mag + pp_mag);
366 min_asym = std::min(min_asym, asymmetry);
367 max_asym = std::max(max_asym, asymmetry);
368 }
369 }
370
371 // Store results (use -9999 if no pairs found)
372 bool has_pairs = (!electrons.empty() && !positrons.empty());
373
374 bus_.set("min_dTanLambda", has_pairs ? min_dTanLambda : -9999.0);
375 bus_.set("max_dTanLambda", has_pairs ? max_dTanLambda : -9999.0);
376 bus_.set("min_opening", has_pairs ? min_opening : -9999.0);
377 bus_.set("max_opening", has_pairs ? max_opening : -9999.0);
378 bus_.set("min_mass", has_pairs ? min_mass : -9999.0);
379 bus_.set("max_mass", has_pairs ? max_mass : -9999.0);
380 bus_.set("min_asym", has_pairs ? min_asym : -9999.0);
381 bus_.set("max_asym", has_pairs ? max_asym : -9999.0);
382 bus_.set("min_dPhi", has_pairs ? min_dPhi : -9999.0);
383 bus_.set("max_dPhi", has_pairs ? max_dPhi : -9999.0);
384}
385
387 _ah = std::make_shared<AnaHelpers>();
388
389 // init Reading Tree
390 bus_.board_input<EventHeader>(tree, "EventHeader");
391 bus_.board_input<TSData>(tree, "TSBank");
392 if (not trkColl_.empty()) bus_.board_input<std::vector<Track*>>(tree, trkColl_);
393 // if (not hitColl_.empty()) bus_.board_input<std::vector<TrackerHit*>>(tree, hitColl_);
394 bus_.board_input<std::vector<Vertex*>>(tree, vtxColl_);
395 bus_.board_input<std::vector<CalCluster*>>(tree, "RecoEcalClusters");
396 if (not isData_ and not mcColl_.empty()) bus_.board_input<std::vector<MCParticle*>>(tree, mcColl_);
397
398 /* pre-selection on vertices */
399 // vertex_cf_.add("single_trigger", 2, -0.5, 1.5);
401 // NOTE: the vertex cutflow's denominator (nocut bin) is now SEEDED: only v0 candidates with a
402 // positron that has BOTH a track and a cluster, and an electron with a track (cluster optional),
403 // enter the cutflow. Cluster-EXISTENCE is folded into the seed; the positron cluster-ENERGY
404 // sanity cut (E_clus > 0.2 GeV) remains as the first cut after the skim.
405 vertex_cf_.add("positron_clusterE_above_0pt2GeV", 100, 0, 4.0);
406 vertex_cf_.add("electron_above_0pt2GeV", 100, 0.0, 4.0);
407 vertex_cf_.add("electron_below_2pt9GeV", 100, 0.0, 4.0);
408 vertex_cf_.add("ele_track_chi2ndf", 100, 0.0, 30.0);
409 vertex_cf_.add("pos_track_chi2ndf", 100, 0.0, 30.0);
410 vertex_cf_.add("positron_above_0pt4GeV", 100, 0.0, 4.0);
411 vertex_cf_.add("ele_min_hits", 14, 0, 14);
412 vertex_cf_.add("pos_min_hits", 14, 0, 14);
413 vertex_cf_.add("ele_track_cluster", 200, 0.0, 60.0);
414 vertex_cf_.add("pos_track_cluster", 200, 0.0, 20.0);
415 vertex_cf_.add("ele_pos_track", 200, 0.0, 20.0);
416 vertex_cf_.add("vertex_chi2", 100, 0.0, 30.0);
417 if (psumCut_ >= 0.0) vertex_cf_.add("psum_min", 100, 0.0, 4.0);
418 vertex_cf_.add("vtx_max_p_4pt0GeV", 100, 0.0, 4.0);
419 vertex_cf_.init();
420
421 std::stringstream ele_trk_clu_cut, pos_trk_clu_cut, ele_pos_trk_cut;
422 ele_trk_clu_cut << "|t_{trk, e^{-}} - t_{clu, e^{+}}| < " << time_cuts_[0] << " ns";
423 pos_trk_clu_cut << "|t_{trk, e^{+}} - t_{clu, e^{+}}| < " << time_cuts_[1] << " ns";
424 ele_pos_trk_cut << "|t_{trk, e^{-}} - t_{trk, e^{+}}| < " << time_cuts_[2] << " ns";
425 std::vector<std::string> labels_vertex_cf = {
426 "e^{+} trk+clu, e^{-} trk", "E_{e^{+}} > 0.2 GeV",
427 "p_{e^{-}} > 0.2 GeV", "p_{e^{-}} < 2.9 GeV",
428 "e^{-} #chi^{2}/ndf < 20", "e^{+} #chi^{2}/ndf < 20", "p_{e^{+}} > 0.4 GeV",
429 "N_{2D hits, e^{-}} #geq " + std::to_string(eleMinHits_), "N_{2D hits, e^{+}} #geq " + std::to_string(posMinHits_),
430 ele_trk_clu_cut.str(), pos_trk_clu_cut.str(), ele_pos_trk_cut.str(),
431 "#chi^{2}_{vtx} < 30"};
432 if (psumCut_ >= 0.0) {
433 std::stringstream psum_cut;
434 psum_cut << "p_{sum} > " << psumCut_ << " GeV";
435 labels_vertex_cf.push_back(psum_cut.str());
436 }
437 labels_vertex_cf.push_back("p_{vtx} < 4.0 GeV");
438 vertex_cf_.set_label_names(labels_vertex_cf);
439
440 /* event selection after vertex selection */
441 event_cf_.add("single_trigger", 2, -0.5, 1.5);
442 event_cf_.add("at_least_one_v0", 10, 0.0, 10.0);
443 event_cf_.add("at_least_one_vertex", 10, 0.0, 10.0);
444 event_cf_.add("no_extra_vertices", 10, 0.0, 10.0);
445 if (isSimpSignal_) {
446 event_cf_.add("at_least_one_true_vd", 3, 0.0, 2.0);
447 event_cf_.add("no_extra_true_vd", 3, 0.0, 2.0);
448 }
449 if (isApSignal_) {
450 event_cf_.add("at_least_one_true_ap", 3, 0.0, 2.0);
451 event_cf_.add("no_extra_true_ap", 3, 0.0, 2.0);
452 }
453 event_cf_.init();
454 std::string trig_label = (triggerSelection_ == "pairs") ? "pairs trigger" : "single2 or 3 trigger";
455 std::string no_extra_vtx_label = requireSingleVertex_ ? "N_{vtx}^{presel} < 2" : "best #chi^{2} selected";
456 std::vector<std::string> labels_event_cf = {"readout", trig_label, "N_{v0}^{raw} >= 1", "N_{vtx}^{presel} >= 1", no_extra_vtx_label};
457 event_cf_.set_label_names(labels_event_cf);
458
459 n_vertices_h_ = std::make_unique<TH2F>(
460 "n_vertices_h", "N Vertices in Event; N_{vtx}^{readout}; N_{vtx}^{preselected}", 10, -0.5, 9.5, 10, -0.5, 9.5);
461
462 // Best-chi2 multi-vertex diagnostics: filled for every event with >=2 preselected vertices,
463 // independent of requireSingleVertex_, so the effect of relaxing the veto can be checked
464 // against real data/MC before turning it on.
465 multivtx_chosen_chi2_h_ = std::make_unique<TH1F>(
466 "multivtx_chosen_chi2_h", "Chosen vertex #chi^{2} (events with #geq2 preselected vertices);#chi^{2};N", 60, 0.0, 30.0);
467 multivtx_discarded_chi2_h_ = std::make_unique<TH1F>(
468 "multivtx_discarded_chi2_h", "Discarded vertex #chi^{2} (events with #geq2 preselected vertices);#chi^{2};N", 60, 0.0, 30.0);
469}
470
472 Processor::setFile(out_file);
473
474 // create output TTree in output file
475 output_tree_ = std::make_unique<TTree>("preselection", "Preselected and Categorized Vertices", 99, out_file);
476 bus_.board_output<double>(output_tree_.get(), "weight");
483 bus_.board_output<int>(output_tree_.get(), "run_number");
484 bus_.board_output<int>(output_tree_.get(), "event_number");
485 // Position of the event in the input tuple: unique where MC event numbers are not.
486 bus_.board_output<int>(output_tree_.get(), "input_entry");
487 // Per raw v0 candidate (from vertex collection): the signed track-momentum scale the
488 // corrections applied, omega_before / omega_after
489 bus_.board_output<std::vector<double>>(output_tree_.get(), "vtx_ele_smear_scale");
490 bus_.board_output<std::vector<double>>(output_tree_.get(), "vtx_pos_smear_scale");
491 bus_.board_output<Vertex>(output_tree_.get(), "vertex");
492 bus_.board_output<Particle>(output_tree_.get(), "ele");
493 bus_.board_output<Particle>(output_tree_.get(), "pos");
494 bus_.board_output<Track>(output_tree_.get(), "third_track");
495 bus_.board_output<double>(output_tree_.get(), "psum");
496 bus_.board_output<double>(output_tree_.get(), "psum_scalar");
497 bus_.board_output<double>(output_tree_.get(), "epem_opening_angle");
498 bus_.board_output<double>(output_tree_.get(), "recoil_theta");
499 bus_.board_output<double>(output_tree_.get(), "ele_p_smear_ratio");
500 bus_.board_output<double>(output_tree_.get(), "pos_p_smear_ratio");
501 bus_.board_output<double>(output_tree_.get(), "pos_cl_min_dr");
502 bus_.board_output<double>(output_tree_.get(), "pos_cl_min_dr_t");
503 bus_.board_output<bool>(output_tree_.get(), "ele_has_truth_link");
504 bus_.board_output<bool>(output_tree_.get(), "pos_has_truth_link");
505 bus_.board_output<TVector3>(output_tree_.get(), "ele_track_p");
506 bus_.board_output<TVector3>(output_tree_.get(), "pos_track_p");
507 bus_.board_output<TVector3>(output_tree_.get(), "ele_track_p_prefit");
508 bus_.board_output<TVector3>(output_tree_.get(), "pos_track_p_prefit");
509 bus_.board_output<TVector3>(output_tree_.get(), "ele_truth_p");
510 bus_.board_output<TVector3>(output_tree_.get(), "pos_truth_p");
511
512 // Standalone-track vs vertex-fit comparison, independent of useVertexMomentum. Both are
513 // captured before smearing/scale corrections, so the difference is due to the fit alone.
514 for (const auto& name : {"trk_invM",
515 "ele_p_prefit", "ele_px_prefit", "ele_py_prefit", "ele_pz_prefit",
516 "pos_p_prefit", "pos_px_prefit", "pos_py_prefit", "pos_pz_prefit",
517 "ele_p_postfit", "ele_px_postfit", "ele_py_postfit", "ele_pz_postfit",
518 "pos_p_postfit", "pos_px_postfit", "pos_py_postfit", "pos_pz_postfit"}) {
519 bus_.board_output<double>(output_tree_.get(), name);
520 }
521
522 /***************************************
523 * adding specific cut variables *
524 ***************************************/
525
526 // hit categories (layer has both axial+stereo)
527 for (const auto& name : {"eleL1", "eleL2", "eleL3", "eleL4", "posL1", "posL2", "posL3", "posL4", "single2", "single3"}) {
528 bus_.board_output<bool>(output_tree_.get(), name);
529 }
530
531 // vertex layer category flags (outward hit requirement enforced)
532 for (const auto& name : {"isL1L1", "isL2L2", "isL3L3", "isL1L2", "isL2L3"}) {
533 bus_.board_output<bool>(output_tree_.get(), name);
534 }
535
536 // top/bottom track flags
537 for (const auto& name : {"ele_isTop", "pos_isTop"}) {
538 bus_.board_output<bool>(output_tree_.get(), name);
539 }
540
541 // per-layer axial/stereo hit flags
542 for (const auto& name : {
543 "eleL1_axial", "eleL1_stereo", "eleL2_axial", "eleL2_stereo",
544 "eleL3_axial", "eleL3_stereo", "eleL4_axial", "eleL4_stereo",
545 "posL1_axial", "posL1_stereo", "posL2_axial", "posL2_stereo",
546 "posL3_axial", "posL3_stereo", "posL4_axial", "posL4_stereo"}) {
547 bus_.board_output<bool>(output_tree_.get(), name);
548 }
549
550 // vertex projection to target
551 if (not v0proj_fits_.empty()) {
552 for (const auto& name : {"vtx_proj_sig", "vtx_proj_x", "vtx_proj_x_sig", "vtx_proj_y", "vtx_proj_y_sig",
553 "vtx_proj_x_centered", "vtx_proj_y_centered",
554 "vtx_proj_sig_lcio", "vtx_proj_x_lcio", "vtx_proj_x_sig_lcio",
555 "vtx_proj_y_lcio", "vtx_proj_y_sig_lcio",
556 "vtx_proj_x_err_lcio", "vtx_proj_y_err_lcio",
557 "vtx_proj_x_centered_lcio", "vtx_proj_y_centered_lcio"}) {
558 bus_.board_output<double>(output_tree_.get(), name);
559 }
560 }
561
562 // isolation cut
563 for (const auto& name : {"ele_L1_iso", "pos_L1_iso", "ele_L1_iso_significance", "pos_L1_iso_significance",
564 "ele_L1_iso_significance_raw", "pos_L1_iso_significance_raw"}) {
565 bus_.board_output<double>(output_tree_.get(), name);
566 }
567
568 // vertical impact parameter
569 for (const auto& name : {"min_y0", "max_y0err", "min_y0err", "ele_y0err", "pos_y0err", "min_y0_vtx", "min_y0_vtx_proj", "vtx_y_at_zero", "delta_y0_vtx_proj"}) {
570 bus_.board_output<double>(output_tree_.get(), name);
571 }
572
574 for (const auto& extrema : {"min", "max"}) {
575 bus_.board_output<double>(output_tree_.get(), std::string(extrema) + "_dTanLambda");
576 bus_.board_output<double>(output_tree_.get(), std::string(extrema) + "_opening");
577 bus_.board_output<double>(output_tree_.get(), std::string(extrema) + "_mass");
578 bus_.board_output<double>(output_tree_.get(), std::string(extrema) + "_asym");
579 bus_.board_output<double>(output_tree_.get(), std::string(extrema) + "_dPhi");
580 }
581 }
582
583 if (saveAllTracks_) {
584 bus_.board_output<std::vector<Track>>(output_tree_.get(), "all_preselected_tracks");
585 }
586
587 if (bus_.has(mcColl_)) {
588 if (isSimpSignal_) {
589 bus_.board_output<MCParticle>(output_tree_.get(), "true_vd");
590 bus_.board_output<double>(output_tree_.get(), "true_vd_betagamma");
591 }
592 if (isApSignal_) {
593 bus_.board_output<MCParticle>(output_tree_.get(), "true_ap");
594 bus_.board_output<double>(output_tree_.get(), "true_decay_len");
595 bus_.board_output<double>(output_tree_.get(), "true_ap_betagamma");
596 }
597 bus_.board_output<bool>(output_tree_.get(), "isRadEle");
598 bus_.board_output<double>(output_tree_.get(), "true_vertex_invM");
599 bus_.board_output<double>(output_tree_.get(), "true_vertex_psum");
600 }
601}
602
604 // Reset the output branches so that anything we do not explicitly set this
605 // event is written as its default rather than carrying over the previous
606 // event's value. Matters for the conditionally-filled truth branches
607 // (true_vertex_invM, true_ap, true_decay_len, ...), which are only set when
608 // the truth match succeeds.
609 bus_.clear_outputs();
610
611 const auto& tsbank{bus_.get<TSData>("TSBank")};
612 const auto& eh{bus_.get<EventHeader>("EventHeader")};
613 int run_number = eh.getRunNumber();
614 if (corrector_) {
615 const std::vector<MCParticle*>* mcParticles =
616 bus_.has(mcColl_) ? &bus_.get<std::vector<MCParticle*>>(mcColl_) : nullptr;
617 corrector_->beginEvent(run_number, mcParticles);
618 }
619 // Set immediately after clear_outputs so the identity is recorded no matter which
620 // of the many early returns below ends up rejecting the event.
621 bus_.set("run_number", run_number);
622 bus_.set("event_number", eh.getEventNumber());
623 bus_.set("input_entry", ++input_entry_);
624
625 event_cf_.begin_event();
626
627 // re-apply trigger desicion to data sample since it contains
628 // other triggers within it
629 // MC is created with only this trigger AND the event header
630 // is not updated so we need to skip this check for MC
631 // trigger decision selected by configuration: default "singles2" (singles2||singles3),
632 // or "pairs" (OR of all pair triggers). Anything else falls back to the singles logic.
633 bool trigger_decision = (triggerSelection_ == "pairs")
634 ? tsbank.isPairTrigger()
635 : (tsbank.isSingle3Trigger() || tsbank.isSingle2Trigger());
636 event_cf_.apply("single_trigger", trigger_decision);
637 event_cf_.fill_nm1("single_trigger", trigger_decision ? 1 : 0);
638 if (not event_cf_.keep()) {
639 // we leave BEFORE filling the vertex counting histogram
640 // so that the vertex count histogram is relative to this trigger
641 // and does not include other triggers
642 return true;
643 }
644
645 const auto& allClusters{bus_.get<std::vector<CalCluster*>>("RecoEcalClusters")};
646
647 const auto& vtxs{bus_.get<std::vector<Vertex*>>(vtxColl_)};
648
649 // event-level: does the event have at least one raw v0 (before any preselection cuts)?
650 // sits between the trigger and the preselected-vertex requirement so the cutflow shows
651 // trigger -> >=1 v0 -> >=1 good (preselected) v0.
652 event_cf_.apply("at_least_one_v0", vtxs.size() >= 1);
653 event_cf_.fill_nm1("at_least_one_v0", vtxs.size());
654
676 struct PreselectedVertex {
677 Vertex vtx;
678 Particle ele;
679 Particle pos;
680 double ele_z0_raw;
681 double pos_z0_raw;
682 TVector3 ele_track_p;
683 TVector3 pos_track_p;
684 TVector3 ele_track_p_prefit;
685 TVector3 pos_track_p_prefit;
686 TVector3 ele_p_postfit;
687 TVector3 pos_p_postfit;
688 double ele_p_smear_ratio;
689 double pos_p_smear_ratio;
690 };
691 std::vector<PreselectedVertex> preselected_vtx;
692 std::vector<double> vtx_ele_smear_scale, vtx_pos_smear_scale; // one entry per raw v0
693 int ivtx = 0;
694
695 // Orphan-positron-cluster diagnostic, aggregated over the whole event. It only takes a
696 // value for candidates whose positron has NO cluster, and those are rejected below -- so
697 // it can never describe the vertex that gets written out, and is necessarily an
698 // event-level quantity. We keep the closest orphan over all raw candidates; the sentinel
699 // survives when every candidate had a positron cluster.
700 double evt_pos_cl_min_dr = -9999.0;
701 double evt_pos_cl_min_dr_t = -9999.0;
702
703 for (Vertex* vtx : vtxs) {
704 // access the indiviual Vertex, electron, and positron
705 // and add corrections to them before applying pre-selection
706 int i_ele{-1}, i_pos{-1};
707 for (int ipart = 0; ipart < vtx->getParticles().GetEntries(); ++ipart) {
708 int pdg_id = ((Particle*)vtx->getParticles().At(ipart))->getPDG();
709 if (pdg_id == 11) {
710 i_ele = ipart;
711 } else if (pdg_id == -11) {
712 i_pos = ipart;
713 }
714 }
715 if (i_ele < 0 or i_pos < 0) {
716 throw std::runtime_error("Vertex formed without either an electron or positron!");
717 }
718
719 Particle ele = *dynamic_cast<Particle*>(vtx->getParticles().At(i_ele));
720 Particle pos = *dynamic_cast<Particle*>(vtx->getParticles().At(i_pos));
721
722 // for both particles, get cluster, update, re-set cluster
723 CalCluster ele_clu = ele.getCluster();
724 CalCluster pos_clu = pos.getCluster();
725
726 ele_clu.setTime(ele_clu.getTime() - calTimeOffset_);
727 pos_clu.setTime(pos_clu.getTime() - calTimeOffset_);
728
729 ele.setCluster(&ele_clu);
730 pos.setCluster(&pos_clu);
731
732 Track ele_trk = ele.getTrack();
733 Track pos_trk = pos.getTrack();
734
735 // cache z0 before any corrections (used to recompute isolation significance)
736 double ele_z0_raw = ele_trk.getZ0();
737 double pos_z0_raw = pos_trk.getZ0();
738
739 // snapshot pre-vertex-fit track momenta before they are overwritten
740 TVector3 ele_p_prefit(ele_trk.getMomentum()[0], ele_trk.getMomentum()[1], ele_trk.getMomentum()[2]);
741 TVector3 pos_p_prefit(pos_trk.getMomentum()[0], pos_trk.getMomentum()[1], pos_trk.getMomentum()[2]);
742 // snapshot vertex-fitted momenta now: smearing below rescales them in place on vtx
743 TVector3 ele_p_postfit(vtx->getP1X(), vtx->getP1Y(), vtx->getP1Z());
744 TVector3 pos_p_postfit(vtx->getP2X(), vtx->getP2Y(), vtx->getP2Z());
745
746 // Replace particle track momenta with the vertex-fitted momenta (only when enabled). The
747 // vertex stores its two fitted momenta in a fixed electron-then-positron slot order
748 // (verified against hps-java: BilliorVertexer.fitVertex preserves the input track order
749 // [electron, positron] from HpsReconParticleDriver.makeV0Candidates, and
750 // BilliorVertex::getParameters writes p1 <- electron, p2 <- positron), independent of
751 // which vertical half (top/bottom) either track curves into. When useVertexMomentum_ is
752 // false, the standalone track-fit momenta are kept as-is.
753 if (useVertexMomentum_) {
754 ele_trk.setMomentum(vtx->getP1X(), vtx->getP1Y(), vtx->getP1Z());
755 pos_trk.setMomentum(vtx->getP2X(), vtx->getP2Y(), vtx->getP2Z());
756 }
757
758 // Track corrections, in TrackCorrector's fixed order: offsets and z0 calibration, data
759 // scale corrections, MC smearing. The vertex-fitted momenta follow the track momenta.
760 double ele_p_smear_ratio = 1.0;
761 double pos_p_smear_ratio = 1.0;
762 const double ele_omega_before = ele_trk.getOmega();
763 const double pos_omega_before = pos_trk.getOmega();
764 if (corrector_) {
765 auto corr = corrector_->correct({&ele_trk, &pos_trk}, {-1, +1});
766 ele_p_smear_ratio = corr[0].pRatio();
767 pos_p_smear_ratio = corr[1].pRatio();
768 if (corrector_->updatesVertex()) TrackCorrector::correctVertex(vtx, ele_p_smear_ratio, pos_p_smear_ratio);
769 if (debug_)
770 std::cout << "[TrackCorrector] ele ratio " << ele_p_smear_ratio << " pos ratio " << pos_p_smear_ratio
771 << " ele |p| " << ele_trk.getP() << " pos |p| " << pos_trk.getP() << std::endl;
772 }
773 // Recorded for every raw candidate, before the seeding requirement below can skip it.
774 vtx_ele_smear_scale.push_back(ele_trk.getOmega() != 0. ? ele_omega_before / ele_trk.getOmega() : 1.);
775 vtx_pos_smear_scale.push_back(pos_trk.getOmega() != 0. ? pos_omega_before / pos_trk.getOmega() : 1.);
776 // Captured, not published -- see the PreselectedVertex comment above.
777 TVector3 ele_track_p(ele_trk.getMomentum()[0], ele_trk.getMomentum()[1], ele_trk.getMomentum()[2]);
778 TVector3 pos_track_p(pos_trk.getMomentum()[0], pos_trk.getMomentum()[1], pos_trk.getMomentum()[2]);
779
780 // put tracks back into their particles
781 // with their new data
782 ele.setTrack(&ele_trk);
783 pos.setTrack(&pos_trk);
784
785 // corrections have been applied, now onto pre-selecting
786 int ele_nhits = ele.getTrack().getTrackerHitCount();
787 if (not ele.getTrack().isKalmanTrack()) ele_nhits *= 2;
788 int pos_nhits = pos.getTrack().getTrackerHitCount();
789 if (not pos.getTrack().isKalmanTrack()) pos_nhits *= 2;
790
791 if (debug_) {
792 std::cout << "Tracker hit counts (vertex " << ivtx << "):" << std::endl;
793 std::cout << " Electron: TrackerHitCount=" << ele.getTrack().getTrackerHitCount()
794 << ", nhits (after scaling)=" << ele_nhits << std::endl;
795 std::cout << " Positron: TrackerHitCount=" << pos.getTrack().getTrackerHitCount()
796 << ", nhits (after scaling)=" << pos_nhits << std::endl;
797 }
798
799 TVector3 ele_mom(ele.getTrack().getMomentum()[0], ele.getTrack().getMomentum()[1],
800 ele.getTrack().getMomentum()[2]);
801 TVector3 pos_mom(pos.getTrack().getMomentum()[0], pos.getTrack().getMomentum()[1],
802 pos.getTrack().getMomentum()[2]);
803
804 TVector3 psum = ele_mom + pos_mom;
805
806 // ----- seed the vertex cutflow -----
807 // Only v0 candidates with a positron that has BOTH a track and a cluster, and an electron
808 // with a track (its cluster is irrelevant here), are counted. These define the cutflow
809 // denominator (nocut bin); the remaining cuts then measure preselection efficiency relative
810 // to this clean candidate, instead of charging cluster-acceptance against the first cut.
811 const auto& posCl = pos.getCluster();
812 double posClE = posCl.getEnergy();
813 bool pos_has_cluster = (posClE > -9000.0);
814 bool pos_has_track = (pos.getTrack().getTrackerHitCount() > 0);
815 bool ele_has_track = (ele.getTrack().getTrackerHitCount() > 0);
816
817 // orphan-cluster diagnostic (only filled when the positron has NO cluster, which the seed
818 // below rejects -> stays at the sentinel for seeded candidates).
819 double pos_cl_min_dr = -9999.0;
820 double pos_cl_min_dr_t = -9999.0;
821 if (not pos_has_cluster) {
822 auto posAtEcal = pos_trk.getPositionAtEcal();
823 double min_dr = 9999.0;
824 for (const auto* cl : allClusters) {
825 auto clPos = cl->getPosition();
826 double dx = clPos[0] - posAtEcal[0];
827 double dy = clPos[1] - posAtEcal[1];
828 double dr = std::sqrt(dx*dx + dy*dy);
829 if (dr < min_dr) {
830 min_dr = dr;
831 pos_cl_min_dr_t = cl->getTime() - calTimeOffset_;
832 }
833 }
834 pos_cl_min_dr = min_dr;
835 }
836 if (not pos_has_cluster &&
837 (evt_pos_cl_min_dr < 0.0 || pos_cl_min_dr < evt_pos_cl_min_dr)) {
838 evt_pos_cl_min_dr = pos_cl_min_dr;
839 evt_pos_cl_min_dr_t = pos_cl_min_dr_t;
840 }
841
842 if (not (pos_has_track && pos_has_cluster && ele_has_track)) {
843 ivtx++;
844 continue; // does not seed the cutflow and cannot be preselected
845 }
846
847 vertex_cf_.begin_event();
848 // sanity cut on the (now-guaranteed-present) positron cluster energy
849 vertex_cf_.apply("positron_clusterE_above_0pt2GeV", posClE >= 0.2);
850 vertex_cf_.apply("electron_above_0pt2GeV", ele.getTrack().getP() >= 0.2);
851 vertex_cf_.apply("electron_below_2pt9GeV", ele.getTrack().getP() <= 2.9);
852 vertex_cf_.apply("ele_track_chi2ndf", ele.getTrack().getChi2Ndf() <= 20.0);
853 vertex_cf_.apply("pos_track_chi2ndf", pos.getTrack().getChi2Ndf() <= 20.0);
854 vertex_cf_.apply("positron_above_0pt4GeV", pos.getTrack().getP() >= 0.4);
855 vertex_cf_.apply("ele_min_hits", ele_nhits >= eleMinHits_);
856 vertex_cf_.apply("pos_min_hits", pos_nhits >= posMinHits_);
857 vertex_cf_.apply("ele_track_cluster",
858 disableTimingCuts_ || fabs(ele.getTrack().getTrackTime() - pos.getCluster().getTime()) <= time_cuts_[0]);
859 vertex_cf_.apply("pos_track_cluster",
860 disableTimingCuts_ || fabs(pos.getTrack().getTrackTime() - pos.getCluster().getTime()) <= time_cuts_[1]);
861 vertex_cf_.apply("ele_pos_track",
863 vertex_cf_.apply("vertex_chi2", disableVertexChi2Cut_ || vtx->getChi2() <= 30.0);
864 if (psumCut_ >= 0.0) vertex_cf_.apply("psum_min", psum.Mag() > psumCut_);
865 double vtxmaxp = ele_mom.Mag() + pos_mom.Mag();
866 vertex_cf_.apply("vtx_max_p_4pt0GeV", psum.Mag() <= 4.0);
867
868 vertex_cf_.fill_nm1("positron_clusterE_above_0pt2GeV", posClE);
869 vertex_cf_.fill_nm1("electron_above_0pt2GeV", ele.getTrack().getP());
870 vertex_cf_.fill_nm1("electron_below_2pt9GeV", ele.getTrack().getP());
871 vertex_cf_.fill_nm1("ele_track_chi2ndf", ele.getTrack().getChi2Ndf());
872 vertex_cf_.fill_nm1("pos_track_chi2ndf", pos.getTrack().getChi2Ndf());
873 vertex_cf_.fill_nm1("positron_above_0pt4GeV", pos.getTrack().getP());
874 vertex_cf_.fill_nm1("ele_min_hits", ele_nhits);
875 vertex_cf_.fill_nm1("pos_min_hits", pos_nhits);
876 vertex_cf_.fill_nm1("ele_track_cluster", fabs(ele.getTrack().getTrackTime() - pos.getCluster().getTime()));
877 vertex_cf_.fill_nm1("pos_track_cluster", fabs(pos.getTrack().getTrackTime() - pos.getCluster().getTime()));
878 vertex_cf_.fill_nm1("ele_pos_track", fabs(ele.getTrack().getTrackTime() - pos.getTrack().getTrackTime()));
879 vertex_cf_.fill_nm1("vertex_chi2", vtx->getChi2());
880 if (psumCut_ >= 0.0) vertex_cf_.fill_nm1("psum_min", psum.Mag());
881 vertex_cf_.fill_nm1("vtx_max_p_4pt0GeV", vtxmaxp);
882
883 if (disablePreselection_ || vertex_cf_.keep()) {
884 preselected_vtx.push_back(PreselectedVertex{*vtx, ele, pos, ele_z0_raw, pos_z0_raw,
885 ele_track_p, pos_track_p,
886 ele_p_prefit, pos_p_prefit,
887 ele_p_postfit, pos_p_postfit,
888 ele_p_smear_ratio, pos_p_smear_ratio});
889 }
890 ivtx++;
891 }
892
893 n_vertices_h_->Fill(vtxs.size(), preselected_vtx.size());
894
895 bus_.set("vtx_ele_smear_scale", vtx_ele_smear_scale);
896 bus_.set("vtx_pos_smear_scale", vtx_pos_smear_scale);
897 bus_.set("pos_cl_min_dr", evt_pos_cl_min_dr);
898 bus_.set("pos_cl_min_dr_t", evt_pos_cl_min_dr_t);
899
900 // Index of the preselected vertex with the lowest chi2 -- the vertex that will be carried
901 // forward if the event survives. Trivially valid when there are 0 or 1 preselected vertices.
902 std::size_t i_best_vtx = 0;
903 for (std::size_t i = 1; i < preselected_vtx.size(); ++i) {
904 if (preselected_vtx[i].vtx.getChi2() < preselected_vtx[i_best_vtx].vtx.getChi2()) {
905 i_best_vtx = i;
906 }
907 }
908 // Multi-vertex chi2 diagnostics: always filled (independent of requireSingleVertex_) so the
909 // effect of relaxing the veto can be checked against data/MC before turning it on.
910 if (preselected_vtx.size() >= 2) {
911 for (std::size_t i = 0; i < preselected_vtx.size(); ++i) {
912 double chi2 = preselected_vtx[i].vtx.getChi2();
913 (i == i_best_vtx ? multivtx_chosen_chi2_h_ : multivtx_discarded_chi2_h_)->Fill(chi2);
914 }
915 }
916
917 event_cf_.apply("at_least_one_vertex", disablePreselection_ || preselected_vtx.size() >= 1);
918 event_cf_.apply("no_extra_vertices",
919 disablePreselection_ || !requireSingleVertex_ || preselected_vtx.size() < 2);
920
921 event_cf_.fill_nm1("at_least_one_vertex", preselected_vtx.size());
922 event_cf_.fill_nm1("no_extra_vertices", preselected_vtx.size());
923 if (not event_cf_.keep()) {
924 return true;
925 }
926
927 bool single2{false}, single3{false};
928 if (tsbank.isSingle3Trigger() == 1) single3 = true;
929 if (tsbank.isSingle2Trigger() == 1) single2 = true;
930 bus_.set("single2", single2);
931 bus_.set("single3", single3);
932
933 // unpack the selected vertex into its elements. Normally there is exactly one preselected
934 // vertex; if requireSingleVertex_ is false and multiple survived, i_best_vtx (computed above)
935 // picks the one with the lowest vertex chi2.
936 // Guard against empty collection (can occur when disablePreselection=true bypasses at_least_one_vertex)
937 if (preselected_vtx.empty()) return true;
938 auto selected = preselected_vtx.at(i_best_vtx);
939 Vertex& vtx = selected.vtx;
940 Particle& ele = selected.ele;
941 Particle& pos = selected.pos;
942 const double ele_z0_raw = selected.ele_z0_raw;
943 const double pos_z0_raw = selected.pos_z0_raw;
944
945 // Per-vertex quantities stashed during the loop, now published for the selected vertex.
946 bus_.set("ele_track_p", selected.ele_track_p);
947 bus_.set("pos_track_p", selected.pos_track_p);
948 bus_.set("ele_track_p_prefit", selected.ele_track_p_prefit);
949 bus_.set("pos_track_p_prefit", selected.pos_track_p_prefit);
950 for (const auto& [prefix, prefit, postfit] : {
951 std::make_tuple("ele_", selected.ele_track_p_prefit, selected.ele_p_postfit),
952 std::make_tuple("pos_", selected.pos_track_p_prefit, selected.pos_p_postfit)}) {
953 const std::string pre{prefix};
954 bus_.set(pre + "p_prefit", prefit.Mag());
955 bus_.set(pre + "px_prefit", prefit.X());
956 bus_.set(pre + "py_prefit", prefit.Y());
957 bus_.set(pre + "pz_prefit", prefit.Z());
958 bus_.set(pre + "p_postfit", postfit.Mag());
959 bus_.set(pre + "px_postfit", postfit.X());
960 bus_.set(pre + "py_postfit", postfit.Y());
961 bus_.set(pre + "pz_postfit", postfit.Z());
962 }
963 {
964 // e+e- invariant mass from the standalone track momenta (never the vertex-fitted ones)
965 constexpr double electron_mass{0.000510999}; // GeV
966 const TVector3& pe{selected.ele_track_p_prefit};
967 const TVector3& pp{selected.pos_track_p_prefit};
968 ROOT::Math::PxPyPzMVector ele_p4(pe.X(), pe.Y(), pe.Z(), electron_mass);
969 ROOT::Math::PxPyPzMVector pos_p4(pp.X(), pp.Y(), pp.Z(), electron_mass);
970 bus_.set("trk_invM", (ele_p4 + pos_p4).M());
971 }
972 bus_.set("ele_p_smear_ratio", selected.ele_p_smear_ratio);
973 bus_.set("pos_p_smear_ratio", selected.pos_p_smear_ratio);
974
975 // earliest layer hit categories
976 bool eleL1{false}, eleL2{false}, eleL3{false}, eleL4{false};
977 bool posL1{false}, posL2{false}, posL3{false}, posL4{false};
978 Track ele_trk{ele.getTrack()}, pos_trk{pos.getTrack()};
979 auto ele_layers = _ah->GetTrackHitLayers(&ele_trk);
980 auto pos_layers = _ah->GetTrackHitLayers(&pos_trk);
981
982 if (ele_layers.at(0) == 1 && ele_layers.at(1) == 1) eleL1 = true;
983 if (ele_layers.at(2) == 1 && ele_layers.at(3) == 1) eleL2 = true;
984 if (ele_layers.at(4) == 1 && ele_layers.at(5) == 1) eleL3 = true;
985 if (ele_layers.at(6) == 1 && ele_layers.at(7) == 1) eleL4 = true;
986 if (pos_layers.at(0) == 1 && pos_layers.at(1) == 1) posL1 = true;
987 if (pos_layers.at(2) == 1 && pos_layers.at(3) == 1) posL2 = true;
988 if (pos_layers.at(4) == 1 && pos_layers.at(5) == 1) posL3 = true;
989 if (pos_layers.at(6) == 1 && pos_layers.at(7) == 1) posL4 = true;
990
991 bus_.set("eleL1", eleL1);
992 bus_.set("eleL2", eleL2);
993 bus_.set("eleL3", eleL3);
994 bus_.set("eleL4", eleL4);
995 bus_.set("posL1", posL1);
996 bus_.set("posL2", posL2);
997 bus_.set("posL3", posL3);
998 bus_.set("posL4", posL4);
999
1000 // vertex layer category flags (outward hit requirement: LN track requires L[N..3] hits and no L[1..N-1])
1001 bool ele_L1 = eleL1 && eleL2 && eleL3;
1002 bool ele_L2 = !eleL1 && eleL2 && eleL3;
1003 bool ele_L3 = !eleL1 && !eleL2 && eleL3;
1004 bool pos_L1 = posL1 && posL2 && posL3;
1005 bool pos_L2 = !posL1 && posL2 && posL3;
1006 bool pos_L3 = !posL1 && !posL2 && posL3;
1007
1008 bus_.set("isL1L1", ele_L1 && pos_L1);
1009 bus_.set("isL2L2", ele_L2 && pos_L2);
1010 bus_.set("isL3L3", ele_L3 && pos_L3);
1011 bus_.set("isL1L2", (ele_L1 && pos_L2) || (pos_L1 && ele_L2));
1012 bus_.set("isL2L3", (ele_L2 && pos_L3) || (pos_L2 && ele_L3));
1013
1014 // top/bottom identification
1015 bool ele_isTop = ele_trk.getTanLambda() > 0;
1016 bool pos_isTop = pos_trk.getTanLambda() > 0;
1017 bus_.set("ele_isTop", ele_isTop);
1018 bus_.set("pos_isTop", pos_isTop);
1019
1020 // Per-layer axial/stereo hit flags
1021 // From sensor_locations.txt z-positions:
1022 // Top: even index (0,2,4,6) = axial, odd index (1,3,5,7) = stereo
1023 // Bottom: even index (0,2,4,6) = stereo, odd index (1,3,5,7) = axial
1024 auto setLayerHits = [&](const std::vector<int>& layers, bool isTop, const std::string& prefix) {
1025 for (int iL = 0; iL < 4; iL++) {
1026 int idx_even = 2 * iL;
1027 int idx_odd = 2 * iL + 1;
1028 bool hit_axial = isTop ? (layers.at(idx_even) == 1) : (layers.at(idx_odd) == 1);
1029 bool hit_stereo = isTop ? (layers.at(idx_odd) == 1) : (layers.at(idx_even) == 1);
1030 bus_.set(prefix + "L" + std::to_string(iL + 1) + "_axial", hit_axial);
1031 bus_.set(prefix + "L" + std::to_string(iL + 1) + "_stereo", hit_stereo);
1032 }
1033 };
1034 setLayerHits(ele_layers, ele_isTop, "ele");
1035 setLayerHits(pos_layers, pos_isTop, "pos");
1036
1037 double ele_L1_iso{9999.0}, pos_L1_iso{9999.0};
1038 if (eleL1 && eleL2 && posL1 && posL2) {
1039 ele_L1_iso = ele_trk.getIsolation(0);
1040 pos_L1_iso = pos_trk.getIsolation(0);
1041 }
1042 bus_.set("ele_L1_iso", ele_L1_iso);
1043 bus_.set("pos_L1_iso", pos_L1_iso);
1044
1045 // isolation significance
1046 double ele_L1_iso_significance{9999.0}, pos_L1_iso_significance{9999.0};
1047
1048 if (debug_) {
1049 std::cout << "[iso_sig debug] eleL1=" << eleL1 << " eleL2=" << eleL2
1050 << " posL1=" << posL1 << " posL2=" << posL2 << std::endl;
1051 std::cout << "[iso_sig debug] ele_L1_iso=" << ele_L1_iso
1052 << " pos_L1_iso=" << pos_L1_iso << std::endl;
1053 }
1054
1055 if (eleL1 && eleL2 && posL1 && posL2) {
1056 if (ele_L1_iso < 9999.0) {
1057 double ele_py_sign = TMath::Sign(1, ele_trk.getMomentum()[1]);
1058 double ele_z0 = ele_trk.getZ0();
1059 double ele_z0err = ele_trk.getZ0Err();
1060 ele_L1_iso_significance = (2 * ele_L1_iso + ele_py_sign * ele_z0) / ele_z0err;
1061 if (debug_) {
1062 std::cout << "[iso_sig debug] ele: iso=" << ele_L1_iso
1063 << " py_sign=" << ele_py_sign
1064 << " z0=" << ele_z0
1065 << " z0err=" << ele_z0err
1066 << " numerator=(2*iso + sign*z0)=" << (2 * ele_L1_iso + ele_py_sign * ele_z0)
1067 << " significance=" << ele_L1_iso_significance << std::endl;
1068 }
1069 } else if (debug_) {
1070 std::cout << "[iso_sig debug] ele: iso=9999 (no L1 hit), significance not calculated" << std::endl;
1071 }
1072
1073 if (pos_L1_iso < 9999.0) {
1074 double pos_py_sign = TMath::Sign(1, pos_trk.getMomentum()[1]);
1075 double pos_z0 = pos_trk.getZ0();
1076 double pos_z0err = pos_trk.getZ0Err();
1077 pos_L1_iso_significance = (2 * pos_L1_iso + pos_py_sign * pos_z0) / pos_z0err;
1078 if (debug_) {
1079 std::cout << "[iso_sig debug] pos: iso=" << pos_L1_iso
1080 << " py_sign=" << pos_py_sign
1081 << " z0=" << pos_z0
1082 << " z0err=" << pos_z0err
1083 << " numerator=(2*iso + sign*z0)=" << (2 * pos_L1_iso + pos_py_sign * pos_z0)
1084 << " significance=" << pos_L1_iso_significance << std::endl;
1085 }
1086 } else if (debug_) {
1087 std::cout << "[iso_sig debug] pos: iso=9999 (no L1 hit), significance not calculated" << std::endl;
1088 }
1089 } else if (debug_) {
1090 std::cout << "[iso_sig debug] L1L2 hit requirement not met, significance left at 9999" << std::endl;
1091 }
1092 bus_.set("ele_L1_iso_significance", ele_L1_iso_significance);
1093 bus_.set("pos_L1_iso_significance", pos_L1_iso_significance);
1094
1095 // Recompute isolation significance using raw (pre-correction) z0
1096 double ele_L1_iso_significance_raw{9999.0}, pos_L1_iso_significance_raw{9999.0};
1097 if (debug_) {
1098 std::cout << "[iso_sig debug] raw z0: ele_z0_raw=" << ele_z0_raw
1099 << " pos_z0_raw=" << pos_z0_raw << std::endl;
1100 }
1101 if (eleL1 && eleL2 && posL1 && posL2) {
1102 if (ele_L1_iso < 9999.0) {
1103 double ele_py_sign = TMath::Sign(1, ele_trk.getMomentum()[1]);
1104 ele_L1_iso_significance_raw = (2 * ele_L1_iso + ele_py_sign * ele_z0_raw) / ele_trk.getZ0Err();
1105 if (debug_) {
1106 std::cout << "[iso_sig debug] ele raw: iso=" << ele_L1_iso
1107 << " py_sign=" << ele_py_sign
1108 << " z0_raw=" << ele_z0_raw
1109 << " z0err=" << ele_trk.getZ0Err()
1110 << " numerator=" << (2 * ele_L1_iso + ele_py_sign * ele_z0_raw)
1111 << " significance_raw=" << ele_L1_iso_significance_raw << std::endl;
1112 }
1113 }
1114 if (pos_L1_iso < 9999.0) {
1115 double pos_py_sign = TMath::Sign(1, pos_trk.getMomentum()[1]);
1116 pos_L1_iso_significance_raw = (2 * pos_L1_iso + pos_py_sign * pos_z0_raw) / pos_trk.getZ0Err();
1117 if (debug_) {
1118 std::cout << "[iso_sig debug] pos raw: iso=" << pos_L1_iso
1119 << " py_sign=" << pos_py_sign
1120 << " z0_raw=" << pos_z0_raw
1121 << " z0err=" << pos_trk.getZ0Err()
1122 << " numerator=" << (2 * pos_L1_iso + pos_py_sign * pos_z0_raw)
1123 << " significance_raw=" << pos_L1_iso_significance_raw << std::endl;
1124 }
1125 }
1126 }
1127 bus_.set("ele_L1_iso_significance_raw", ele_L1_iso_significance_raw);
1128 bus_.set("pos_L1_iso_significance_raw", pos_L1_iso_significance_raw);
1129
1130 TVector3 ele_mom(ele_trk.getMomentum()[0], ele_trk.getMomentum()[1], ele_trk.getMomentum()[2]);
1131 TVector3 pos_mom(pos_trk.getMomentum()[0], pos_trk.getMomentum()[1], pos_trk.getMomentum()[2]);
1132 TVector3 psum = ele_mom + pos_mom;
1133
1134 if (debug_) {
1135 std::cout << "Preselection psum calculation:" << std::endl;
1136 std::cout << " Electron: px=" << ele_mom.X() << " py=" << ele_mom.Y() << " pz=" << ele_mom.Z()
1137 << " |p|=" << ele_mom.Mag() << std::endl;
1138 std::cout << " Positron: px=" << pos_mom.X() << " py=" << pos_mom.Y() << " pz=" << pos_mom.Z()
1139 << " |p|=" << pos_mom.Mag() << std::endl;
1140 std::cout << " Psum: px=" << psum.X() << " py=" << psum.Y() << " pz=" << psum.Z()
1141 << " |psum|=" << psum.Mag() << std::endl;
1142 }
1143
1144 bus_.set("psum", psum.Mag());
1145 bus_.set("psum_scalar", ele_mom.Mag() + pos_mom.Mag());
1146 bus_.set("epem_opening_angle", ele_mom.Angle(pos_mom));
1147 bus_.set("recoil_theta", calculate_theta_R(ele_mom, pos_mom));
1148
1149 Track thirdTrack = createInferredTrack(&vtx, &ele_trk, &pos_trk);
1150
1151 // calculate target projection and its significance
1152 if (not v0proj_fits_.empty()) {
1153 double vtx_proj_x{-1.0}, vtx_proj_y{-1.0};
1154 double vtx_proj_x_sig{-1.0}, vtx_proj_y_sig{-1.0};
1155 double vtx_proj_x_centered{-999.0}, vtx_proj_y_centered{-999.0};
1156 double vtx_proj_sig{-1.0};
1157
1158 TVector3 vtx_p = vtx.getP();
1159 vtx_proj_sig = utils::v0_projection_to_target_significance(v0proj_fits_, eh.getRunNumber(), vtx_proj_x,
1160 vtx_proj_y, vtx_proj_x_sig, vtx_proj_y_sig,
1161 vtx_proj_x_centered, vtx_proj_y_centered,
1162 vtx.getX(), vtx.getY(), vtx.getZ(),
1163 vtx_p.X(), vtx_p.Y(), vtx_p.Z(),
1164 debug_);
1165
1166 //utils::debug_target_projection(-1.1, &vtx);
1167
1168 bus_.set("vtx_proj_sig", vtx_proj_sig);
1169 bus_.set("vtx_proj_x", vtx_proj_x);
1170 bus_.set("vtx_proj_x_sig", vtx_proj_x_sig);
1171 bus_.set("vtx_proj_y", vtx_proj_y);
1172 bus_.set("vtx_proj_y_sig", vtx_proj_y_sig);
1173 bus_.set("vtx_proj_x_centered", vtx_proj_x_centered);
1174 bus_.set("vtx_proj_y_centered", vtx_proj_y_centered);
1175
1176 double vtx_proj_x_lcio{-1.0}, vtx_proj_y_lcio{-1.0};
1177 double vtx_proj_x_sig_lcio{-1.0}, vtx_proj_y_sig_lcio{-1.0};
1178 double vtx_proj_x_err_lcio{-1.0}, vtx_proj_y_err_lcio{-1.0};
1179 double vtx_proj_x_centered_lcio{-999.0}, vtx_proj_y_centered_lcio{-999.0};
1180 double vtx_proj_sig_lcio = utils::v0_projection_to_target_significance(
1181 v0proj_fits_, eh.getRunNumber(),
1182 vtx_proj_x_lcio, vtx_proj_y_lcio,
1183 vtx_proj_x_sig_lcio, vtx_proj_y_sig_lcio,
1184 &vtx, vtx_proj_x_err_lcio, vtx_proj_y_err_lcio,
1185 vtx_proj_x_centered_lcio, vtx_proj_y_centered_lcio, debug_);
1186
1187 bus_.set("vtx_proj_sig_lcio", vtx_proj_sig_lcio);
1188 bus_.set("vtx_proj_x_lcio", vtx_proj_x_lcio);
1189 bus_.set("vtx_proj_x_sig_lcio", vtx_proj_x_sig_lcio);
1190 bus_.set("vtx_proj_y_lcio", vtx_proj_y_lcio);
1191 bus_.set("vtx_proj_y_sig_lcio", vtx_proj_y_sig_lcio);
1192 bus_.set("vtx_proj_x_err_lcio", vtx_proj_x_err_lcio);
1193 bus_.set("vtx_proj_y_err_lcio", vtx_proj_y_err_lcio);
1194 bus_.set("vtx_proj_x_centered_lcio", vtx_proj_x_centered_lcio);
1195 bus_.set("vtx_proj_y_centered_lcio", vtx_proj_y_centered_lcio);
1196 }
1197
1198 // vertical impact parameters
1199 double min_y0{9999.0}, max_y0err{-1.0}, min_y0err{-1.0};
1200
1201 if (fabs(ele_trk.getZ0()) < fabs(pos_trk.getZ0())) {
1202 min_y0 = ele_trk.getZ0();
1203 } else {
1204 min_y0 = pos_trk.getZ0();
1205 }
1206 min_y0 = fabs(min_y0);
1207
1208 max_y0err = std::max(ele_trk.getZ0Err(), pos_trk.getZ0Err());
1209 min_y0err = std::min(ele_trk.getZ0Err(), pos_trk.getZ0Err());
1210
1211 // min z0 distance to vertex y directly
1212 double vtx_y = vtx.getY();
1213 double min_y0_vtx = std::min(fabs(ele_trk.getZ0() - vtx_y), fabs(pos_trk.getZ0() - vtx_y));
1214
1215 // min z0 distance to vertex y projected back to z=0 along vertex momentum
1216 // solve z(t)=0: t = -vtx_z / vtx_pz, then y_proj = vtx_y + py*t
1217 TVector3 vtx_mom = vtx.getP();
1218 double vtx_y_at_zero = (vtx_mom.Z() != 0.0)
1219 ? vtx_y - (vtx_mom.Y() / vtx_mom.Z()) * vtx.getZ()
1220 : vtx_y;
1221 double ele_y0_proj = fabs(ele_trk.getZ0() - vtx_y_at_zero);
1222 double pos_y0_proj = fabs(pos_trk.getZ0() - vtx_y_at_zero);
1223 double min_y0_vtx_proj = std::min(ele_y0_proj, pos_y0_proj);
1224 double delta_y0_vtx_proj = ele_y0_proj - pos_y0_proj;
1225
1226 bus_.set("min_y0", min_y0);
1227 bus_.set("max_y0err", max_y0err);
1228 bus_.set("min_y0err", min_y0err);
1229 bus_.set("ele_y0err", ele_trk.getZ0Err());
1230 bus_.set("pos_y0err", pos_trk.getZ0Err());
1231 bus_.set("min_y0_vtx", min_y0_vtx);
1232 bus_.set("min_y0_vtx_proj", min_y0_vtx_proj);
1233 bus_.set("vtx_y_at_zero", vtx_y_at_zero);
1234 bus_.set("delta_y0_vtx_proj", delta_y0_vtx_proj);
1235
1236 // set vertex object and tracks
1237 bus_.set("weight", eh.getWeight());
1238 bus_.set("vertex", vtx);
1239 bus_.set("ele", ele);
1240 bus_.set("pos", pos);
1241 bus_.set("third_track", thirdTrack);
1242
1243 //set multi-track quantities
1244 if (calcMultiTrackVars_ && bus_.has(trkColl_)) {
1245 const auto& all_tracks = bus_.get<std::vector<Track*>>(trkColl_);
1246 calculatePairwiseQuantities(all_tracks, ele, pos);
1247 } else if (saveAllTracks_ && bus_.has(trkColl_)) {
1248 // if we only want to save tracks but not calculate pairwise quantities
1249 const auto& all_tracks = bus_.get<std::vector<Track*>>(trkColl_);
1250 std::vector<Track> all_good_tracks;
1251
1252 for (auto* trk : all_tracks) {
1253 if (isQualityTrack(trk, pos)) {
1254 all_good_tracks.push_back(*trk);
1255 }
1256 }
1257
1258 bus_.set("all_preselected_tracks", all_good_tracks);
1259 }
1260
1261
1271 bus_.set("ele_truth_p", TVector3(0., 0., 0.));
1272 bus_.set("pos_truth_p", TVector3(0., 0., 0.));
1273 if (bus_.has(mcColl_)) {
1279 std::map<int, int> count_per_particle_id;
1280 for (const auto& [layer_id, particle_id] : ele_trk.getMcpHits()) {
1281 if (count_per_particle_id.find(particle_id) == count_per_particle_id.end()) {
1282 count_per_particle_id[particle_id] = 0;
1283 }
1284 count_per_particle_id[particle_id]++;
1285 }
1286 int truth_ele_id{-1}, max_nhits{0};
1287 for (const auto& [particle_id, count] : count_per_particle_id) {
1288 if (count > max_nhits) {
1289 truth_ele_id = particle_id;
1290 max_nhits = count;
1291 }
1292 }
1303 const auto& mc_ptr{bus_.get<std::vector<MCParticle*>>(mcColl_)};
1304 MCParticle* vd{nullptr};
1305 MCParticle* ap{nullptr};
1306 ROOT::Math::PxPyPzEVector trueEleP;
1307 ROOT::Math::PxPyPzEVector truePosP;
1308
1309 int n_vd{0};
1310 int n_ap{0};
1311 bool ele_is_rad_ele{false};
1312 for (MCParticle* ptr : mc_ptr) {
1313 std::vector<double> lP = ptr->getMomentum();
1314 if (isSimpSignal_) {
1315 if (ptr->getPDG() == 625) {
1316 n_vd++;
1317 vd = ptr;
1318 } else if (ptr->getID() == truth_ele_id) {
1319 ele_is_rad_ele = (ptr->getMomPDG() == 625);
1320 trueEleP = ROOT::Math::PxPyPzEVector(lP.at(0), lP.at(1), lP.at(2), ptr->getEnergy());
1321 } else if (ptr->getPDG() == -11 && ptr->getMomPDG() == 625) {
1322 truePosP = ROOT::Math::PxPyPzEVector(lP.at(0), lP.at(1), lP.at(2), ptr->getEnergy());
1323 }
1324 } else if (isApSignal_) {
1325 if (ptr->getPDG() == apPDG_) {
1326 n_ap++;
1327 ap = ptr;
1328 } else if (ptr->getID() == truth_ele_id) {
1329 ele_is_rad_ele = (ptr->getMomPDG() == apPDG_);
1330 trueEleP = ROOT::Math::PxPyPzEVector(lP.at(0), lP.at(1), lP.at(2), ptr->getEnergy());
1331 } else if (ptr->getPDG() == -11 && ptr->getMomPDG() == apPDG_) {
1332 truePosP = ROOT::Math::PxPyPzEVector(lP.at(0), lP.at(1), lP.at(2), ptr->getEnergy());
1333 }
1334 } else {
1335 if (ptr->getID() == truth_ele_id) {
1336 ele_is_rad_ele = (ptr->getMomPDG() == 623);
1337 }
1338 if (ptr->getPDG() == 11 && ptr->getMomPDG() == 623) {
1339 trueEleP = ROOT::Math::PxPyPzEVector(lP.at(0), lP.at(1), lP.at(2), ptr->getEnergy());
1340 } else if (ptr->getPDG() == -11 && ptr->getMomPDG() == 623) {
1341 truePosP = ROOT::Math::PxPyPzEVector(lP.at(0), lP.at(1), lP.at(2), ptr->getEnergy());
1342 }
1343 }
1344 }
1345
1346 if (debug_) {
1347 std::cout << "[AP debug] MCParticle PDGs in event (run=" << run_number << "):" << std::endl;
1348 for (MCParticle* ptr : mc_ptr) {
1349 std::cout << " PDG=" << ptr->getPDG()
1350 << " momPDG=" << ptr->getMomPDG()
1351 << " id=" << ptr->getID()
1352 << " p=" << ptr->getMomentum()[2] << std::endl;
1353 }
1354 std::cout << "[AP debug] searching for apPDG=" << apPDG_ << " n_ap=" << n_ap << " ap=" << (ap ? "found" : "null") << std::endl;
1355 }
1356
1357 bus_.set("ele_truth_p", TVector3(trueEleP.Px(), trueEleP.Py(), trueEleP.Pz()));
1358 bus_.set("pos_truth_p", TVector3(truePosP.Px(), truePosP.Py(), truePosP.Pz()));
1359
1366 bus_.set("ele_has_truth_link", utils::hasTruthMatch(ele_trk, &mc_ptr, debug_));
1367 bus_.set("pos_has_truth_link", utils::hasTruthMatch(pos_trk, &mc_ptr, debug_));
1368
1369 if (isSimpSignal_) {
1370 event_cf_.apply("at_least_one_true_vd", n_vd > 0);
1371 event_cf_.apply("no_extra_true_vd", n_vd < 2);
1372 if (not event_cf_.keep()) {
1373 return true;
1374 }
1375 if (not vd) {
1376 throw std::runtime_error("ERROR: Logic error: checked for VD earlier but there isn't one.");
1377 }
1378 bus_.set("true_vd", *vd);
1379
1380 std::vector<double> vdMom = vd->getMomentum();
1381 double vd_p = std::sqrt(vdMom[0]*vdMom[0] + vdMom[1]*vdMom[1] + vdMom[2]*vdMom[2]);
1382 bus_.set("true_vd_betagamma", vd_p / vd->getMass());
1383
1384 } else if (isApSignal_) {
1385 event_cf_.apply("at_least_one_true_ap", n_ap > 0);
1386 event_cf_.apply("no_extra_true_ap", n_ap < 2);
1387 if (not event_cf_.keep()) {
1388 return true;
1389 }
1390 if (not ap) {
1391 throw std::runtime_error("ERROR: Logic error: checked for AP earlier but there isn't one.");
1392 }
1393 bus_.set("true_ap", *ap);
1394
1395 // Compute lab-frame decay distance and Lorentz boost for lifetime reweighting
1396 std::vector<double> vtxPos = ap->getVertexPosition();
1397 std::vector<double> endPos = ap->getEndPoint();
1398 double dx = endPos[0] - vtxPos[0];
1399 double dy = endPos[1] - vtxPos[1];
1400 double dz = endPos[2] - vtxPos[2];
1401 bus_.set("true_decay_len", std::sqrt(dx*dx + dy*dy + dz*dz));
1402
1403 std::vector<double> apMom = ap->getMomentum();
1404 double ap_p = std::sqrt(apMom[0]*apMom[0] + apMom[1]*apMom[1] + apMom[2]*apMom[2]);
1405 bus_.set("true_ap_betagamma", ap_p / ap->getMass());
1406 }
1407 if (trueEleP.P() > 0 and truePosP.P() > 0) {
1408 bus_.set("true_vertex_invM", (trueEleP + truePosP).M());
1409 bus_.set("true_vertex_psum", trueEleP.P() + truePosP.P());
1410 }
1411
1412 bus_.set("isRadEle", ele_is_rad_ele);
1413 }
1414 output_tree_->Fill();
1415 return true;
1416}
1417
1419 outF_->cd();
1420 output_tree_->Write();
1421 n_vertices_h_->Write();
1422 multivtx_chosen_chi2_h_->Write();
1424 vertex_cf_.save();
1425 event_cf_.save();
1426 outF_->Close();
1427}
1428
#define DECLARE_PROCESSOR(CLASS)
Macro which allows the framework to construct a producer given its name during configuration.
Definition Processor.h:139
double getEnergy() const
Definition CalCluster.h:73
void setTime(const double time)
Definition CalCluster.h:80
double getTime() const
Definition CalCluster.h:83
int getRunNumber() const
Definition EventHeader.h:69
Definition IEvent.h:7
description
Track getTrack() const
Definition Particle.h:48
CalCluster getCluster() const
Definition Particle.h:62
void setTrack(Track *track)
Definition Particle.h:42
void setCluster(CalCluster *cluster)
Definition Particle.h:56
double calculate_theta_R(const TVector3 &ele_mom, const TVector3 &pos_mom) const
std::unique_ptr< TH1F > multivtx_discarded_chi2_h_
std::shared_ptr< TrackCorrector > corrector_
virtual void setFile(TFile *out_file) final
Set output TFile for AnaProcessors.
void calculatePairwiseQuantities(const std::vector< Track * > &all_tracks, Particle &ele, Particle &pos)
virtual void initialize(TTree *tree) final
Callback for the Processor to take any necessary action when the processing of events starts,...
virtual void finalize() final
Callback for the Processor to take any necessary action when the processing of events finishes,...
bool isQualityTrack(Track *trk, const Particle &pos) const
virtual void configure(const ParameterSet &parameters) final
Callback for the Processor to configure itself from the given set of parameters.
Track createInferredTrack(Vertex *vtx, Track *ele_track, Track *pos_track)
std::unique_ptr< TH1F > multivtx_chosen_chi2_h_
std::vector< double > determine_time_cuts(bool isData, int runNumber)
virtual void setVtxColl(std::string vtx_coll)
json preselect_json_load(const std::string &filepath)
std::string mcColl_
description
std::unique_ptr< TH2F > n_vertices_h_
std::shared_ptr< AnaHelpers > _ah
description
std::map< int, std::vector< double > > beamspot_corrections_
std::unique_ptr< TTree > output_tree_
TFile * outF_
Definition Processor.h:125
virtual bool process()
Process the histograms and generate analysis output.
Definition Processor.h:95
virtual void setFile(TFile *outFile)
Set output TFile for AnaProcessors.
Definition Processor.h:88
static void correctVertex(Vertex *vtx, double r1, double r2)
Definition Track.h:32
bool isKalmanTrack() const
Definition Track.h:233
void setTrackParameters(const double d0, const double phi0, const double omega, const double tan_lambda, const double z0)
Definition Track.cxx:31
double getChi2Ndf() const
Definition Track.h:128
int getTrackerHitCount() const
Definition Track.h:347
double getOmega() const
Definition Track.h:90
double getTrackTime() const
Definition Track.h:162
std::vector< double > getPositionAtEcal()
Definition Track.cxx:53
int getCharge() const
Definition Track.h:249
int getID() const
Definition Track.h:264
double getTanLambda() const
Definition Track.h:92
double getIsolation(const int layer) const
Definition Track.h:151
std::vector< double > getMomentum()
Definition Track.h:287
void setCov(const std::vector< float > &cov)
Definition Track.h:97
std::vector< std::pair< int, int > > getMcpHits()
Definition Track.h:105
double getZ0() const
Definition Track.h:93
double getP() const
Definition Track.h:293
double getZ0Err() const
Definition Track.h:111
void setMomentum(double bfield=0.52)
Definition Track.cxx:63
std::vector< float > calculateTrackParameters(float x_vtx, float y_vtx, float z_vtx, float px, float py, float pz, float Q, float cB, float targetPos)
Calculate track parameters at target from position and momentum.
TMatrixD getVertexCovariance(Vertex *vtx)
Extract vertex position covariance from Vertex object.
TMatrixD calculateTrackCovariance(float x_vtx, float y_vtx, float z_vtx, float px, float py, float pz, const TMatrixD &covVertex, const TMatrixD &covMomentum, float Q, float cB, float targetPos)
Calculate track parameter covariance from momentum, position.
TMatrixD momentumCovarianceFromTrack(double px, double py, double pz, double phi0, double omega, double tanLambda, const TMatrixD &covTrack)
Calculate momentum covariance from track parameter covariance.
bool hasTruthMatch(Track &trk, const std::vector< MCParticle * > *mcParticles, bool debug=false)
Check if a track has a truth-matched electron/positron.
double v0_projection_to_target_significance(json v0proj_fits, int run, double &vtx_proj_x, double &vtx_proj_y, double &vtx_proj_x_signif, double &vtx_proj_y_signif, double &vtx_proj_x_centered, double &vtx_proj_y_centered, double vtx_x, double vtx_y, double vtx_z, double vtx_px, double vtx_py, double vtx_pz, bool debug=false)
description
bool doSmearing
MC Gaussian smearing on/off for this job.
int requireTruthMatch
-1: use the JSON value; 0/1: override it