BmnRoot 26.10.0-18-g4e3414f9
Software framework of the BM@N experiment
Loading...
Searching...
No Matches
BmnDigiMergeTask.cxx
Go to the documentation of this file.
1#include "BmnDigiMergeTask.h"
2
3// RUN-6
4
5BmnDigiMergeTask::BmnDigiMergeTask(TString in1, TString in2, TString in3)
6 : isRun6(kTRUE)
7 , isRun7(kFALSE)
8 , isSrc(kFALSE)
9 , fOutFile(nullptr)
10 , fOutTree(nullptr)
11 , fIn1(nullptr)
12 , fIn2(nullptr)
13 , fIn3(nullptr)
14 , fHeaderOut(nullptr)
15 , fGem(nullptr)
16 , fSil(nullptr)
17 , fZdc(nullptr)
18 , fT0(nullptr)
19 , fBC1(nullptr)
20 , fBC2(nullptr)
21 , fVeto(nullptr)
22 , fFd(nullptr)
23 , fBd(nullptr)
24 , fMwpc(nullptr)
25 , fDch(nullptr)
26 , fTof400(nullptr)
27 , fTof700(nullptr)
28 , fEcal(nullptr)
29 , fHeader1(nullptr)
30 , fHeader2(nullptr)
31 , fHeader3(nullptr)
32 , fGemDigits(nullptr)
33 , fSilDigits(nullptr)
34 , fZdcDigits(nullptr)
35 , fT0Digits(nullptr)
36 , fBC1Digits(nullptr)
37 , fBC2Digits(nullptr)
38 , fVetoDigits(nullptr)
39 , fFdDigits(nullptr)
40 , fBdDigits(nullptr)
41 , fMwpcDigits(nullptr)
42 , fDchDigits(nullptr)
43 , fTof400Digits(nullptr)
44 , fTof700Digits(nullptr)
45 , fEcalDigits(nullptr)
46 , fCont(nullptr)
47{
48 fIn1 = new TChain("BMN_DIGIT");
49 fIn2 = new TChain("cbmsim");
50 fIn3 = new TChain("cbmsim");
51
52 // Event headers
53 TString brName = "EventHeader";
54
55 // Detector branches
56 if (!in1.IsNull()) {
57 fIn1->Add(in1.Data());
58 fIn1->SetBranchAddress("STRIPGEM", &fGemDigits);
59 fIn1->SetBranchAddress("MYSILICON", &fSilDigits);
60 fIn1->SetBranchAddress(brName.Data(), &fHeader1);
61 }
62
63 if (!in2.IsNull()) {
64 fIn2->Add(in2.Data());
65 fIn2->SetBranchAddress("ZDC", &fZdcDigits);
66 fIn2->SetBranchAddress(brName.Data(), &fHeader2);
67 }
68
69 if (!in3.IsNull()) {
70 fIn3->Add(in3.Data());
71 fIn3->SetBranchAddress("T0", &fT0Digits);
72 fIn3->SetBranchAddress("BC1", &fBC1Digits);
73 fIn3->SetBranchAddress("BC2", &fBC2Digits);
74 fIn3->SetBranchAddress("VETO", &fVetoDigits);
75 fIn3->SetBranchAddress("FD", &fFdDigits);
76 fIn3->SetBranchAddress("BD", &fBdDigits);
77 fIn3->SetBranchAddress("MWPC", &fMwpcDigits);
78 fIn3->SetBranchAddress("DCH", &fDchDigits);
79 fIn3->SetBranchAddress("TOF400", &fTof400Digits);
80 fIn3->SetBranchAddress("TOF700", &fTof700Digits);
81 fIn3->SetBranchAddress("ECAL", &fEcalDigits);
82 fIn3->SetBranchAddress(brName.Data(), &fHeader3);
83 }
84 CreateOutputFiles();
85 CreateGeometries();
86}
87
88// RUN-7
89
90BmnDigiMergeTask::BmnDigiMergeTask(TString* in)
91 : isRun6(kFALSE)
92 , isRun7(kTRUE)
93 , isSrc(kFALSE)
94 , fIn1(nullptr)
95 , fIn2(nullptr)
96 , fIn3(nullptr)
97 , fHeader1(nullptr)
98 , fHeader2(nullptr)
99 , fHeader3Obj(nullptr)
100 , fGemDigits(nullptr)
101 , fSilDigits(nullptr)
102 , fBC1Digits(nullptr)
103 , fBC2Digits(nullptr)
104 , fBC3Digits(nullptr)
105 , fVetoDigits(nullptr)
106 , fSiDigits(nullptr)
107 , fBdDigits(nullptr)
108 , fMwpcDigits(nullptr)
109 , fDchDigits(nullptr)
110 , fTof400Digits(nullptr)
111 , fTof700Digits(nullptr)
112 , fEcalDigits(nullptr)
113 , fZdcDigits(nullptr)
114 , fOutFile(nullptr)
115 , fOutTree(nullptr)
116 , fOutFiles(nullptr)
117 , fOutTrees(nullptr)
118 , fGem(nullptr)
119 , fCsc(nullptr)
120 , fSil(nullptr)
121 , fZdc(nullptr)
122 , fT0(nullptr)
123 , fBC1(nullptr)
124 , fBC2(nullptr)
125 , fBC3(nullptr)
126 , fSi(nullptr)
127 , fVeto(nullptr)
128 , fFd(nullptr)
129 , fBd(nullptr)
130 , fMwpc(nullptr)
131 , fDch(nullptr)
132 , fTof400(nullptr)
133 , fTof700(nullptr)
134 , fEcal(nullptr)
135 , fHeaderOut(nullptr)
136{
137 fIn1 = new TChain("BMN_DIGIT");
138 fIn2 = new TChain("cbmsim");
139 fIn3 = new TChain("bmndata");
140
141 TString brName = "EventHeader";
142
143 // Detector branches
144 if (!in[0].IsNull()) {
145 fIn1->Add(in[0].Data());
146 fIn1->SetBranchAddress("STRIPGEM", &fGemDigits);
147 fIn1->SetBranchAddress("MYSILICON", &fSilDigits);
148 fIn1->SetBranchAddress("MWPC", &fMwpcDigits);
149 fIn1->SetBranchAddress("DCH", &fDchDigits);
150 fIn1->SetBranchAddress("TOF400", &fTof400Digits);
151 fIn1->SetBranchAddress("ECAL", &fEcalDigits);
152 fIn1->SetBranchAddress(brName.Data(), &fHeader1);
153 }
154
155 if (!in[1].IsNull()) {
156 fIn2->Add(in[1].Data());
157 fIn2->SetBranchAddress("BC1", &fBC1Digits);
158 fIn2->SetBranchAddress("BC2", &fBC2Digits);
159 fIn2->SetBranchAddress("BC3", &fBC3Digits);
160 fIn2->SetBranchAddress("VC", &fVetoDigits);
161 fIn2->SetBranchAddress("Si", &fSiDigits);
162 fIn2->SetBranchAddress("BD", &fBdDigits);
163 fIn2->SetBranchAddress("ZDC", &fZdcDigits);
164 fIn2->SetBranchAddress(brName.Data(), &fHeader2);
165 }
166
167 if (!in[2].IsNull()) {
168 fIn3->Add(in[2].Data());
169 fIn3->SetBranchAddress("TOF700", &fTof700Digits);
170 fIn3->SetBranchAddress(brName.Data(), &fHeader3Obj);
171 }
172
173 CreateOutputFiles();
174 CreateGeometries();
175}
176
177BmnDigiMergeTask::BmnDigiMergeTask(vector<TString> files)
178 : isRun6(kFALSE)
179 , isRun7(kTRUE)
180 , isSrc(kTRUE)
181 , fIn1(nullptr)
182 , fIn2(nullptr)
183 , fIn3(nullptr)
184 ,
185
186 // in1
187 fGemDigits(nullptr)
188 , fSilDigits(nullptr)
189 ,
190
191 // in2
192 fBC1Digits(nullptr)
193 , fBC2Digits(nullptr)
194 , fBC3Digits(nullptr)
195 , fBC4Digits(nullptr)
196 , fBC1TQDCDigits(nullptr)
197 , fBC2TQDCDigits(nullptr)
198 , fBC3TQDCDigits(nullptr)
199 , fBC4TQDCDigits(nullptr)
200 , fX1LDigits(nullptr)
201 , fX2LDigits(nullptr)
202 , fY1LDigits(nullptr)
203 , fY2LDigits(nullptr)
204 , fX1RDigits(nullptr)
205 , fX2RDigits(nullptr)
206 , fY1RDigits(nullptr)
207 , fY2RDigits(nullptr)
208 , fX1LTQDCDigits(nullptr)
209 , fX2LTQDCDigits(nullptr)
210 , fY1LTQDCDigits(nullptr)
211 , fY2LTQDCDigits(nullptr)
212 , fX1RTQDCDigits(nullptr)
213 , fX2RTQDCDigits(nullptr)
214 , fY1RTQDCDigits(nullptr)
215 , fY2RTQDCDigits(nullptr)
216 , fVetoDigits(nullptr)
217 , fVetoTQDCDigits(nullptr)
218 , fTof700Digits(nullptr)
219 , fZdcDigits(nullptr)
220 ,
221
222 // in3
223 fMwpcDigits(nullptr)
224 , fDchDigits(nullptr)
225 , fTof400Digits(nullptr)
226 , fEcalDigits(nullptr)
227 ,
228
229 fOutFile(nullptr)
230 , fOutTree(nullptr)
231 , fOutFiles(nullptr)
232 , fOutTrees(nullptr)
233 ,
234
235 // out file content
236 fGem(nullptr)
237 , fCsc(nullptr)
238 , fSil(nullptr)
239 , fZdc(nullptr)
240 , fMwpc(nullptr)
241 , fDch(nullptr)
242 , fTof400(nullptr)
243 , fTof700(nullptr)
244 , fEcal(nullptr)
245 ,
246
247 fBC1(nullptr)
248 , fBC2(nullptr)
249 , fBC3(nullptr)
250 , fBC4(nullptr)
251 , fBC1TQDC(nullptr)
252 , fBC2TQDC(nullptr)
253 , fBC3TQDC(nullptr)
254 , fBC4TQDC(nullptr)
255 , fVeto(nullptr)
256 , fVetoTQDC(nullptr)
257 , fX1L(nullptr)
258 , fX2L(nullptr)
259 , fY1L(nullptr)
260 , fY2L(nullptr)
261 , fX1R(nullptr)
262 , fX2R(nullptr)
263 , fY1R(nullptr)
264 , fY2R(nullptr)
265 , fX1LTQDC(nullptr)
266 , fX2LTQDC(nullptr)
267 , fY1LTQDC(nullptr)
268 , fY2LTQDC(nullptr)
269 , fX1RTQDC(nullptr)
270 , fX2RTQDC(nullptr)
271 , fY1RTQDC(nullptr)
272 , fY2RTQDC(nullptr)
273 , fHeader1(nullptr)
274 , fHeader2Obj(nullptr)
275 , fHeader3(nullptr)
276 , fHeaderOut(nullptr)
277{
278 fIn1 = new TChain("BMN_DIGIT");
279 fIn2 = new TChain("bmndata");
280 fIn3 = new TChain("bmndata");
281
282 if (!files[0].IsNull()) {
283 fIn1->Add(files[0].Data());
284 fIn1->SetBranchAddress("EventHeader", &fHeader1);
285 fIn1->SetBranchAddress("STRIPGEM", &fGemDigits);
286 fIn1->SetBranchAddress("MYSILICON", &fSilDigits);
287 }
288
289 if (!files[1].IsNull()) {
290 fIn2->Add(files[1].Data());
291 fIn2->SetBranchAddress("BmnEventHeader.", &fHeader2Obj);
292 fIn2->SetBranchAddress("BC1", &fBC1Digits);
293 fIn2->SetBranchAddress("BC2", &fBC2Digits);
294 fIn2->SetBranchAddress("BC3", &fBC3Digits);
295 fIn2->SetBranchAddress("BC4", &fBC4Digits);
296 fIn2->SetBranchAddress("TQDC_BC1", &fBC1TQDCDigits);
297 fIn2->SetBranchAddress("TQDC_BC2", &fBC2TQDCDigits);
298 fIn2->SetBranchAddress("TQDC_BC3", &fBC3TQDCDigits);
299 fIn2->SetBranchAddress("TQDC_BC4", &fBC4TQDCDigits);
300
301 fIn2->SetBranchAddress("X1_Left", &fX1LDigits);
302 fIn2->SetBranchAddress("X2_Left", &fX2LDigits);
303 fIn2->SetBranchAddress("Y1_Left", &fY1LDigits);
304 fIn2->SetBranchAddress("Y2_Left", &fY2LDigits);
305 fIn2->SetBranchAddress("X1_Right", &fX1RDigits);
306 fIn2->SetBranchAddress("X2_Right", &fX2RDigits);
307 fIn2->SetBranchAddress("Y1_Right", &fY1RDigits);
308 fIn2->SetBranchAddress("Y2_Right", &fY2RDigits);
309 fIn2->SetBranchAddress("TQDC_X1_Left", &fX1LTQDCDigits);
310 fIn2->SetBranchAddress("TQDC_X2_Left", &fX2LTQDCDigits);
311 fIn2->SetBranchAddress("TQDC_Y1_Left", &fY1LTQDCDigits);
312 fIn2->SetBranchAddress("TQDC_Y2_Left", &fY2LTQDCDigits);
313 fIn2->SetBranchAddress("TQDC_X1_Right", &fX1RTQDCDigits);
314 fIn2->SetBranchAddress("TQDC_X2_Right", &fX2RTQDCDigits);
315 fIn2->SetBranchAddress("TQDC_Y1_Right", &fY1RTQDCDigits);
316 fIn2->SetBranchAddress("TQDC_Y2_Right", &fY2RTQDCDigits);
317
318 fIn2->SetBranchAddress("VC", &fVetoDigits);
319 fIn2->SetBranchAddress("TQDC_VC", &fVetoTQDCDigits);
320
321 fIn2->SetBranchAddress("ZDC", &fZdcDigits);
322 fIn2->SetBranchAddress("TOF700", &fTof700Digits);
323 }
324
325 if (!files[2].IsNull()) {
326 fIn3->Add(files[2].Data());
327 fIn3->SetBranchAddress("EventHeader", &fHeader3);
328 fIn3->SetBranchAddress("MWPC", &fMwpcDigits);
329 fIn3->SetBranchAddress("DCH", &fDchDigits);
330 fIn3->SetBranchAddress("ECAL", &fEcalDigits);
331 fIn3->SetBranchAddress("TOF400", &fTof400Digits);
332 }
333
334 CreateOutputFiles();
335 CreateGeometries();
336}
337
338BmnDigiMergeTask::BmnDigiMergeTask(vector<TString> files, TString out)
339 : isRun6(kFALSE)
340 , isRun7(kFALSE)
341 , isSrc(kFALSE)
342 , fOutFile(nullptr)
343 , fOutTree(nullptr)
344 , fOutFiles(nullptr)
345 , fOutTrees(nullptr)
346 , fInFiles(nullptr)
347 , fBC1Digits(nullptr)
348 , fBC2Digits(nullptr)
349 , fBC3Digits(nullptr)
350 , fVetoDigits(nullptr)
351 , fSiDigits(nullptr)
352 , fBdDigits(nullptr)
353 , fZdcDigits(nullptr)
354 , fGemDigits(nullptr)
355 , fCscDigits(nullptr)
356 , fSilDigits(nullptr)
357 , fMwpcDigits(nullptr)
358 , fDchDigits(nullptr)
359 , fTof400Digits(nullptr)
360 , fTof700Digits(nullptr)
361 , fEcalDigits(nullptr)
362 , fHeaderOut(nullptr)
363 , fHeaders(nullptr)
364 , fGem(nullptr)
365 , fCsc(nullptr)
366 , fSil(nullptr)
367 , fZdc(nullptr)
368 , fT0(nullptr)
369 , fBC1(nullptr)
370 , fBC2(nullptr)
371 , fBC3(nullptr)
372 , fSi(nullptr)
373 , fVeto(nullptr)
374 , fFd(nullptr)
375 , fBd(nullptr)
376 , fMwpc(nullptr)
377 , fDch(nullptr)
378 , fTof400(nullptr)
379 , fTof700(nullptr)
380 , fEcal(nullptr)
381 , evId_evNum(nullptr)
382{
383 nDets = files.size();
384
385 isRun6 = (nDets == 14) ? kTRUE : kFALSE;
386 isRun7 = (nDets == 15) ? kTRUE : kFALSE;
387 isSrc = (nDets == 35) ? kTRUE : kFALSE;
388
389 if (!isRun6 && !isRun7 && !isSrc)
390 throw;
391
392 fBC1Digits = new TClonesArray("BmnTrigDigit");
393 fBC2Digits = new TClonesArray("BmnTrigDigit");
394 fVetoDigits = new TClonesArray("BmnTrigDigit");
395 fBdDigits = new TClonesArray("BmnTrigDigit");
396 fZdcDigits = new TClonesArray("BmnZDCDigit");
397 fGemDigits = new TClonesArray("BmnGemStripDigit");
398 fSilDigits = new TClonesArray("BmnSiliconDigit");
399 fMwpcDigits = new TClonesArray("BmnMwpcDigit");
400 fDchDigits = new TClonesArray("BmnDchDigit");
401 fTof400Digits = new TClonesArray("BmnTof1Digit");
402 fTof700Digits = new TClonesArray("BmnTof2Digit");
403 fEcalDigits = new TClonesArray("BmnECALDigit");
404
405 if (isRun6 && !isSrc) {
406 fT0Digits = new TClonesArray("BmnTrigDigit");
407 fFdDigits = new TClonesArray("BmnTrigDigit");
408 }
409
410 if (isRun7 && !isSrc) {
411 fBC3Digits = new TClonesArray("BmnTrigDigit");
412 fSiDigits = new TClonesArray("BmnTrigDigit");
413 fCscDigits = new TClonesArray("BmnCSCDigit");
414 }
415
416 if (isSrc) {
417 fCscDigits = new TClonesArray("BmnCSCDigit");
418 fBC3Digits = new TClonesArray("BmnTrigDigit");
419 fBC4Digits = new TClonesArray("BmnTrigDigit");
420
421 fVetoTQDCDigits = new TClonesArray("BmnTrigWaveDigit");
422
423 fX1LDigits = new TClonesArray("BmnTrigDigit");
424 fX2LDigits = new TClonesArray("BmnTrigDigit");
425 fY1LDigits = new TClonesArray("BmnTrigDigit");
426 fY2LDigits = new TClonesArray("BmnTrigDigit");
427 fX1RDigits = new TClonesArray("BmnTrigDigit");
428 fX2RDigits = new TClonesArray("BmnTrigDigit");
429 fY1RDigits = new TClonesArray("BmnTrigDigit");
430 fY2RDigits = new TClonesArray("BmnTrigDigit");
431
432 fX1LTQDCDigits = new TClonesArray("BmnTrigWaveDigit");
433 fX2LTQDCDigits = new TClonesArray("BmnTrigWaveDigit");
434 fY1LTQDCDigits = new TClonesArray("BmnTrigWaveDigit");
435 fY2LTQDCDigits = new TClonesArray("BmnTrigWaveDigit");
436 fX1RTQDCDigits = new TClonesArray("BmnTrigWaveDigit");
437 fX2RTQDCDigits = new TClonesArray("BmnTrigWaveDigit");
438 fY1RTQDCDigits = new TClonesArray("BmnTrigWaveDigit");
439 fY2RTQDCDigits = new TClonesArray("BmnTrigWaveDigit");
440
441 fBC1TQDCDigits = new TClonesArray("BmnTrigWaveDigit");
442 fBC2TQDCDigits = new TClonesArray("BmnTrigWaveDigit");
443 fBC3TQDCDigits = new TClonesArray("BmnTrigWaveDigit");
444 fBC4TQDCDigits = new TClonesArray("BmnTrigWaveDigit");
445 }
446
447 TString detsRun6[] = {"GEM", "SILICON", "ZDC", "T0", "BC1", "BC2", "VETO",
448 "FD", "BD", "MWPC", "DCH", "TOF400", "TOF700", "ECAL"};
449 TString detsRun7[] = {"BC1", "BC2", "BC3", "VC", "Si", "BD", "ZDC", "GEM",
450 "SILICON", "MWPC", "DCH", "TOF400", "ECAL", "CSC", "TOF700"};
451 TString detsRun7Src[] = {"GEM", "SILICON", "CSC", "BC1", "BC2", "BC3", "BC4",
452 "TQDC_BC1", "TQDC_BC2", "TQDC_BC3", "TQDC_BC4", "X1L", "X2L", "Y1L",
453 "Y2L", "X1R", "X2R", "Y1R", "Y2R", "TQDC_X1L", "TQDC_X2L",
454 "TQDC_Y1L", "TQDC_Y2L", "TQDC_X1R", "TQDC_X2R", "TQDC_Y1R", "TQDC_Y2R", "VETO",
455 "TQDC_VETO", "TOF700", "ZDC", "MWPC", "DCH", "TOF400", "ECAL"};
456
457 TClonesArray* inArrsRun6[] = {fGemDigits, fSilDigits, fZdcDigits, fT0Digits, fBC1Digits,
458 fBC2Digits, fVetoDigits, fFdDigits, fBdDigits, fMwpcDigits,
459 fDchDigits, fTof400Digits, fTof700Digits, fEcalDigits};
460
461 TClonesArray* inArrsRun7[] = {fBC1Digits, fBC2Digits, fBC3Digits, fVetoDigits, fSiDigits,
462 fBdDigits, fZdcDigits, fGemDigits, fSilDigits, fMwpcDigits,
463 fDchDigits, fTof400Digits, fEcalDigits, fCscDigits, fTof700Digits};
464
465 TClonesArray* inArrsRun7Src[] = {
466 fGemDigits, fSilDigits, fCscDigits, fBC1Digits, fBC2Digits, fBC3Digits, fBC4Digits,
467 fBC1TQDCDigits, fBC2TQDCDigits, fBC3TQDCDigits, fBC4TQDCDigits, fX1LDigits, fX2LDigits, fY1LDigits,
468 fY2LDigits, fX1RDigits, fX2RDigits, fY1RDigits, fY2RDigits, fX1LTQDCDigits, fX2LTQDCDigits,
469 fY1LTQDCDigits, fY2LTQDCDigits, fX1RTQDCDigits, fX2RTQDCDigits, fY1RTQDCDigits, fY2RTQDCDigits, fVetoDigits,
470 fVetoTQDCDigits, fTof700Digits, fZdcDigits, fMwpcDigits, fDchDigits, fTof400Digits, fEcalDigits};
471
472 fInArrs = new TClonesArray*[nDets];
473 fHeaders = new BmnEventHeader*[nDets];
474 fInFiles = new TChain*[nDets];
475
476 for (Int_t iDet = 0; iDet < nDets; iDet++) {
477 fHeaders[iDet] = new BmnEventHeader();
478 if (!isSrc)
479 fInArrs[iDet] = (isRun6) ? inArrsRun6[iDet] : inArrsRun7[iDet];
480 else
481 fInArrs[iDet] = inArrsRun7Src[iDet];
482 fInFiles[iDet] = new TChain("bmndata");
483 fInFiles[iDet]->Add(files[iDet].Data());
484 if (!isSrc)
485 fInFiles[iDet]->SetBranchAddress((isRun6 ? detsRun6[iDet] : detsRun7[iDet]).Data(), &fInArrs[iDet]);
486 else
487 fInFiles[iDet]->SetBranchAddress(detsRun7Src[iDet].Data(), &fInArrs[iDet]);
488 fInFiles[iDet]->SetBranchAddress("BmnEventHeader.", &fHeaders[iDet]);
489 }
490
491 CreateOutputFile(out);
492}
493
494void BmnDigiMergeTask::CreateOutputFiles()
495{
496 fIn1->GetEntry(0);
497 BmnEventHeader* evHead = (BmnEventHeader*)fHeader1->UncheckedAt(0);
498 UInt_t runId = evHead->GetRunId();
499
500 if (!isSrc)
501 nDets = isRun7 ? 15 : isRun6 ? 14 : throw;
502 else
503 nDets = 9 + 26; // dets + triggers
504
505 TString detsRun6[] = {"GEM", "SILICON", "ZDC", "T0", "BC1", "BC2", "VETO",
506 "FD", "BD", "MWPC", "DCH", "TOF400", "TOF700", "ECAL"};
507 TString detsRun7[] = {"BC1", "BC2", "BC3", "VC", "Si", "BD", "ZDC", "GEM",
508 "SILICON", "MWPC", "DCH", "TOF400", "ECAL", "CSC", "TOF700"};
509 TString detsRun7Src[] = {"GEM", "SILICON", "CSC", "BC1", "BC2", "BC3", "BC4",
510 "TQDC_BC1", "TQDC_BC2", "TQDC_BC3", "TQDC_BC4", "X1L", "X2L", "Y1L",
511 "Y2L", "X1R", "X2R", "Y1R", "Y2R", "TQDC_X1L", "TQDC_X2L",
512 "TQDC_Y1L", "TQDC_Y2L", "TQDC_X1R", "TQDC_X2R", "TQDC_Y1R", "TQDC_Y2R", "VETO",
513 "TQDC_VETO", "TOF700", "ZDC", "MWPC", "DCH", "TOF400", "ECAL"};
514
515 fOutFiles = new TFile*[nDets];
516 fOutTrees = new TTree*[nDets];
517
518 // Common triggers (BM@N + SRC)
519 fBC1 = new TClonesArray("BmnTrigDigit");
520 fBC2 = new TClonesArray("BmnTrigDigit");
521 fBC3 = new TClonesArray("BmnTrigDigit");
522 fVeto = new TClonesArray("BmnTrigDigit");
523
524 // Common detectors (BM@N + SRC)
525 fGem = new TClonesArray("BmnGemStripDigit");
526 fSil = new TClonesArray("BmnSiliconDigit");
527 fMwpc = new TClonesArray("BmnMwpcDigit");
528 fDch = new TClonesArray("BmnDchDigit");
529 fTof400 = new TClonesArray("BmnTof1Digit");
530 fTof700 = new TClonesArray("BmnTof2Digit");
531 fEcal = new TClonesArray("BmnECALDigit");
532 fZdc = new TClonesArray("BmnZDCDigit");
533
534 if (!isSrc) {
535 fBd = new TClonesArray("BmnTrigDigit");
536 if (isRun6) {
537 fT0 = new TClonesArray("BmnTrigDigit");
538 fFd = new TClonesArray("BmnTrigDigit");
539 }
540
541 if (isRun7) {
542 fSi = new TClonesArray("BmnTrigDigit");
543 fCsc = new TClonesArray("BmnCSCDigit");
544 }
545 } else {
546 // Triggers
547 fBC4 = new TClonesArray("BmnTrigDigit");
548
549 fBC1TQDC = new TClonesArray("BmnTrigWaveDigit");
550 fBC2TQDC = new TClonesArray("BmnTrigWaveDigit");
551 fBC3TQDC = new TClonesArray("BmnTrigWaveDigit");
552 fBC4TQDC = new TClonesArray("BmnTrigWaveDigit");
553
554 fX1L = new TClonesArray("BmnTrigDigit");
555 fX2L = new TClonesArray("BmnTrigDigit");
556 fY1L = new TClonesArray("BmnTrigDigit");
557 fY2L = new TClonesArray("BmnTrigDigit");
558 fX1R = new TClonesArray("BmnTrigDigit");
559 fX2R = new TClonesArray("BmnTrigDigit");
560 fY1R = new TClonesArray("BmnTrigDigit");
561 fY2R = new TClonesArray("BmnTrigDigit");
562
563 fX1LTQDC = new TClonesArray("BmnTrigWaveDigit");
564 fX2LTQDC = new TClonesArray("BmnTrigWaveDigit");
565 fY1LTQDC = new TClonesArray("BmnTrigWaveDigit");
566 fY2LTQDC = new TClonesArray("BmnTrigWaveDigit");
567 fX1RTQDC = new TClonesArray("BmnTrigWaveDigit");
568 fX2RTQDC = new TClonesArray("BmnTrigWaveDigit");
569 fY1RTQDC = new TClonesArray("BmnTrigWaveDigit");
570 fY2RTQDC = new TClonesArray("BmnTrigWaveDigit");
571
572 fVetoTQDC = new TClonesArray("BmnTrigWaveDigit");
573
574 // Detectors
575 fCsc = new TClonesArray("BmnCSCDigit");
576 }
577
578 fHeaderOut = new BmnEventHeader();
579
580 TClonesArray* arrRun6[] = {fGem, fSil, fZdc, fT0, fBC1, fBC2, fVeto,
581 fFd, fBd, fMwpc, fDch, fTof400, fTof700, fEcal};
582 TClonesArray* arrRun7[] = {fBC1, fBC2, fBC3, fVeto, fSi, fBd, fZdc, fGem,
583 fSil, fMwpc, fDch, fTof400, fEcal, fCsc, fTof700};
584 TClonesArray* arrRun7Src[] = {
585 fGem, fSil, fCsc, fBC1, fBC2, fBC3, fBC4, fBC1TQDC, fBC2TQDC, fBC3TQDC, fBC4TQDC, fX1L,
586 fX2L, fY1L, fY2L, fX1R, fX2R, fY1R, fY2R, fX1LTQDC, fX2LTQDC, fY1LTQDC, fY2LTQDC, fX1RTQDC,
587 fX2RTQDC, fY1RTQDC, fY2RTQDC, fVeto, fVetoTQDC, fTof700, fZdc, fMwpc, fDch, fTof400, fEcal};
588
589 fOutArrs = new TClonesArray*[nDets];
590 for (Int_t iDet = 0; iDet < nDets; iDet++) {
591 if (!isSrc)
592 fOutArrs[iDet] = isRun6 ? arrRun6[iDet] : arrRun7[iDet];
593 else
594 fOutArrs[iDet] = arrRun7Src[iDet];
595 }
596
597 for (Int_t iDet = 0; iDet < nDets; iDet++) {
598 if (!isSrc)
599 fOutFiles[iDet] = new TFile(
600 TString((isRun6 ? detsRun6[iDet] : detsRun7[iDet]) + TString::Format("_%d.root", runId)).Data(),
601 "recreate");
602 else
603 fOutFiles[iDet] =
604 new TFile(TString(detsRun7Src[iDet] + TString::Format("_%d.root", runId)).Data(), "recreate");
605 fOutTrees[iDet] = new TTree("bmndata", "bmndata");
606 fOutTrees[iDet]->Branch("BmnEventHeader.", &fHeaderOut);
607 if (!isSrc)
608 fOutTrees[iDet]->Branch((isRun6 ? detsRun6[iDet] : detsRun7[iDet]).Data(), &fOutArrs[iDet]);
609 else
610 fOutTrees[iDet]->Branch(detsRun7Src[iDet].Data(), &fOutArrs[iDet]);
611 }
612}
613
614void BmnDigiMergeTask::CreateOutputFile(TString out)
615{
616 fOutFile = new TFile(out.Data(), "recreate");
617 fOutTree = new TTree("bmndata", "bmndata");
618
619 fHeaderOut = new BmnEventHeader();
620 fOutTree->Branch("BmnEventHeader.", &fHeaderOut);
621
622 fGem = new TClonesArray("BmnGemStripDigit");
623 fOutTree->Branch("GEM", &fGem);
624
625 fSil = new TClonesArray("BmnSiliconDigit");
626 fOutTree->Branch("SILICON", &fSil);
627
628 fZdc = new TClonesArray("BmnZDCDigit");
629 fOutTree->Branch("ZDC", &fZdc);
630
631 fBC1 = new TClonesArray("BmnTrigDigit");
632 fOutTree->Branch("BC1", &fBC1);
633
634 fBC2 = new TClonesArray("BmnTrigDigit");
635 fOutTree->Branch("BC2", &fBC2);
636
637 fVeto = new TClonesArray("BmnTrigDigit");
638 fOutTree->Branch("VETO", &fVeto);
639
640 fBd = new TClonesArray("BmnTrigDigit");
641 fOutTree->Branch("BD", &fBd);
642
643 fMwpc = new TClonesArray("BmnMwpcDigit");
644 fDch = new TClonesArray("BmnDchDigit");
645 fTof400 = new TClonesArray("BmnTof1Digit");
646 fTof700 = new TClonesArray("BmnTof2Digit");
647 fEcal = new TClonesArray("BmnECALDigit");
648 fOutTree->Branch("MWPC", &fMwpc);
649 fOutTree->Branch("DCH", &fDch);
650 fOutTree->Branch("TOF400", &fTof400);
651 fOutTree->Branch("TOF700", &fTof700);
652 fOutTree->Branch("ECAL", &fEcal);
653
654 if (isRun6 && !isSrc) {
655 fT0 = new TClonesArray("BmnTrigDigit");
656 fOutTree->Branch("T0", &fT0);
657 fFd = new TClonesArray("BmnTrigDigit");
658 fOutTree->Branch("FD", &fFd);
659 }
660
661 if (isRun7 && !isSrc) {
662 fCsc = new TClonesArray("BmnCSCDigit");
663 fOutTree->Branch("CSC", &fCsc);
664 fBC3 = new TClonesArray("BmnTrigDigit");
665 fOutTree->Branch("BC3", &fBC3);
666 fSi = new TClonesArray("BmnTrigDigit");
667 fOutTree->Branch("Si", &fSi);
668 }
669
670 if (isSrc) {
671 fCsc = new TClonesArray("BmnCSCDigit");
672 fOutTree->Branch("CSC", &fCsc);
673
674 fBC3 = new TClonesArray("BmnTrigDigit");
675 fOutTree->Branch("BC3", &fBC3);
676
677 fBC4 = new TClonesArray("BmnTrigDigit");
678 fOutTree->Branch("BC4", &fBC4);
679
680 fVetoTQDC = new TClonesArray("BmnTrigWaveDigit");
681 fOutTree->Branch("TQDC_VETO", &fVetoTQDC);
682
683 fX1L = new TClonesArray("BmnTrigDigit");
684 fOutTree->Branch("X1L", &fX1L);
685 fX2L = new TClonesArray("BmnTrigDigit");
686 fOutTree->Branch("X2L", &fX2L);
687 fY1L = new TClonesArray("BmnTrigDigit");
688 fOutTree->Branch("Y1L", &fY1L);
689 fY2L = new TClonesArray("BmnTrigDigit");
690 fOutTree->Branch("Y2L", &fY2L);
691 fX1R = new TClonesArray("BmnTrigDigit");
692 fOutTree->Branch("X1R", &fX1R);
693 fX2R = new TClonesArray("BmnTrigDigit");
694 fOutTree->Branch("X2R", &fX2R);
695 fY1R = new TClonesArray("BmnTrigDigit");
696 fOutTree->Branch("Y1R", &fY1R);
697 fY2R = new TClonesArray("BmnTrigDigit");
698 fOutTree->Branch("Y2R", &fY2R);
699
700 fX1LTQDC = new TClonesArray("BmnTrigWaveDigit");
701 fOutTree->Branch("TQDC_X1L", &fX1LTQDC);
702 fX2LTQDC = new TClonesArray("BmnTrigWaveDigit");
703 fOutTree->Branch("TQDC_X2L", &fX2LTQDC);
704 fY1LTQDC = new TClonesArray("BmnTrigWaveDigit");
705 fOutTree->Branch("TQDC_Y1L", &fY1LTQDC);
706 fY2LTQDC = new TClonesArray("BmnTrigWaveDigit");
707 fOutTree->Branch("TQDC_Y2L", &fY2LTQDC);
708 fX1RTQDC = new TClonesArray("BmnTrigWaveDigit");
709 fOutTree->Branch("TQDC_X1R", &fX1RTQDC);
710 fX2RTQDC = new TClonesArray("BmnTrigWaveDigit");
711 fOutTree->Branch("TQDC_X2R", &fX2RTQDC);
712 fY1RTQDC = new TClonesArray("BmnTrigWaveDigit");
713 fOutTree->Branch("TQDC_Y1R", &fY1RTQDC);
714 fY2RTQDC = new TClonesArray("BmnTrigWaveDigit");
715 fOutTree->Branch("TQDC_Y2R", &fY2RTQDC);
716
717 fBC1TQDC = new TClonesArray("BmnTrigWaveDigit");
718 fOutTree->Branch("TQDC_BC1", &fBC1TQDC);
719 fBC2TQDC = new TClonesArray("BmnTrigWaveDigit");
720 fOutTree->Branch("TQDC_BC2", &fBC2TQDC);
721 fBC3TQDC = new TClonesArray("BmnTrigWaveDigit");
722 fOutTree->Branch("TQDC_BC3", &fBC3TQDC);
723 fBC4TQDC = new TClonesArray("BmnTrigWaveDigit");
724 fOutTree->Branch("TQDC_BC4", &fBC4TQDC);
725 }
726
727 TClonesArray* arrRun6[] = {fGem, fSil, fZdc, fT0, fBC1, fBC2, fVeto,
728 fFd, fBd, fMwpc, fDch, fTof400, fTof700, fEcal};
729 TClonesArray* arrRun7[] = {fBC1, fBC2, fBC3, fVeto, fSi, fBd, fZdc, fGem,
730 fSil, fMwpc, fDch, fTof400, fEcal, fCsc, fTof700};
731 TClonesArray* arrRun7Src[] = {
732 fGem, fSil, fCsc, fBC1, fBC2, fBC3, fBC4, fBC1TQDC, fBC2TQDC, fBC3TQDC, fBC4TQDC, fX1L,
733 fX2L, fY1L, fY2L, fX1R, fX2R, fY1R, fY2R, fX1LTQDC, fX2LTQDC, fY1LTQDC, fY2LTQDC, fX1RTQDC,
734 fX2RTQDC, fY1RTQDC, fY2RTQDC, fVeto, fVetoTQDC, fTof700, fZdc, fMwpc, fDch, fTof400, fEcal};
735
736 fOutArrs = new TClonesArray*[nDets];
737 for (Int_t iDet = 0; iDet < nDets; iDet++) {
738 if (!isSrc)
739 fOutArrs[iDet] = isRun6 ? arrRun6[iDet] : arrRun7[iDet];
740 else
741 fOutArrs[iDet] = arrRun7Src[iDet];
742 }
743}
744
745void BmnDigiMergeTask::SplitToDetectorsSrc()
746{
747 map<Int_t, TClonesArray*> detsAndOutTrees1;
748 map<Int_t, TClonesArray*> detsAndOutTrees2;
749 map<Int_t, TClonesArray*> detsAndOutTrees3;
750
751 for (Int_t iDet = 0; iDet < 3; iDet++)
752 detsAndOutTrees1[iDet] = fOutArrs[iDet];
753
754 for (Int_t iDet = 3; iDet < 31; iDet++)
755 detsAndOutTrees2[iDet] = fOutArrs[iDet];
756
757 for (Int_t iDet = 31; iDet < nDets; iDet++)
758 detsAndOutTrees3[iDet] = fOutArrs[iDet];
759
760 for (Int_t iEntry = 0; iEntry < fIn1->GetEntries(); iEntry++) {
761 fIn1->GetEntry(iEntry);
762
763 if (iEntry % 10000 == 0)
764 cout << "Event# " << iEntry << endl;
765
766 for (auto it : detsAndOutTrees1)
767 it.second->Delete();
768
769 BmnEventHeader* header = (BmnEventHeader*)fHeader1->UncheckedAt(0);
770 fHeaderOut->SetRunId(header->GetRunId());
771 fHeaderOut->SetEventId(header->GetEventId());
772
773 // Prepare arrays for GEM- and SI-converters and make
774 Int_t* statsGem = new Int_t[fDetectorGEM->GetNStations()];
775 Int_t* statsSil = new Int_t[fDetectorSI->GetNStations()];
776
777 Int_t* statsGemPermut = new Int_t[fDetectorGEM->GetNStations()];
778 Int_t* statsSilPermut = new Int_t[fDetectorSI->GetNStations()];
779
780 for (Int_t iStat = 0; iStat < fDetectorGEM->GetNStations(); iStat++) {
781 statsGem[iStat] = -1;
782 statsGemPermut[iStat] = -1;
783 }
784
785 for (Int_t iStat = 0; iStat < fDetectorSI->GetNStations(); iStat++) {
786 statsSil[iStat] = -1;
787 statsSilPermut[iStat] = -1;
788 }
789
790 Run7(statsGem, statsSil, statsGemPermut, statsSilPermut); // FIXME!
791
792 for (Int_t iStat = 0; iStat < fDetectorGEM->GetNStations(); iStat++)
793 fGemStats[statsGem[iStat]] = statsGemPermut[iStat];
794
795 for (Int_t iStat = 0; iStat < fDetectorSI->GetNStations(); iStat++)
796 fSilStats[statsSil[iStat]] = statsSilPermut[iStat];
797
798 if (fGemDigits)
799 for (UInt_t iDigi = 0; iDigi < fGemDigits->GetEntriesFast(); iDigi++) {
800 BmnGemStripDigit* dig = (BmnGemStripDigit*)fGemDigits->UncheckedAt(iDigi);
801
802 if (dig->GetStation() != 11) {
803 Int_t stat = dig->GetStation();
804 Int_t strip = dig->GetStripNumber() - 1; // strips should be enumerated from zero
805 Double_t signal = dig->GetStripSignal();
806 dig->SetStation(GemStatPermutation(stat));
807 stat = dig->GetStation(); // Stations permuted already!
808
809 if (stat == 5 || stat == 7 || stat == 9) {
810 if (dig->GetModule() == 0)
811 dig->SetModule(1);
812 else if (dig->GetModule() == 1)
813 dig->SetModule(0);
814 else {
815 cout << "Something went wrong!" << endl;
816 throw;
817 }
818 }
819 new ((*fGem)[fGem->GetEntriesFast()])
820 BmnGemStripDigit(stat, dig->GetModule(), dig->GetStripLayer(), strip, signal);
821 } else {
822 // Create CSC-digi without converter
823 BmnCSCDigit digCsc(0, dig->GetModule(), dig->GetStripLayer(), dig->GetStripNumber(),
824 dig->GetStripSignal());
825
826 Int_t strip = digCsc.GetStripNumber() - 1; // strips should be enumerated from zero
827 Double_t signal = digCsc.GetStripSignal();
828
829 // Modules should be permutated! (mod0 <--> mod1)
830 if (digCsc.GetModule() == 0) {
831 digCsc.SetModule(1);
832 // Layers should be permutated in mod0 only
833 if (digCsc.GetStripLayer() == 2)
834 digCsc.SetStripLayer(0);
835 else if (digCsc.GetStripLayer() == 3)
836 digCsc.SetStripLayer(1);
837 else if (digCsc.GetStripLayer() == 0)
838 digCsc.SetStripLayer(2);
839 else if (digCsc.GetStripLayer() == 1)
840 digCsc.SetStripLayer(3);
841 else {
842 cout << "Something went wrong!" << endl;
843 throw;
844 }
845 } else if (digCsc.GetModule() == 1)
846 digCsc.SetModule(0);
847
848 else {
849 cout << "Something went wrong!" << endl;
850 throw;
851 }
852 new ((*fCsc)[fCsc->GetEntriesFast()])
853 BmnCSCDigit(0, digCsc.GetModule(), digCsc.GetStripLayer(), strip, signal);
854 }
855 }
856
857 if (fSilDigits)
858 for (UInt_t iDigi = 0; iDigi < fSilDigits->GetEntriesFast(); iDigi++) {
859 BmnSiliconDigit* dig = (BmnSiliconDigit*)fSilDigits->UncheckedAt(iDigi);
860 Int_t stat = dig->GetStation();
861 dig->SetStation(SiliconStatPermutation(stat));
862 stat = dig->GetStation(); // Stations permuted already!
863
864 Int_t strip = dig->GetStripNumber() - 1; // strips should be enumerated from zero
865 Int_t signal = dig->GetStripSignal();
866
867 Int_t mod = dig->GetModule();
868 Int_t layer = dig->GetStripLayer();
869
870 new ((*fSil)[fSil->GetEntriesFast()]) BmnSiliconDigit(stat, mod, layer, strip, signal);
871 }
872
873 for (auto it : detsAndOutTrees1)
874 fOutTrees[it.first]->Fill();
875 }
876
877 for (Int_t iEntry = 0; iEntry < fIn2->GetEntries(); iEntry++) {
878 fIn2->GetEntry(iEntry);
879
880 if (iEntry % 10000 == 0)
881 cout << "Event# " << iEntry << endl;
882
883 for (auto it : detsAndOutTrees2)
884 it.second->Delete();
885
886 fHeaderOut->SetRunId(fHeader2Obj->GetRunId());
887 fHeaderOut->SetEventId(fHeader2Obj->GetEventId());
888
889 // Detectors
890 if (fTof700Digits)
891 FillDetDigi<BmnTof2Digit>(fTof700Digits, fTof700);
892
893 if (fZdcDigits)
894 FillDetDigi<BmnZDCDigit>(fZdcDigits, fZdc);
895
896 // Triggers
897 const Int_t nTrigs = 13;
898 const Int_t nTqdcTrigs = 13;
899
900 TClonesArray* trigsIn[nTrigs] = {fBC1Digits, fBC2Digits, fBC3Digits, fBC4Digits, fX1LDigits,
901 fX2LDigits, fY1LDigits, fY2LDigits, fX1RDigits, fX2RDigits,
902 fY1RDigits, fY2RDigits, fVetoDigits};
903 TClonesArray* trigsOut[nTrigs] = {fBC1, fBC2, fBC3, fBC4, fX1L, fX2L, fY1L,
904 fY2L, fX1R, fX2R, fY1R, fY2R, fVeto};
905 TClonesArray* tqdcTrigsIn[nTrigs] = {fBC1TQDCDigits, fBC2TQDCDigits, fBC3TQDCDigits, fBC4TQDCDigits,
906 fX1LTQDCDigits, fX2LTQDCDigits, fY1LTQDCDigits, fY2LTQDCDigits,
907 fX1RTQDCDigits, fX2RTQDCDigits, fY1RTQDCDigits, fY2RTQDCDigits,
908 fVetoTQDCDigits};
909 TClonesArray* tqdcTrigsOut[nTrigs] = {fBC1TQDC, fBC2TQDC, fBC3TQDC, fBC4TQDC, fX1LTQDC, fX2LTQDC, fY1LTQDC,
910 fY2LTQDC, fX1RTQDC, fX2RTQDC, fY1RTQDC, fY2RTQDC, fVetoTQDC};
911
912 for (Int_t iTrig = 0; iTrig < nTrigs; iTrig++)
913 if (trigsIn[iTrig])
914 FillDetDigi<BmnTrigDigit>(trigsIn[iTrig], trigsOut[iTrig]);
915
916 for (Int_t iTqdcTrig = 0; iTqdcTrig < nTqdcTrigs; iTqdcTrig++)
917 if (tqdcTrigsIn[iTqdcTrig])
918 FillDetDigi<BmnTrigWaveDigit>(tqdcTrigsIn[iTqdcTrig], tqdcTrigsOut[iTqdcTrig]);
919
920 for (auto it : detsAndOutTrees2)
921 fOutTrees[it.first]->Fill();
922 }
923
924 for (Int_t iEntry = 0; iEntry < fIn3->GetEntries(); iEntry++) {
925 fIn3->GetEntry(iEntry);
926
927 if (iEntry % 10000 == 0)
928 cout << "Event# " << iEntry << endl;
929
930 for (auto it : detsAndOutTrees3)
931 it.second->Delete();
932
933 BmnEventHeader* header = (BmnEventHeader*)fHeader3->UncheckedAt(0);
934 fHeaderOut->SetRunId(header->GetRunId());
935 fHeaderOut->SetEventId(header->GetEventId());
936
937 if (fMwpcDigits)
938 FillDetDigi<BmnMwpcDigit>(fMwpcDigits, fMwpc);
939
940 if (fDchDigits)
941 FillDetDigi<BmnDchDigit>(fDchDigits, fDch);
942
943 if (fTof400Digits)
944 FillDetDigi<BmnTof1Digit>(fTof400Digits, fTof400);
945
946 if (fEcalDigits)
947 FillDetDigi<BmnECALDigit>(fEcalDigits, fEcal);
948
949 for (auto it : detsAndOutTrees3)
950 fOutTrees[it.first]->Fill();
951 }
952}
953
954void BmnDigiMergeTask::SplitToDetectorsRun6()
955{
956 map<Int_t, TClonesArray*> detsAndOutTrees1;
957 map<Int_t, TClonesArray*> detsAndOutTrees2;
958 map<Int_t, TClonesArray*> detsAndOutTrees3;
959
960 for (Int_t iDet = 0; iDet < 2; iDet++)
961 detsAndOutTrees1[iDet] = fOutArrs[iDet];
962
963 for (Int_t iDet = 2; iDet < 3; iDet++)
964 detsAndOutTrees2[iDet] = fOutArrs[iDet];
965
966 for (Int_t iDet = 3; iDet < nDets; iDet++)
967 detsAndOutTrees3[iDet] = fOutArrs[iDet];
968
969 for (Int_t iEntry = 0; iEntry < fIn1->GetEntries(); iEntry++) {
970 fIn1->GetEntry(iEntry);
971
972 if (iEntry % 10000 == 0)
973 cout << "Event# " << iEntry << endl;
974
975 for (auto it : detsAndOutTrees1)
976 it.second->Delete();
977
978 BmnEventHeader* header = (BmnEventHeader*)fHeader1->UncheckedAt(0);
979 fHeaderOut->SetRunId(header->GetRunId());
980 fHeaderOut->SetEventId(header->GetEventId());
981 // if (header->GetEventType() == 0) cout << header->GetEventType() << endl;
982 fHeaderOut->SetEventType(header->GetEventType());
983
984 if (fGemDigits)
985 FillDetDigi<BmnGemStripDigit>(fGemDigits, fGem);
986
987 if (fSilDigits)
988 FillDetDigi<BmnSiliconDigit>(fSilDigits, fSil);
989
990 for (auto it : detsAndOutTrees1)
991 fOutTrees[it.first]->Fill();
992 }
993
994 for (Int_t iEntry = 0; iEntry < fIn2->GetEntries(); iEntry++) {
995 fIn2->GetEntry(iEntry);
996
997 if (iEntry % 10000 == 0)
998 cout << "Event# " << iEntry << endl;
999
1000 for (auto it : detsAndOutTrees2)
1001 it.second->Delete();
1002
1003 BmnEventHeader* header = (BmnEventHeader*)fHeader2->UncheckedAt(0);
1004 fHeaderOut->SetRunId(header->GetRunId());
1005 fHeaderOut->SetEventId(header->GetEventId());
1006
1007 if (fZdcDigits)
1008 FillDetDigi<BmnZDCDigit>(fZdcDigits, fZdc);
1009
1010 for (auto it : detsAndOutTrees2)
1011 fOutTrees[it.first]->Fill();
1012 }
1013
1014 for (Int_t iEntry = 0; iEntry < fIn3->GetEntries(); iEntry++) {
1015 fIn3->GetEntry(iEntry);
1016
1017 if (iEntry % 10000 == 0)
1018 cout << "Event# " << iEntry << endl;
1019
1020 for (auto it : detsAndOutTrees3)
1021 it.second->Delete();
1022
1023 BmnEventHeader* header = (BmnEventHeader*)fHeader3->UncheckedAt(0);
1024 fHeaderOut->SetRunId(header->GetRunId());
1025 fHeaderOut->SetEventId(header->GetEventId());
1026
1027 // Triggers
1028 const Int_t nTrigs = 6;
1029 TClonesArray* trigsIn[nTrigs] = {fT0Digits, fFdDigits, fBC1Digits, fBC2Digits, fVetoDigits, fBdDigits};
1030 TClonesArray* trigsOut[nTrigs] = {fT0, fFd, fBC1, fBC2, fVeto, fBd};
1031
1032 for (Int_t iTrig = 0; iTrig < nTrigs; iTrig++)
1033 if (trigsIn[iTrig])
1034 FillDetDigi<BmnTrigDigit>(trigsIn[iTrig], trigsOut[iTrig]);
1035
1036 if (fMwpcDigits)
1037 FillDetDigi<BmnMwpcDigit>(fMwpcDigits, fMwpc);
1038
1039 if (fDchDigits)
1040 FillDetDigi<BmnDchDigit>(fDchDigits, fDch);
1041
1042 if (fTof400Digits)
1043 FillDetDigi<BmnTof1Digit>(fTof400Digits, fTof400);
1044
1045 if (fTof700Digits)
1046 FillDetDigi<BmnTof2Digit>(fTof700Digits, fTof700);
1047
1048 if (fEcalDigits)
1049 FillDetDigi<BmnECALDigit>(fEcalDigits, fEcal);
1050
1051 for (auto it : detsAndOutTrees3)
1052 fOutTrees[it.first]->Fill();
1053 }
1054}
1055
1056void BmnDigiMergeTask::SplitToDetectorsRun7()
1057{
1058 // fBC1, fBC2, fBC3, fVeto, fSi, fBd, fZdc, fGem, fSil, fMwpc, fDch, fTof400, fEcal, fCsc, fTof700
1059 map<Int_t, TClonesArray*> detsAndOutTrees1;
1060 map<Int_t, TClonesArray*> detsAndOutTrees2;
1061 map<Int_t, TClonesArray*> detsAndOutTrees3;
1062
1063 for (Int_t iDet = 7; iDet < 14; iDet++)
1064 detsAndOutTrees1[iDet] = fOutArrs[iDet];
1065
1066 for (Int_t iDet = 0; iDet < 7; iDet++)
1067 detsAndOutTrees2[iDet] = fOutArrs[iDet];
1068
1069 for (Int_t iDet = 14; iDet < nDets; iDet++)
1070 detsAndOutTrees3[iDet] = fOutArrs[iDet];
1071
1072 for (Int_t iEntry = 0; iEntry < fIn1->GetEntries(); iEntry++) {
1073 fIn1->GetEntry(iEntry);
1074
1075 if (iEntry % 10000 == 0)
1076 cout << "Event# " << iEntry << endl;
1077
1078 for (auto it : detsAndOutTrees1)
1079 it.second->Delete();
1080
1081 BmnEventHeader* header = (BmnEventHeader*)fHeader1->UncheckedAt(0);
1082 fHeaderOut->SetRunId(header->GetRunId());
1083 fHeaderOut->SetEventId(header->GetEventId());
1084
1085 // Prepare arrays for GEM- and SI-converters and make
1086 Int_t* statsGem = new Int_t[fDetectorGEM->GetNStations()];
1087 Int_t* statsSil = new Int_t[fDetectorSI->GetNStations()];
1088
1089 Int_t* statsGemPermut = new Int_t[fDetectorGEM->GetNStations()];
1090 Int_t* statsSilPermut = new Int_t[fDetectorSI->GetNStations()];
1091
1092 for (Int_t iStat = 0; iStat < fDetectorGEM->GetNStations(); iStat++) {
1093 statsGem[iStat] = -1;
1094 statsGemPermut[iStat] = -1;
1095 }
1096
1097 for (Int_t iStat = 0; iStat < fDetectorSI->GetNStations(); iStat++) {
1098 statsSil[iStat] = -1;
1099 statsSilPermut[iStat] = -1;
1100 }
1101
1102 Run7(statsGem, statsSil, statsGemPermut, statsSilPermut); // FIXME!
1103
1104 for (Int_t iStat = 0; iStat < fDetectorGEM->GetNStations(); iStat++)
1105 fGemStats[statsGem[iStat]] = statsGemPermut[iStat];
1106
1107 for (Int_t iStat = 0; iStat < fDetectorSI->GetNStations(); iStat++)
1108 fSilStats[statsSil[iStat]] = statsSilPermut[iStat];
1109
1110 if (fGemDigits)
1111 for (UInt_t iDigi = 0; iDigi < fGemDigits->GetEntriesFast(); iDigi++) {
1112 BmnGemStripDigit* dig = (BmnGemStripDigit*)fGemDigits->UncheckedAt(iDigi);
1113
1114 if (dig->GetStation() == 3) // Stat3 did not work, so skipped
1115 continue;
1116
1117 if (dig->GetStation() != 8) {
1118 Int_t stat = dig->GetStation();
1119 Int_t strip = dig->GetStripNumber() - 1; // strips should be enumerated from zero
1120 Double_t signal = dig->GetStripSignal();
1121 dig->SetStation(GemStatPermutation(stat));
1122 stat = dig->GetStation(); // Stations permuted already!
1123
1124 if (stat == 0 || stat == 3 || stat == 5) {
1125 if (dig->GetModule() == 0)
1126 dig->SetModule(1);
1127 else if (dig->GetModule() == 1)
1128 dig->SetModule(0);
1129 else {
1130 cout << "Something went wrong!" << endl;
1131 throw;
1132 }
1133 }
1134 new ((*fGem)[fGem->GetEntriesFast()])
1135 BmnGemStripDigit(stat, dig->GetModule(), dig->GetStripLayer(), strip, signal);
1136 } else {
1137 // Create CSC-digi without converter
1138 BmnCSCDigit digCsc(0, dig->GetModule(), dig->GetStripLayer(), dig->GetStripNumber(),
1139 dig->GetStripSignal());
1140
1141 Int_t strip = digCsc.GetStripNumber() - 1; // strips should be enumerated from zero
1142 Double_t signal = digCsc.GetStripSignal();
1143
1144 // Modules should be permutated! (mod0 <--> mod1)
1145 if (digCsc.GetModule() == 0) {
1146 digCsc.SetModule(1);
1147 // Layers should be permutated in mod0 only
1148 if (digCsc.GetStripLayer() == 2)
1149 digCsc.SetStripLayer(0);
1150 else if (digCsc.GetStripLayer() == 3)
1151 digCsc.SetStripLayer(1);
1152 else if (digCsc.GetStripLayer() == 0)
1153 digCsc.SetStripLayer(2);
1154 else if (digCsc.GetStripLayer() == 1)
1155 digCsc.SetStripLayer(3);
1156 else {
1157 cout << "Something went wrong!" << endl;
1158 throw;
1159 }
1160 } else if (digCsc.GetModule() == 1)
1161 digCsc.SetModule(0);
1162
1163 else {
1164 cout << "Something went wrong!" << endl;
1165 throw;
1166 }
1167 new ((*fCsc)[fCsc->GetEntriesFast()])
1168 BmnCSCDigit(0, digCsc.GetModule(), digCsc.GetStripLayer(), strip, signal);
1169 }
1170 }
1171
1172 if (fSilDigits)
1173 for (UInt_t iDigi = 0; iDigi < fSilDigits->GetEntriesFast(); iDigi++) {
1174 BmnSiliconDigit* dig = (BmnSiliconDigit*)fSilDigits->UncheckedAt(iDigi);
1175 Int_t stat = dig->GetStation();
1176 dig->SetStation(SiliconStatPermutation(stat));
1177 stat = dig->GetStation(); // Stations permuted already!
1178
1179 Int_t strip = dig->GetStripNumber() - 1; // strips should be enumerated from zero
1180 Int_t signal = dig->GetStripSignal();
1181
1182 Int_t mod = dig->GetModule();
1183 Int_t layer = dig->GetStripLayer();
1184
1185 BmnSiliconDigit* outDig =
1186 new ((*fSil)[fSil->GetEntriesFast()]) BmnSiliconDigit(stat, mod, layer, strip, signal);
1187 outDig->SetIsGoodDigit(dig->IsGoodDigit());
1188 }
1189
1190 if (fMwpcDigits)
1191 FillDetDigi<BmnMwpcDigit>(fMwpcDigits, fMwpc);
1192
1193 if (fDchDigits)
1194 FillDetDigi<BmnDchDigit>(fDchDigits, fDch);
1195
1196 if (fTof400Digits)
1197 FillDetDigi<BmnTof1Digit>(fTof400Digits, fTof400);
1198
1199 if (fEcalDigits)
1200 FillDetDigi<BmnECALDigit>(fEcalDigits, fEcal);
1201
1202 for (auto it : detsAndOutTrees1)
1203 fOutTrees[it.first]->Fill();
1204 }
1205
1206 for (Int_t iEntry = 0; iEntry < fIn2->GetEntries(); iEntry++) {
1207 fIn2->GetEntry(iEntry);
1208 if (iEntry % 10000 == 0)
1209 cout << "Event# " << iEntry << endl;
1210
1211 for (auto it : detsAndOutTrees2)
1212 it.second->Delete();
1213
1214 BmnEventHeader* header = (BmnEventHeader*)fHeader2->UncheckedAt(0);
1215 fHeaderOut->SetRunId(header->GetRunId());
1216 fHeaderOut->SetEventId(header->GetEventId());
1217
1218 // Triggers
1219 const Int_t nTrigs = 6;
1220 TClonesArray* trigsIn[nTrigs] = {fBC1Digits, fBC2Digits, fBC3Digits, fVetoDigits, fSiDigits, fBdDigits};
1221 TClonesArray* trigsOut[nTrigs] = {fBC1, fBC2, fBC3, fVeto, fSi, fBd};
1222
1223 for (Int_t iTrig = 0; iTrig < nTrigs; iTrig++)
1224 if (trigsIn[iTrig])
1225 FillDetDigi<BmnTrigDigit>(trigsIn[iTrig], trigsOut[iTrig]);
1226
1227 if (fZdcDigits)
1228 FillDetDigi<BmnZDCDigit>(fZdcDigits, fZdc);
1229
1230 for (auto it : detsAndOutTrees2)
1231 fOutTrees[it.first]->Fill();
1232 }
1233
1234 for (Int_t iEntry = 0; iEntry < fIn3->GetEntries(); iEntry++) {
1235 fIn3->GetEntry(iEntry);
1236
1237 if (iEntry % 10000 == 0)
1238 cout << "Event# " << iEntry << endl;
1239
1240 for (auto it : detsAndOutTrees3)
1241 it.second->Delete();
1242
1243 fHeaderOut->SetRunId(fHeader3Obj->GetRunId());
1244 fHeaderOut->SetEventId(fHeader3Obj->GetEventId());
1245
1246 if (fTof700Digits)
1247 FillDetDigi<BmnTof2Digit>(fTof700Digits, fTof700);
1248
1249 for (auto it : detsAndOutTrees3)
1250 fOutTrees[it.first]->Fill();
1251 }
1252}
1253
1254void BmnDigiMergeTask::ProcessEvents()
1255{
1256 vector<UInt_t> nums;
1257 for (Int_t iDet = 0; iDet < nDets; iDet++)
1258 nums.push_back(fInFiles[iDet]->GetEntries());
1259
1260 maxEvId = *max_element(nums.begin(), nums.end()) + 100;
1261
1262 evId_evNum = new Long_t*[maxEvId];
1263 for (UInt_t iEle = 0; iEle < maxEvId; iEle++)
1264 evId_evNum[iEle] = new Long_t[nDets];
1265
1266 for (Long_t iEvId = 0; iEvId < maxEvId; iEvId++)
1267 for (Int_t iDet = 0; iDet < nDets; iDet++)
1268 evId_evNum[iEvId][iDet] = -1;
1269
1270 for (Int_t iDet = 0; iDet < nDets; iDet++) {
1271 BmnEventHeader* header = fHeaders[iDet];
1272 for (Int_t iEntry = 0; iEntry < fInFiles[iDet]->GetEntries(); iEntry++) {
1273 fInFiles[iDet]->GetEntry(iEntry);
1274 // cout << iDet << " " << header->GetEventId() << endl;
1275 evId_evNum[header->GetEventId()][iDet] = iEntry;
1276 }
1277 }
1278 GlueEventsFromInputFiles();
1279}
1280
1281void BmnDigiMergeTask::GlueEventsFromInputFiles()
1282{
1283 for (UInt_t iEvId = 0; iEvId < maxEvId; iEvId++) {
1284 fBC1->Delete();
1285 fBC2->Delete();
1286 fVeto->Delete();
1287 fBd->Delete();
1288 fZdc->Delete();
1289 fGem->Delete();
1290 fSil->Delete();
1291 fMwpc->Delete();
1292 fDch->Delete();
1293 fTof400->Delete();
1294 fTof700->Delete();
1295 fEcal->Delete();
1296
1297 if (isRun6 && !isSrc) {
1298 fT0->Delete();
1299 fFd->Delete();
1300 }
1301
1302 if (isRun7 && !isSrc) {
1303 fBC3->Delete();
1304 fSi->Delete();
1305 fCsc->Delete();
1306 }
1307
1308 if (isSrc) {
1309 fCsc->Delete();
1310 fBC3->Delete();
1311 fBC4->Delete();
1312
1313 fVetoTQDC->Delete();
1314
1315 fX1L->Delete();
1316 fX2L->Delete();
1317 fY1L->Delete();
1318 fY2L->Delete();
1319 fX1R->Delete();
1320 fX2R->Delete();
1321 fY1R->Delete();
1322 fY2R->Delete();
1323
1324 fX1LTQDC->Delete();
1325 fX2LTQDC->Delete();
1326 fY1LTQDC->Delete();
1327 fY2LTQDC->Delete();
1328 fX1RTQDC->Delete();
1329 fX2RTQDC->Delete();
1330 fY1RTQDC->Delete();
1331 fY2RTQDC->Delete();
1332
1333 fBC1TQDC->Delete();
1334 fBC2TQDC->Delete();
1335 fBC3TQDC->Delete();
1336 fBC4TQDC->Delete();
1337 }
1338
1339 for (Int_t iDet = 0; iDet < nDets; iDet++) {
1340 fHeaderOut->SetRunId(fHeaders[iDet]->GetRunId());
1341 fHeaderOut->SetEventId(fHeaders[iDet]->GetEventId());
1342
1343 if (evId_evNum[iEvId][iDet] % 1000 == 0)
1344 cout << "Det# " << iDet << " Event# " << evId_evNum[iEvId][iDet] << endl;
1345
1346 fInFiles[iDet]->GetEntry(evId_evNum[iEvId][iDet]);
1347
1348 fOutArrs[iDet]->AbsorbObjects(fInArrs[iDet]);
1349 }
1350
1351 fOutTree->Fill();
1352 }
1353}
1354
1355void BmnDigiMergeTask::Run7(Int_t* statsGem, Int_t* statsSil, Int_t* statsGemPermut, Int_t* statsSilPermut)
1356{
1357 // Setup is valid for two modes (BM@N and SRC)
1358 // To be moved to the UniDb
1359 if (!isSrc) {
1360 statsGem[0] = 1; // MK-numeration
1361 statsGem[1] = 2; // MK-numeration
1362 statsGem[2] = 4; // MK-numeration
1363 statsGem[3] = 5; // MK-numeration
1364 statsGem[4] = 6; // MK-numeration
1365 statsGem[5] = 7; // MK-numeration
1366
1367 statsGemPermut[0] = 0;
1368 statsGemPermut[1] = 1;
1369 statsGemPermut[2] = 2;
1370 statsGemPermut[3] = 3;
1371 statsGemPermut[4] = 4;
1372 statsGemPermut[5] = 5;
1373
1374 statsSil[0] = 1; // MK-numeration
1375 statsSil[1] = 2; // MK-numeration
1376 statsSil[2] = 3; // MK-numeration
1377
1378 statsSilPermut[0] = 0;
1379 statsSilPermut[1] = 1;
1380 statsSilPermut[2] = 2;
1381
1382 } else if (isSrc) {
1383 statsGem[0] = 1; // MK-numeration
1384 statsGem[1] = 2; // MK-numeration
1385 statsGem[2] = 3; // MK-numeration
1386 statsGem[3] = 4; // MK-numeration
1387 statsGem[4] = 5; // MK-numeration
1388 statsGem[5] = 6; // MK-numeration
1389 statsGem[6] = 7; // MK-numeration
1390 statsGem[7] = 8; // MK-numeration
1391 statsGem[8] = 9; // MK-numeration
1392 statsGem[9] = 10; // MK-numeration
1393
1394 statsGemPermut[0] = 0;
1395 statsGemPermut[1] = 1;
1396 statsGemPermut[2] = 2;
1397 statsGemPermut[3] = 3;
1398 statsGemPermut[4] = 4;
1399 statsGemPermut[5] = 5;
1400 statsGemPermut[6] = 6;
1401 statsGemPermut[7] = 7;
1402 statsGemPermut[8] = 8;
1403 statsGemPermut[9] = 9;
1404
1405 statsSil[0] = 1; // MK-numeration
1406 statsSil[1] = 2; // MK-numeration
1407 statsSil[2] = 3; // MK-numeration
1408
1409 statsSilPermut[0] = 0;
1410 statsSilPermut[1] = 1;
1411 statsSilPermut[2] = 2;
1412 } else {
1413 cout << "Configuration not defined!" << endl;
1414 throw;
1415 }
1416}
1417
1418void BmnDigiMergeTask::CreateGeometries()
1419{
1420 // Initialize det. geometries for converter
1421 TString gPathConfig = gSystem->Getenv("VMCWORKDIR");
1422 TString confSi = (!isSrc) ? "SiliconRunSpring2018.xml" : isSrc ? "SiliconRunSRCSpring2018.xml" : "";
1423 TString confGem = (!isSrc) ? "GemRunSpring2018.xml" : isSrc ? "GemRunSRCSpring2018.xml" : "";
1424 TString confCsc = "CSCRunSpring2018.xml";
1425
1426 // SI
1427 TString gPathSiliconConfig = gPathConfig + "/parameters/silicon/XMLConfigs/";
1428 fDetectorSI = new BmnSiliconStationSet(gPathSiliconConfig + confSi);
1429
1430 // GEM
1431 TString gPathGemConfig = gPathConfig + "/parameters/gem/XMLConfigs/";
1432 fDetectorGEM = new BmnGemStripStationSet(gPathGemConfig + confGem);
1433
1434 // CSC
1435 TString gPathCscConfig = gPathConfig + "/parameters/csc/XMLConfigs/";
1436 fDetectorCSC = new BmnCSCStationSet(gPathCscConfig + confCsc);
1437}
Int_t
int Int_t
Long_t
long Long_t
kFALSE
constexpr Bool_t kFALSE
Double_t
double Double_t
kTRUE
constexpr Bool_t kTRUE
gSystem
R__EXTERN TSystem * gSystem
BmnDigiMergeTask::fY1L
TClonesArray * fY1L
Definition BmnDigiMergeTask.h:142
BmnDigiMergeTask::fY1RTQDC
TClonesArray * fY1RTQDC
Definition BmnDigiMergeTask.h:154
BmnDigiMergeTask::fBC4TQDCDigits
TClonesArray * fBC4TQDCDigits
Definition BmnDigiMergeTask.h:99
BmnDigiMergeTask::fGemDigits
TClonesArray * fGemDigits
Definition BmnDigiMergeTask.h:87
BmnDigiMergeTask::fY2R
TClonesArray * fY2R
Definition BmnDigiMergeTask.h:147
BmnDigiMergeTask::fDetectorCSC
BmnCSCStationSet * fDetectorCSC
Definition BmnDigiMergeTask.h:192
BmnDigiMergeTask::fX2RTQDC
TClonesArray * fX2RTQDC
Definition BmnDigiMergeTask.h:153
BmnDigiMergeTask::fZdcDigits
TClonesArray * fZdcDigits
Definition BmnDigiMergeTask.h:90
BmnDigiMergeTask::fGemStats
map< Int_t, Int_t > fGemStats
Definition BmnDigiMergeTask.h:194
BmnDigiMergeTask::fBC2
TClonesArray * fBC2
Definition BmnDigiMergeTask.h:133
BmnDigiMergeTask::fY2RTQDC
TClonesArray * fY2RTQDC
Definition BmnDigiMergeTask.h:155
BmnDigiMergeTask::fVetoTQDCDigits
TClonesArray * fVetoTQDCDigits
Definition BmnDigiMergeTask.h:117
BmnDigiMergeTask::fY1RDigits
TClonesArray * fY1RDigits
Definition BmnDigiMergeTask.h:106
BmnDigiMergeTask::fBC3Digits
TClonesArray * fBC3Digits
Definition BmnDigiMergeTask.h:94
BmnDigiMergeTask::GemStatPermutation
Int_t GemStatPermutation(Int_t stat)
Definition BmnDigiMergeTask.h:200
BmnDigiMergeTask::fHeaders
BmnEventHeader ** fHeaders
Definition BmnDigiMergeTask.h:188
BmnDigiMergeTask::fZdc
TClonesArray * fZdc
Definition BmnDigiMergeTask.h:130
BmnDigiMergeTask::fY2RTQDCDigits
TClonesArray * fY2RTQDCDigits
Definition BmnDigiMergeTask.h:115
BmnDigiMergeTask::fX1RDigits
TClonesArray * fX1RDigits
Definition BmnDigiMergeTask.h:104
BmnDigiMergeTask::fY1LTQDCDigits
TClonesArray * fY1LTQDCDigits
Definition BmnDigiMergeTask.h:110
BmnDigiMergeTask::fX1RTQDC
TClonesArray * fX1RTQDC
Definition BmnDigiMergeTask.h:152
BmnDigiMergeTask::fBC2Digits
TClonesArray * fBC2Digits
Definition BmnDigiMergeTask.h:93
BmnDigiMergeTask::fHeader2Obj
BmnEventHeader * fHeader2Obj
Definition BmnDigiMergeTask.h:170
BmnDigiMergeTask::fTof700Digits
TClonesArray * fTof700Digits
Definition BmnDigiMergeTask.h:124
BmnDigiMergeTask::fBC1Digits
TClonesArray * fBC1Digits
Definition BmnDigiMergeTask.h:92
BmnDigiMergeTask::fHeader1
TClonesArray * fHeader1
Definition BmnDigiMergeTask.h:168
BmnDigiMergeTask::fBC3TQDC
TClonesArray * fBC3TQDC
Definition BmnDigiMergeTask.h:138
BmnDigiMergeTask::fTof400Digits
TClonesArray * fTof400Digits
Definition BmnDigiMergeTask.h:123
BmnDigiMergeTask::fY1LDigits
TClonesArray * fY1LDigits
Definition BmnDigiMergeTask.h:102
BmnDigiMergeTask::fBC3
TClonesArray * fBC3
Definition BmnDigiMergeTask.h:134
BmnDigiMergeTask::FillDetDigi
void FillDetDigi(TClonesArray *inDigiArr, TClonesArray *outDigiArr)
Definition BmnDigiMergeTask.h:216
BmnDigiMergeTask::fVeto
TClonesArray * fVeto
Definition BmnDigiMergeTask.h:157
BmnDigiMergeTask::fX1RTQDCDigits
TClonesArray * fX1RTQDCDigits
Definition BmnDigiMergeTask.h:112
BmnDigiMergeTask::fCont
BmnDigiContainer * fCont
Definition BmnDigiMergeTask.h:177
BmnDigiMergeTask::fHeaderOut
BmnEventHeader * fHeaderOut
Definition BmnDigiMergeTask.h:175
BmnDigiMergeTask::fBdDigits
TClonesArray * fBdDigits
Definition BmnDigiMergeTask.h:120
BmnDigiMergeTask::fBC1TQDCDigits
TClonesArray * fBC1TQDCDigits
Definition BmnDigiMergeTask.h:96
BmnDigiMergeTask::fX2RDigits
TClonesArray * fX2RDigits
Definition BmnDigiMergeTask.h:105
BmnDigiMergeTask::fHeader2
TClonesArray * fHeader2
Definition BmnDigiMergeTask.h:169
BmnDigiMergeTask::fTof400
TClonesArray * fTof400
Definition BmnDigiMergeTask.h:163
BmnDigiMergeTask::fMwpc
TClonesArray * fMwpc
Definition BmnDigiMergeTask.h:161
BmnDigiMergeTask::fY1RTQDCDigits
TClonesArray * fY1RTQDCDigits
Definition BmnDigiMergeTask.h:114
BmnDigiMergeTask::fHeader3
TClonesArray * fHeader3
Definition BmnDigiMergeTask.h:171
BmnDigiMergeTask::fDetectorSI
BmnSiliconStationSet * fDetectorSI
Definition BmnDigiMergeTask.h:191
BmnDigiMergeTask::fBC3TQDCDigits
TClonesArray * fBC3TQDCDigits
Definition BmnDigiMergeTask.h:98
BmnDigiMergeTask::fBC4
TClonesArray * fBC4
Definition BmnDigiMergeTask.h:135
BmnDigiMergeTask::fCsc
TClonesArray * fCsc
Definition BmnDigiMergeTask.h:128
BmnDigiMergeTask::fSi
TClonesArray * fSi
Definition BmnDigiMergeTask.h:156
BmnDigiMergeTask::fFdDigits
TClonesArray * fFdDigits
Definition BmnDigiMergeTask.h:118
BmnDigiMergeTask::fBC2TQDCDigits
TClonesArray * fBC2TQDCDigits
Definition BmnDigiMergeTask.h:97
BmnDigiMergeTask::fY2L
TClonesArray * fY2L
Definition BmnDigiMergeTask.h:143
BmnDigiMergeTask::fBC4Digits
TClonesArray * fBC4Digits
Definition BmnDigiMergeTask.h:95
BmnDigiMergeTask::fDetectorGEM
BmnGemStripStationSet * fDetectorGEM
Definition BmnDigiMergeTask.h:190
BmnDigiMergeTask::fEcalDigits
TClonesArray * fEcalDigits
Definition BmnDigiMergeTask.h:125
BmnDigiMergeTask::fSilDigits
TClonesArray * fSilDigits
Definition BmnDigiMergeTask.h:89
BmnDigiMergeTask::fCscDigits
TClonesArray * fCscDigits
Definition BmnDigiMergeTask.h:88
BmnDigiMergeTask::fT0
TClonesArray * fT0
Definition BmnDigiMergeTask.h:131
BmnDigiMergeTask::fVetoTQDC
TClonesArray * fVetoTQDC
Definition BmnDigiMergeTask.h:158
BmnDigiMergeTask::fBC1
TClonesArray * fBC1
Definition BmnDigiMergeTask.h:132
BmnDigiMergeTask::fBd
TClonesArray * fBd
Definition BmnDigiMergeTask.h:160
BmnDigiMergeTask::fMwpcDigits
TClonesArray * fMwpcDigits
Definition BmnDigiMergeTask.h:121
BmnDigiMergeTask::Run7
void Run7(Int_t *, Int_t *, Int_t *, Int_t *)
Definition BmnDigiMergeTask.cxx:1355
BmnDigiMergeTask::fX2LTQDC
TClonesArray * fX2LTQDC
Definition BmnDigiMergeTask.h:149
BmnDigiMergeTask::CreateOutputFile
void CreateOutputFile(TString)
Definition BmnDigiMergeTask.cxx:614
BmnDigiMergeTask::fX2R
TClonesArray * fX2R
Definition BmnDigiMergeTask.h:145
BmnDigiMergeTask::fY2LDigits
TClonesArray * fY2LDigits
Definition BmnDigiMergeTask.h:103
BmnDigiMergeTask::fSilStats
map< Int_t, Int_t > fSilStats
Definition BmnDigiMergeTask.h:195
BmnDigiMergeTask::fSiDigits
TClonesArray * fSiDigits
Definition BmnDigiMergeTask.h:119
BmnDigiMergeTask::fFd
TClonesArray * fFd
Definition BmnDigiMergeTask.h:159
BmnDigiMergeTask::fHeader3Obj
BmnEventHeader * fHeader3Obj
Definition BmnDigiMergeTask.h:172
BmnDigiMergeTask::fX2LTQDCDigits
TClonesArray * fX2LTQDCDigits
Definition BmnDigiMergeTask.h:109
BmnDigiMergeTask::fOutArrs
TClonesArray ** fOutArrs
Definition BmnDigiMergeTask.h:187
BmnDigiMergeTask::fY1R
TClonesArray * fY1R
Definition BmnDigiMergeTask.h:146
BmnDigiMergeTask::fT0Digits
TClonesArray * fT0Digits
Definition BmnDigiMergeTask.h:91
BmnDigiMergeTask::BmnDigiMergeTask
BmnDigiMergeTask()
Default constructor.
Definition BmnDigiMergeTask.h:27
BmnDigiMergeTask::fTof700
TClonesArray * fTof700
Definition BmnDigiMergeTask.h:164
BmnDigiMergeTask::fY2LTQDCDigits
TClonesArray * fY2LTQDCDigits
Definition BmnDigiMergeTask.h:111
BmnDigiMergeTask::fY2RDigits
TClonesArray * fY2RDigits
Definition BmnDigiMergeTask.h:107
BmnDigiMergeTask::fVetoDigits
TClonesArray * fVetoDigits
Definition BmnDigiMergeTask.h:116
BmnDigiMergeTask::fY2LTQDC
TClonesArray * fY2LTQDC
Definition BmnDigiMergeTask.h:151
BmnDigiMergeTask::fDch
TClonesArray * fDch
Definition BmnDigiMergeTask.h:162
BmnDigiMergeTask::fX2L
TClonesArray * fX2L
Definition BmnDigiMergeTask.h:141
BmnDigiMergeTask::fX1L
TClonesArray * fX1L
Definition BmnDigiMergeTask.h:140
BmnDigiMergeTask::fEcal
TClonesArray * fEcal
Definition BmnDigiMergeTask.h:165
BmnDigiMergeTask::fBC2TQDC
TClonesArray * fBC2TQDC
Definition BmnDigiMergeTask.h:137
BmnDigiMergeTask::fSil
TClonesArray * fSil
Definition BmnDigiMergeTask.h:129
BmnDigiMergeTask::fX1R
TClonesArray * fX1R
Definition BmnDigiMergeTask.h:144
BmnDigiMergeTask::fBC4TQDC
TClonesArray * fBC4TQDC
Definition BmnDigiMergeTask.h:139
BmnDigiMergeTask::fX1LTQDC
TClonesArray * fX1LTQDC
Definition BmnDigiMergeTask.h:148
BmnDigiMergeTask::fInArrs
TClonesArray ** fInArrs
Definition BmnDigiMergeTask.h:186
BmnDigiMergeTask::fX2RTQDCDigits
TClonesArray * fX2RTQDCDigits
Definition BmnDigiMergeTask.h:113
BmnDigiMergeTask::fX1LTQDCDigits
TClonesArray * fX1LTQDCDigits
Definition BmnDigiMergeTask.h:108
BmnDigiMergeTask::fDchDigits
TClonesArray * fDchDigits
Definition BmnDigiMergeTask.h:122
BmnDigiMergeTask::fX1LDigits
TClonesArray * fX1LDigits
Definition BmnDigiMergeTask.h:100
BmnDigiMergeTask::fX2LDigits
TClonesArray * fX2LDigits
Definition BmnDigiMergeTask.h:101
BmnDigiMergeTask::fBC1TQDC
TClonesArray * fBC1TQDC
Definition BmnDigiMergeTask.h:136
BmnDigiMergeTask::fY1LTQDC
TClonesArray * fY1LTQDC
Definition BmnDigiMergeTask.h:150
BmnDigiMergeTask::fGem
TClonesArray * fGem
Definition BmnDigiMergeTask.h:127
BmnDigiMergeTask::SiliconStatPermutation
Int_t SiliconStatPermutation(Int_t stat)
Definition BmnDigiMergeTask.h:202
BmnEventHeader::GetEventId
UInt_t GetEventId()
Get the event ID for this event.
Definition BmnEventHeader.h:89
BmnEventHeader::GetEventType
BmnEventType GetEventType()
Get the type of this event.
Definition BmnEventHeader.h:102
BmnStripDigit::IsGoodDigit
Bool_t IsGoodDigit()
Definition BmnStripDigit.h:32
BmnStripDigit::SetIsGoodDigit
void SetIsGoodDigit(Bool_t tmp)
Definition BmnStripDigit.h:40
BmnStripDigit::GetStripNumber
Int_t GetStripNumber()
Definition BmnStripDigit.h:29
BmnStripDigit::SetStation
void SetStation(Int_t station)
Definition BmnStripDigit.h:34
BmnStripDigit::SetStripLayer
void SetStripLayer(Int_t layer)
Definition BmnStripDigit.h:36
BmnStripDigit::GetStripLayer
Int_t GetStripLayer()
Definition BmnStripDigit.h:28
BmnStripDigit::GetStation
Int_t GetStation()
Definition BmnStripDigit.h:26
BmnStripDigit::GetStripSignal
Double_t GetStripSignal()
Definition BmnStripDigit.h:30
BmnStripDigit::GetModule
Int_t GetModule()
Definition BmnStripDigit.h:27
BmnStripDigit::SetModule
void SetModule(Int_t module)
Definition BmnStripDigit.h:35
TObject::TClonesArray
friend friend class TClonesArray
TString::Data
const char * Data() const
TString::IsNull
Bool_t IsNull() const
TString::Format
static TString Format(const char *fmt,...)