Fork me on GitHub

source: git/modules/TreeWriter.cc@ 00e8dca

ImprovedOutputFile Timing dual_readout llp
Last change on this file since 00e8dca was 839deb7, checked in by Pavel Demin <pavel.demin@…>, 9 years ago

fix variable names and formatting

  • Property mode set to 100644
File size: 20.9 KB
Line 
1/*
2 * Delphes: a framework for fast simulation of a generic collider experiment
3 * Copyright (C) 2012-2014 Universite catholique de Louvain (UCL), Belgium
4 *
5 * This program is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation, either version 3 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
17 */
18
19
20/** \class TreeWriter
21 *
22 * Fills ROOT tree branches.
23 *
24 * \author P. Demin - UCL, Louvain-la-Neuve
25 *
26 */
27
28#include "modules/TreeWriter.h"
29
30#include "classes/DelphesClasses.h"
31#include "classes/DelphesFactory.h"
32#include "classes/DelphesFormula.h"
33
34#include "ExRootAnalysis/ExRootResult.h"
35#include "ExRootAnalysis/ExRootFilter.h"
36#include "ExRootAnalysis/ExRootClassifier.h"
37#include "ExRootAnalysis/ExRootTreeBranch.h"
38
39#include "TROOT.h"
40#include "TMath.h"
41#include "TString.h"
42#include "TFormula.h"
43#include "TRandom3.h"
44#include "TObjArray.h"
45#include "TDatabasePDG.h"
46#include "TLorentzVector.h"
47
48#include <algorithm>
49#include <stdexcept>
50#include <iostream>
51#include <sstream>
52
53using namespace std;
54
55//------------------------------------------------------------------------------
56
57TreeWriter::TreeWriter()
58{
59}
60
61//------------------------------------------------------------------------------
62
63TreeWriter::~TreeWriter()
64{
65}
66
67//------------------------------------------------------------------------------
68
69void TreeWriter::Init()
70{
71 fClassMap[GenParticle::Class()] = &TreeWriter::ProcessParticles;
72 fClassMap[Vertex::Class()] = &TreeWriter::ProcessVertices;
73 fClassMap[Track::Class()] = &TreeWriter::ProcessTracks;
74 fClassMap[Tower::Class()] = &TreeWriter::ProcessTowers;
75 fClassMap[Photon::Class()] = &TreeWriter::ProcessPhotons;
76 fClassMap[Electron::Class()] = &TreeWriter::ProcessElectrons;
77 fClassMap[Muon::Class()] = &TreeWriter::ProcessMuons;
78 fClassMap[Jet::Class()] = &TreeWriter::ProcessJets;
79 fClassMap[MissingET::Class()] = &TreeWriter::ProcessMissingET;
80 fClassMap[ScalarHT::Class()] = &TreeWriter::ProcessScalarHT;
81 fClassMap[Rho::Class()] = &TreeWriter::ProcessRho;
82 fClassMap[Weight::Class()] = &TreeWriter::ProcessWeight;
83 fClassMap[HectorHit::Class()] = &TreeWriter::ProcessHectorHit;
84
85 TBranchMap::iterator itBranchMap;
86 map< TClass *, TProcessMethod >::iterator itClassMap;
87
88 // read branch configuration and
89 // import array with output from filter/classifier/jetfinder modules
90
91 ExRootConfParam param = GetParam("Branch");
92 Long_t i, size;
93 TString branchName, branchClassName, branchInputArray;
94 TClass *branchClass;
95 TObjArray *array;
96 ExRootTreeBranch *branch;
97
98 size = param.GetSize();
99 for(i = 0; i < size/3; ++i)
100 {
101 branchInputArray = param[i*3].GetString();
102 branchName = param[i*3 + 1].GetString();
103 branchClassName = param[i*3 + 2].GetString();
104
105 branchClass = gROOT->GetClass(branchClassName);
106
107 if(!branchClass)
108 {
109 cout << "** ERROR: cannot find class '" << branchClassName << "'" << endl;
110 continue;
111 }
112
113 itClassMap = fClassMap.find(branchClass);
114 if(itClassMap == fClassMap.end())
115 {
116 cout << "** ERROR: cannot create branch for class '" << branchClassName << "'" << endl;
117 continue;
118 }
119
120 array = ImportArray(branchInputArray);
121 branch = NewBranch(branchName, branchClass);
122
123 fBranchMap.insert(make_pair(branch, make_pair(itClassMap->second, array)));
124 }
125
126}
127
128//------------------------------------------------------------------------------
129
130void TreeWriter::Finish()
131{
132}
133
134//------------------------------------------------------------------------------
135
136void TreeWriter::FillParticles(Candidate *candidate, TRefArray *array)
137{
138 TIter it1(candidate->GetCandidates());
139 it1.Reset();
140 array->Clear();
141 while((candidate = static_cast<Candidate*>(it1.Next())))
142 {
143 TIter it2(candidate->GetCandidates());
144
145 // particle
146 if(candidate->GetCandidates()->GetEntriesFast() == 0)
147 {
148 array->Add(candidate);
149 continue;
150 }
151
152 // track
153 candidate = static_cast<Candidate*>(candidate->GetCandidates()->At(0));
154 if(candidate->GetCandidates()->GetEntriesFast() == 0)
155 {
156 array->Add(candidate);
157 continue;
158 }
159
160 // tower
161 it2.Reset();
162 while((candidate = static_cast<Candidate*>(it2.Next())))
163 {
164 array->Add(candidate->GetCandidates()->At(0));
165 }
166 }
167}
168
169//------------------------------------------------------------------------------
170
171void TreeWriter::ProcessParticles(ExRootTreeBranch *branch, TObjArray *array)
172{
173 TIter iterator(array);
174 Candidate *candidate = 0;
175 GenParticle *entry = 0;
176 Double_t pt, signPz, cosTheta, eta, rapidity;
177
178 const Double_t c_light = 2.99792458E8;
179
180 // loop over all particles
181 iterator.Reset();
182 while((candidate = static_cast<Candidate*>(iterator.Next())))
183 {
184 const TLorentzVector &momentum = candidate->Momentum;
185 const TLorentzVector &position = candidate->Position;
186
187 entry = static_cast<GenParticle*>(branch->NewEntry());
188
189 entry->SetBit(kIsReferenced);
190 entry->SetUniqueID(candidate->GetUniqueID());
191
192 pt = momentum.Pt();
193 cosTheta = TMath::Abs(momentum.CosTheta());
194 signPz = (momentum.Pz() >= 0.0) ? 1.0 : -1.0;
195 eta = (cosTheta == 1.0 ? signPz*999.9 : momentum.Eta());
196 rapidity = (cosTheta == 1.0 ? signPz*999.9 : momentum.Rapidity());
197
198 entry->PID = candidate->PID;
199
200 entry->Status = candidate->Status;
201 entry->IsPU = candidate->IsPU;
202
203 entry->M1 = candidate->M1;
204 entry->M2 = candidate->M2;
205
206 entry->D1 = candidate->D1;
207 entry->D2 = candidate->D2;
208
209 entry->Charge = candidate->Charge;
210 entry->Mass = candidate->Mass;
211
212 entry->E = momentum.E();
213 entry->Px = momentum.Px();
214 entry->Py = momentum.Py();
215 entry->Pz = momentum.Pz();
216
217 entry->Eta = eta;
218 entry->Phi = momentum.Phi();
219 entry->PT = pt;
220
221 entry->Rapidity = rapidity;
222
223 entry->X = position.X();
224 entry->Y = position.Y();
225 entry->Z = position.Z();
226 entry->T = position.T()*1.0E-3/c_light;
227 }
228}
229
230//------------------------------------------------------------------------------
231
232void TreeWriter::ProcessVertices(ExRootTreeBranch *branch, TObjArray *array)
233{
234 TIter iterator(array);
235 Candidate *candidate = 0;
236 Vertex *entry = 0;
237
238 const Double_t c_light = 2.99792458E8;
239
240 // loop over all vertices
241 iterator.Reset();
242 while((candidate = static_cast<Candidate*>(iterator.Next())))
243 {
244 const TLorentzVector &position = candidate->Position;
245
246 entry = static_cast<Vertex*>(branch->NewEntry());
247
248 entry->X = position.X();
249 entry->Y = position.Y();
250 entry->Z = position.Z();
251 entry->T = position.T()*1.0E-3/c_light;
252 }
253}
254
255//------------------------------------------------------------------------------
256
257void TreeWriter::ProcessTracks(ExRootTreeBranch *branch, TObjArray *array)
258{
259 TIter iterator(array);
260 Candidate *candidate = 0;
261 Candidate *particle = 0;
262 Track *entry = 0;
263 Double_t pt, signz, cosTheta, eta, rapidity;
264 const Double_t c_light = 2.99792458E8;
265
266 // loop over all tracks
267 iterator.Reset();
268 while((candidate = static_cast<Candidate*>(iterator.Next())))
269 {
270 const TLorentzVector &position = candidate->Position;
271
272 cosTheta = TMath::Abs(position.CosTheta());
273 signz = (position.Pz() >= 0.0) ? 1.0 : -1.0;
274 eta = (cosTheta == 1.0 ? signz*999.9 : position.Eta());
275 rapidity = (cosTheta == 1.0 ? signz*999.9 : position.Rapidity());
276
277 entry = static_cast<Track*>(branch->NewEntry());
278
279 entry->SetBit(kIsReferenced);
280 entry->SetUniqueID(candidate->GetUniqueID());
281
282 entry->PID = candidate->PID;
283
284 entry->Charge = candidate->Charge;
285
286 entry->EtaOuter = eta;
287 entry->PhiOuter = position.Phi();
288
289 entry->XOuter = position.X();
290 entry->YOuter = position.Y();
291 entry->ZOuter = position.Z();
292 entry->TOuter = position.T()*1.0E-3/c_light;
293
294 entry->Dxy = candidate->Dxy;
295 entry->SDxy = candidate->SDxy ;
296 entry->Xd = candidate->Xd;
297 entry->Yd = candidate->Yd;
298 entry->Zd = candidate->Zd;
299
300 const TLorentzVector &momentum = candidate->Momentum;
301
302 pt = momentum.Pt();
303 cosTheta = TMath::Abs(momentum.CosTheta());
304 signz = (momentum.Pz() >= 0.0) ? 1.0 : -1.0;
305 eta = (cosTheta == 1.0 ? signz*999.9 : momentum.Eta());
306 rapidity = (cosTheta == 1.0 ? signz*999.9 : momentum.Rapidity());
307
308 entry->Eta = eta;
309 entry->Phi = momentum.Phi();
310 entry->PT = pt;
311
312 particle = static_cast<Candidate*>(candidate->GetCandidates()->At(0));
313 const TLorentzVector &initialPosition = particle->Position;
314
315 entry->X = initialPosition.X();
316 entry->Y = initialPosition.Y();
317 entry->Z = initialPosition.Z();
318 entry->T = initialPosition.T()*1.0E-3/c_light;
319
320 entry->Particle = particle;
321 }
322}
323
324//------------------------------------------------------------------------------
325
326void TreeWriter::ProcessTowers(ExRootTreeBranch *branch, TObjArray *array)
327{
328 TIter iterator(array);
329 Candidate *candidate = 0;
330 Tower *entry = 0;
331 Double_t pt, signPz, cosTheta, eta, rapidity;
332 const Double_t c_light = 2.99792458E8;
333
334 // loop over all towers
335 iterator.Reset();
336 while((candidate = static_cast<Candidate*>(iterator.Next())))
337 {
338 const TLorentzVector &momentum = candidate->Momentum;
339 const TLorentzVector &position = candidate->Position;
340
341 pt = momentum.Pt();
342 cosTheta = TMath::Abs(momentum.CosTheta());
343 signPz = (momentum.Pz() >= 0.0) ? 1.0 : -1.0;
344 eta = (cosTheta == 1.0 ? signPz*999.9 : momentum.Eta());
345 rapidity = (cosTheta == 1.0 ? signPz*999.9 : momentum.Rapidity());
346
347 entry = static_cast<Tower*>(branch->NewEntry());
348
349 entry->SetBit(kIsReferenced);
350 entry->SetUniqueID(candidate->GetUniqueID());
351
352 entry->Eta = eta;
353 entry->Phi = momentum.Phi();
354 entry->ET = pt;
355 entry->E = momentum.E();
356 entry->Eem = candidate->Eem;
357 entry->Ehad = candidate->Ehad;
358 entry->Edges[0] = candidate->Edges[0];
359 entry->Edges[1] = candidate->Edges[1];
360 entry->Edges[2] = candidate->Edges[2];
361 entry->Edges[3] = candidate->Edges[3];
362
363 entry->T = position.T()*1.0E-3/c_light;
364 entry->NTimeHits = candidate->NTimeHits;
365
366 FillParticles(candidate, &entry->Particles);
367 }
368}
369
370//------------------------------------------------------------------------------
371
372void TreeWriter::ProcessPhotons(ExRootTreeBranch *branch, TObjArray *array)
373{
374 TIter iterator(array);
375 Candidate *candidate = 0;
376 Photon *entry = 0;
377 Double_t pt, signPz, cosTheta, eta, rapidity;
378 const Double_t c_light = 2.99792458E8;
379
380 array->Sort();
381
382 // loop over all photons
383 iterator.Reset();
384 while((candidate = static_cast<Candidate*>(iterator.Next())))
385 {
386 TIter it1(candidate->GetCandidates());
387 const TLorentzVector &momentum = candidate->Momentum;
388 const TLorentzVector &position = candidate->Position;
389
390
391 pt = momentum.Pt();
392 cosTheta = TMath::Abs(momentum.CosTheta());
393 signPz = (momentum.Pz() >= 0.0) ? 1.0 : -1.0;
394 eta = (cosTheta == 1.0 ? signPz*999.9 : momentum.Eta());
395 rapidity = (cosTheta == 1.0 ? signPz*999.9 : momentum.Rapidity());
396
397 entry = static_cast<Photon*>(branch->NewEntry());
398
399 entry->Eta = eta;
400 entry->Phi = momentum.Phi();
401 entry->PT = pt;
402 entry->E = momentum.E();
403
404 entry->T = position.T()*1.0E-3/c_light;
405
406 // Isolation variables
407
408 entry->IsolationVar = candidate->IsolationVar;
409 entry->IsolationVarRhoCorr = candidate->IsolationVarRhoCorr ;
410 entry->SumPtCharged = candidate->SumPtCharged ;
411 entry->SumPtNeutral = candidate->SumPtNeutral ;
412 entry->SumPtChargedPU = candidate->SumPtChargedPU ;
413 entry->SumPt = candidate->SumPt ;
414
415 entry->EhadOverEem = candidate->Eem > 0.0 ? candidate->Ehad/candidate->Eem : 999.9;
416
417 FillParticles(candidate, &entry->Particles);
418 }
419}
420
421//------------------------------------------------------------------------------
422
423void TreeWriter::ProcessElectrons(ExRootTreeBranch *branch, TObjArray *array)
424{
425 TIter iterator(array);
426 Candidate *candidate = 0;
427 Electron *entry = 0;
428 Double_t pt, signPz, cosTheta, eta, rapidity;
429 const Double_t c_light = 2.99792458E8;
430
431 array->Sort();
432
433 // loop over all electrons
434 iterator.Reset();
435 while((candidate = static_cast<Candidate*>(iterator.Next())))
436 {
437 const TLorentzVector &momentum = candidate->Momentum;
438 const TLorentzVector &position = candidate->Position;
439
440 pt = momentum.Pt();
441 cosTheta = TMath::Abs(momentum.CosTheta());
442 signPz = (momentum.Pz() >= 0.0) ? 1.0 : -1.0;
443 eta = (cosTheta == 1.0 ? signPz*999.9 : momentum.Eta());
444 rapidity = (cosTheta == 1.0 ? signPz*999.9 : momentum.Rapidity());
445
446 entry = static_cast<Electron*>(branch->NewEntry());
447
448 entry->Eta = eta;
449 entry->Phi = momentum.Phi();
450 entry->PT = pt;
451
452 entry->T = position.T()*1.0E-3/c_light;
453
454 // Isolation variables
455
456 entry->IsolationVar = candidate->IsolationVar;
457 entry->IsolationVarRhoCorr = candidate->IsolationVarRhoCorr ;
458 entry->SumPtCharged = candidate->SumPtCharged ;
459 entry->SumPtNeutral = candidate->SumPtNeutral ;
460 entry->SumPtChargedPU = candidate->SumPtChargedPU ;
461 entry->SumPt = candidate->SumPt ;
462
463
464 entry->Charge = candidate->Charge;
465
466 entry->EhadOverEem = 0.0;
467
468 entry->Particle = candidate->GetCandidates()->At(0);
469 }
470}
471
472//------------------------------------------------------------------------------
473
474void TreeWriter::ProcessMuons(ExRootTreeBranch *branch, TObjArray *array)
475{
476 TIter iterator(array);
477 Candidate *candidate = 0;
478 Muon *entry = 0;
479 Double_t pt, signPz, cosTheta, eta, rapidity;
480
481 const Double_t c_light = 2.99792458E8;
482
483 array->Sort();
484
485 // loop over all muons
486 iterator.Reset();
487 while((candidate = static_cast<Candidate*>(iterator.Next())))
488 {
489 const TLorentzVector &momentum = candidate->Momentum;
490 const TLorentzVector &position = candidate->Position;
491
492 pt = momentum.Pt();
493 cosTheta = TMath::Abs(momentum.CosTheta());
494 signPz = (momentum.Pz() >= 0.0) ? 1.0 : -1.0;
495 eta = (cosTheta == 1.0 ? signPz*999.9 : momentum.Eta());
496 rapidity = (cosTheta == 1.0 ? signPz*999.9 : momentum.Rapidity());
497
498 entry = static_cast<Muon*>(branch->NewEntry());
499
500 entry->SetBit(kIsReferenced);
501 entry->SetUniqueID(candidate->GetUniqueID());
502
503 entry->Eta = eta;
504 entry->Phi = momentum.Phi();
505 entry->PT = pt;
506
507 entry->T = position.T()*1.0E-3/c_light;
508
509 // Isolation variables
510
511 entry->IsolationVar = candidate->IsolationVar;
512 entry->IsolationVarRhoCorr = candidate->IsolationVarRhoCorr ;
513 entry->SumPtCharged = candidate->SumPtCharged ;
514 entry->SumPtNeutral = candidate->SumPtNeutral ;
515 entry->SumPtChargedPU = candidate->SumPtChargedPU ;
516 entry->SumPt = candidate->SumPt ;
517
518 entry->Charge = candidate->Charge;
519
520 entry->Particle = candidate->GetCandidates()->At(0);
521 }
522}
523
524//------------------------------------------------------------------------------
525
526void TreeWriter::ProcessJets(ExRootTreeBranch *branch, TObjArray *array)
527{
528 TIter iterator(array);
529 Candidate *candidate = 0, *constituent = 0;
530 Jet *entry = 0;
531 Double_t pt, signPz, cosTheta, eta, rapidity;
532 Double_t ecalEnergy, hcalEnergy;
533 const Double_t c_light = 2.99792458E8;
534 Int_t i;
535
536 array->Sort();
537
538 // loop over all jets
539 iterator.Reset();
540 while((candidate = static_cast<Candidate*>(iterator.Next())))
541 {
542 TIter itConstituents(candidate->GetCandidates());
543
544 const TLorentzVector &momentum = candidate->Momentum;
545 const TLorentzVector &position = candidate->Position;
546
547 pt = momentum.Pt();
548 cosTheta = TMath::Abs(momentum.CosTheta());
549 signPz = (momentum.Pz() >= 0.0) ? 1.0 : -1.0;
550 eta = (cosTheta == 1.0 ? signPz*999.9 : momentum.Eta());
551 rapidity = (cosTheta == 1.0 ? signPz*999.9 : momentum.Rapidity());
552
553 entry = static_cast<Jet*>(branch->NewEntry());
554
555 entry->Eta = eta;
556 entry->Phi = momentum.Phi();
557 entry->PT = pt;
558
559 entry->T = position.T()*1.0E-3/c_light;
560
561 entry->Mass = momentum.M();
562
563 entry->Area = candidate->Area;
564
565 entry->DeltaEta = candidate->DeltaEta;
566 entry->DeltaPhi = candidate->DeltaPhi;
567
568 entry->Flavor = candidate->Flavor;
569 entry->FlavorAlgo = candidate->FlavorAlgo;
570 entry->FlavorPhys = candidate->FlavorPhys;
571
572 entry->BTag = candidate->BTag;
573
574 entry->BTagAlgo = candidate->BTagAlgo;
575 entry->BTagPhys = candidate->BTagPhys;
576
577 entry->TauTag = candidate->TauTag;
578
579 entry->Charge = candidate->Charge;
580
581 itConstituents.Reset();
582 entry->Constituents.Clear();
583 ecalEnergy = 0.0;
584 hcalEnergy = 0.0;
585 while((constituent = static_cast<Candidate*>(itConstituents.Next())))
586 {
587 entry->Constituents.Add(constituent);
588 ecalEnergy += constituent->Eem;
589 hcalEnergy += constituent->Ehad;
590 }
591
592 entry->EhadOverEem = ecalEnergy > 0.0 ? hcalEnergy/ecalEnergy : 999.9;
593
594 //--- Pile-Up Jet ID variables ----
595
596 entry->NCharged = candidate->NCharged;
597 entry->NNeutrals = candidate->NNeutrals;
598 entry->Beta = candidate->Beta;
599 entry->BetaStar = candidate->BetaStar;
600 entry->MeanSqDeltaR = candidate->MeanSqDeltaR;
601 entry->PTD = candidate->PTD;
602
603 //--- Sub-structure variables ----
604
605 entry->NSubJetsTrimmed = candidate->NSubJetsTrimmed;
606 entry->NSubJetsPruned = candidate->NSubJetsPruned;
607 entry->NSubJetsSoftDropped = candidate->NSubJetsSoftDropped;
608
609 for(i = 0; i < 5; i++)
610 {
611 entry->FracPt[i] = candidate -> FracPt[i];
612 entry->Tau[i] = candidate -> Tau[i];
613 entry->TrimmedP4[i] = candidate -> TrimmedP4[i];
614 entry->PrunedP4[i] = candidate -> PrunedP4[i];
615 entry->SoftDroppedP4[i] = candidate -> SoftDroppedP4[i];
616 }
617
618 FillParticles(candidate, &entry->Particles);
619 }
620}
621
622//------------------------------------------------------------------------------
623
624void TreeWriter::ProcessMissingET(ExRootTreeBranch *branch, TObjArray *array)
625{
626 Candidate *candidate = 0;
627 MissingET *entry = 0;
628
629 // get the first entry
630 if((candidate = static_cast<Candidate*>(array->At(0))))
631 {
632 const TLorentzVector &momentum = candidate->Momentum;
633
634 entry = static_cast<MissingET*>(branch->NewEntry());
635
636 entry->Eta = (-momentum).Eta();
637 entry->Phi = (-momentum).Phi();
638 entry->MET = momentum.Pt();
639 }
640}
641
642//------------------------------------------------------------------------------
643
644void TreeWriter::ProcessScalarHT(ExRootTreeBranch *branch, TObjArray *array)
645{
646 Candidate *candidate = 0;
647 ScalarHT *entry = 0;
648
649 // get the first entry
650 if((candidate = static_cast<Candidate*>(array->At(0))))
651 {
652 const TLorentzVector &momentum = candidate->Momentum;
653
654 entry = static_cast<ScalarHT*>(branch->NewEntry());
655
656 entry->HT = momentum.Pt();
657 }
658}
659
660//------------------------------------------------------------------------------
661
662void TreeWriter::ProcessRho(ExRootTreeBranch *branch, TObjArray *array)
663{
664 TIter iterator(array);
665 Candidate *candidate = 0;
666 Rho *entry = 0;
667
668 // loop over all rho
669 iterator.Reset();
670 while((candidate = static_cast<Candidate*>(iterator.Next())))
671 {
672 const TLorentzVector &momentum = candidate->Momentum;
673
674 entry = static_cast<Rho*>(branch->NewEntry());
675
676 entry->Rho = momentum.E();
677 entry->Edges[0] = candidate->Edges[0];
678 entry->Edges[1] = candidate->Edges[1];
679 }
680}
681
682//------------------------------------------------------------------------------
683
684void TreeWriter::ProcessWeight(ExRootTreeBranch *branch, TObjArray *array)
685{
686 Candidate *candidate = 0;
687 Weight *entry = 0;
688
689 // get the first entry
690 if((candidate = static_cast<Candidate*>(array->At(0))))
691 {
692 const TLorentzVector &momentum = candidate->Momentum;
693
694 entry = static_cast<Weight*>(branch->NewEntry());
695
696 entry->Weight = momentum.E();
697 }
698}
699
700//------------------------------------------------------------------------------
701
702void TreeWriter::ProcessHectorHit(ExRootTreeBranch *branch, TObjArray *array)
703{
704 TIter iterator(array);
705 Candidate *candidate = 0;
706 HectorHit *entry = 0;
707
708 // loop over all roman pot hits
709 iterator.Reset();
710 while((candidate = static_cast<Candidate*>(iterator.Next())))
711 {
712 const TLorentzVector &position = candidate->Position;
713 const TLorentzVector &momentum = candidate->Momentum;
714
715 entry = static_cast<HectorHit*>(branch->NewEntry());
716
717 entry->E = momentum.E();
718
719 entry->Tx = momentum.Px();
720 entry->Ty = momentum.Py();
721
722 entry->T = position.T();
723
724 entry->X = position.X();
725 entry->Y = position.Y();
726 entry->S = position.Z();
727
728 entry->Particle = candidate->GetCandidates()->At(0);
729 }
730}
731
732//------------------------------------------------------------------------------
733
734void TreeWriter::Process()
735{
736 TBranchMap::iterator itBranchMap;
737 ExRootTreeBranch *branch;
738 TProcessMethod method;
739 TObjArray *array;
740
741 for(itBranchMap = fBranchMap.begin(); itBranchMap != fBranchMap.end(); ++itBranchMap)
742 {
743 branch = itBranchMap->first;
744 method = itBranchMap->second.first;
745 array = itBranchMap->second.second;
746
747 (this->*method)(branch, array);
748 }
749}
750
751//------------------------------------------------------------------------------
Note: See TracBrowser for help on using the repository browser.