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