]>
Commit | Line | Data |
---|---|---|
c9f21053 | 1 | //////////////////////////////////////////////////////////////////////// |
2 | // | |
3 | // Class to steer several steps in merging: | |
4 | // - extraction of vertex from bgr event | |
5 | // - event simulation | |
6 | // - creation of sdigits | |
7 | // - creation of digits | |
8 | // - analysis | |
9 | // | |
10 | // Author: Jiri Chudoba (CERN), 2002 | |
11 | // | |
12 | //////////////////////////////////////////////////////////////////////// | |
13 | ||
14 | #include <iostream.h> | |
15 | ||
16 | // --- ROOT system --- | |
17 | ||
18 | #include "TTask.h" | |
19 | #include "TString.h" | |
20 | #include "TROOT.h" | |
21 | #include "TFile.h" | |
22 | #include "TTree.h" | |
23 | #include "TStopwatch.h" | |
24 | #include "TArrayF.h" | |
25 | #include "TSystem.h" | |
26 | #include "TGeometry.h" | |
27 | #include "TInterpreter.h" | |
28 | ||
29 | // --- AliRoot header files --- | |
30 | ||
31 | #include "AliRun.h" | |
32 | #include "AliHeader.h" | |
33 | #include "AliGenEventHeader.h" | |
34 | ||
35 | class AliTRDdigitizer; | |
36 | class AliPHOSSDigitizer; | |
37 | class AliTOFSDigitizer; | |
38 | ||
39 | class AliMergeSteer: public TTask { | |
40 | ||
41 | public: | |
42 | AliMergeSteer(const Text_t* name="AliMergeSteer", | |
43 | const Text_t* title="AliMergeSteer"); | |
44 | // AliMergeSteer(Option_t *option); | |
45 | virtual ~AliMergeSteer(); | |
46 | Bool_t SetDetectorFlag(Option_t* option, Int_t flag); | |
47 | Int_t GetDetectorFlag(Option_t* option); | |
48 | // void Print(); | |
49 | virtual void Exec(const Option_t *option); | |
50 | Bool_t ImportgAlice(TFile *file); | |
51 | ||
52 | Bool_t ExtractVertex(TString fn, Int_t eventNr); | |
53 | void PrintVertex(TArrayF &vertex); | |
54 | void ExportVertex(TArrayF &vertex); | |
55 | ||
56 | Bool_t Simulate(); | |
57 | Bool_t CreateSDigits(); | |
58 | Bool_t Merge(); | |
59 | Bool_t NoMerge(); | |
60 | Bool_t ITSFastPoints(const char *outputFile, const char *inputFile); | |
61 | Bool_t RecoMerged(); | |
62 | Bool_t RecoSignalOnly(); | |
63 | Bool_t CmpMerged(); | |
64 | Bool_t CmpSignalOnly(); | |
65 | ||
66 | Bool_t AliCopy(TFile *inputFile, TFile *outputFile); | |
67 | Bool_t AliCopy(TString inputFileName, TString outputFileName); | |
68 | ||
69 | ||
70 | ||
71 | // file names setter/getters | |
72 | void SetFileNameHits(TString fileName) {fFileNameHits = fileName;} | |
73 | void SetFileNameSDigits(TString fileName) {fFileNameSDigits = fileName;} | |
74 | void SetFileNameBgrHits(TString fileName) {fFileNameBgrHits = fileName;} | |
75 | void SetFileNameBgrSDigits(TString fileName) {fFileNameBgrSDigits = fileName;} | |
76 | void SetFileNameDigitsMerged(TString fileName) {fFileNameDigitsMerged = fileName;} | |
77 | void SetFileNameDigitsSignalOnly(TString fileName) {fFileNameDigitsSignalOnly = fileName;} | |
78 | TString FileNameHits() {return fFileNameHits;} | |
79 | TString FileNameSDigits() {return fFileNameSDigits;} | |
80 | TString FileNameBgr() {return fFileNameBgrSDigits;} | |
81 | TString FileNameDigitsMerged() {return fFileNameDigitsMerged;} | |
82 | TString FileNameDigitsSignalOnly() {return fFileNameDigitsSignalOnly;} | |
83 | ||
84 | // flags | |
85 | void SetFlagSim(Bool_t flag) {fFlagSim = flag;} | |
86 | void SetFlagSDigits(Bool_t flag) {fFlagSDigits = flag;} | |
87 | void SetFlagMerge(Bool_t flag) {fFlagMerge = flag;} | |
88 | void SetFlagDigitsSignalOnly(Bool_t flag) {fFlagDigitsSignalOnly = flag;} | |
89 | void SetFlagRecoMerged(Bool_t flag) {fFlagRecoMerged = flag;} | |
90 | void SetFlagRecoSignalOnly(Bool_t flag) {fFlagRecoSignalOnly = flag;} | |
91 | void SetFlagCmpMerged(Bool_t flag) {fFlagCmpMerged = flag;} | |
92 | void SetFlagCmpSignalOnly(Bool_t flag) {fFlagCmpSignalOnly = flag;} | |
93 | ||
94 | // event numbers | |
95 | void SetNEvents(Int_t nEvents) {fNEvents = nEvents;} | |
96 | void SetBgrEventNr(Int_t i) {fBgrEventNr = i;} | |
97 | ||
98 | private: | |
99 | ||
100 | TString fFileNameHits; | |
101 | TString fFileNameSDigits; | |
102 | TString fFileNameBgrHits; | |
103 | TString fFileNameBgrSDigits; | |
104 | TString fFileNameDigitsMerged; | |
105 | TString fFileNameDigitsSignalOnly; | |
106 | TString fFileNameCmpMerged; | |
107 | TString fFileNameCmpSignalOnly; | |
108 | ||
109 | Bool_t fFlagSim; | |
110 | Bool_t fFlagSDigits; | |
111 | Bool_t fFlagMerge; | |
112 | Bool_t fFlagDigitsSignalOnly; | |
113 | Bool_t fFlagRecoMerged; | |
114 | Bool_t fFlagRecoSignalOnly; | |
115 | Bool_t fFlagCmpMerged; | |
116 | Bool_t fFlagCmpSignalOnly; | |
117 | Bool_t fCopy2S; | |
118 | Bool_t fCopy2D; | |
119 | ||
120 | Int_t fNEvents; | |
121 | Int_t fFirstEvent; | |
122 | Int_t fBgrEventNr; | |
123 | ||
124 | Int_t fDEBUG; | |
125 | ||
126 | // flags for detectors - determine which detector will be used | |
127 | // during merging. | |
128 | // 0 - do not use | |
129 | // 1 - process the whole detector | |
130 | // 2 - process only active region (region of interest on) | |
131 | ||
132 | Int_t fFMD; | |
133 | Int_t fITS; | |
134 | Int_t fMUON; | |
135 | Int_t fPHOS; | |
136 | Int_t fPMD; | |
137 | Int_t fRICH; | |
138 | Int_t fSTART; | |
139 | Int_t fTOF; | |
140 | Int_t fTPC; | |
141 | Int_t fTRD; | |
142 | Int_t fZDC; | |
143 | Int_t fEMCAL; | |
144 | ||
145 | }; | |
146 | ||
147 | ||
148 | //////////////////////////////////////////////////////////////////////// | |
149 | // | |
150 | // AliMergeSteer.cxx | |
151 | // | |
152 | // | |
153 | //////////////////////////////////////////////////////////////////////// | |
154 | ||
155 | AliMergeSteer::AliMergeSteer(const Text_t *name, const Text_t* title) : TTask(name,title) | |
156 | { | |
157 | // | |
158 | // default ctor | |
159 | // | |
160 | fFileNameHits="galice.root"; | |
161 | fFileNameSDigits = "sdigits.root"; | |
162 | fFileNameBgrSDigits = "bgr.sdigits.root"; | |
163 | fFileNameBgrHits = "bgr.hits.root"; | |
164 | fFileNameDigitsMerged = "digits.root"; | |
165 | fFileNameDigitsSignalOnly = "digits.signal.root"; | |
166 | fFileNameCmpMerged = "CmpGaRS_merged.root"; | |
167 | fFileNameCmpSignalOnly = "CmpGaRS_signal.root"; | |
168 | ||
169 | fFlagSim = kFALSE; | |
170 | fFlagSDigits = kFALSE; | |
171 | fFlagMerge = kFALSE; | |
172 | fFlagDigitsSignalOnly = kFALSE; | |
173 | fFlagRecoMerged = kFALSE; | |
174 | fFlagRecoSignalOnly = kFALSE; | |
175 | fFlagCmpMerged = kFALSE; | |
176 | fFlagCmpSignalOnly = kFALSE; | |
177 | fCopy2S = kTRUE; | |
178 | fCopy2D = kTRUE; | |
179 | ||
180 | fNEvents = 1; | |
181 | fFirstEvent = 0; | |
182 | fBgrEventNr = 0; | |
183 | ||
184 | fDEBUG = 1; | |
185 | ||
186 | fFMD = 0; | |
187 | fITS = 0; | |
188 | fMUON = 0; | |
189 | fPHOS = 0; | |
190 | fPMD = 0; | |
191 | fRICH = 0; | |
192 | fSTART = 0; | |
193 | fTOF = 0; | |
194 | fTPC = 0; | |
195 | fTRD = 0; | |
196 | fZDC = 0; | |
197 | fEMCAL = 0; | |
198 | } | |
199 | ||
200 | //////////////////////////////////////////////////////////////////////// | |
201 | AliMergeSteer::~AliMergeSteer() | |
202 | { | |
203 | // default dtor | |
204 | ||
205 | } | |
206 | //////////////////////////////////////////////////////////////////////// | |
207 | void AliMergeSteer::Exec(Option_t* option) | |
208 | { | |
209 | Bool_t rc = kTRUE; | |
210 | if (gAlice) delete gAlice; | |
211 | gAlice = 0; | |
212 | ||
213 | if (fFlagSim) rc = Simulate(); | |
214 | if (!rc) {Error("Exec","Simulate wrong"); return;} | |
215 | ||
216 | if (fFlagSDigits) rc = CreateSDigits(); | |
217 | if (!rc) {Error("Exec","CreateSDigits wrong"); return;} | |
218 | ||
219 | if (fFlagSDigits && fCopy2S) rc = AliCopy(fFileNameHits,fFileNameSDigits); | |
220 | if (!rc) {Error("Exec","AliCopy to SD wrong"); return;} | |
221 | ||
222 | if (fFlagMerge && fCopy2D) rc = AliCopy(fFileNameHits,fFileNameDigitsMerged); | |
223 | if (!rc) {Error("Exec","AliCopy to DigitsMerged wrong"); return;} | |
224 | ||
225 | if (fFlagMerge) rc = Merge(); | |
226 | if (!rc) {Error("Exec","Merge wrong"); return;} | |
227 | ||
228 | if (fFlagDigitsSignalOnly) rc = NoMerge(); | |
229 | if (!rc) {Error("Exec","NoMerge wrong"); return;} | |
230 | ||
231 | if (fFlagRecoMerged) rc = RecoMerged(); | |
232 | if (!rc) {Error("Exec","RecoMerged wrong"); return;} | |
233 | ||
234 | if (fFlagRecoSignalOnly) rc = RecoSignalOnly(); | |
235 | if (!rc) {Error("Exec","RecoSignalOnly wrong"); return;} | |
236 | ||
237 | if (fFlagCmpMerged) rc = CmpMerged(); | |
238 | if (!rc) {Error("Exec","CmpMerged wrong"); return;} | |
239 | ||
240 | if (fFlagCmpSignalOnly) rc = CmpSignalOnly(); | |
241 | if (!rc) {Error("Exec","CmpSignalOnly wrong"); return;} | |
242 | ||
243 | ||
244 | ||
245 | ||
246 | } | |
247 | //////////////////////////////////////////////////////////////////////// | |
248 | Int_t AliMergeSteer::GetDetectorFlag(Option_t* option) | |
249 | { | |
250 | // | |
251 | // return current flag value for a given detector | |
252 | // | |
253 | if (strstr(option,"FMD")) { | |
254 | return fFMD; | |
255 | } else if (strstr(option,"ITS")) { | |
256 | return fITS; | |
257 | } else if (strstr(option,"MUON")) { | |
258 | return fMUON; | |
259 | } else if (strstr(option,"PHOS")) { | |
260 | return fPHOS; | |
261 | } else if (strstr(option,"PMD")) { | |
262 | return fPMD; | |
263 | } else if (strstr(option,"RICH")) { | |
264 | return fRICH; | |
265 | } else if (strstr(option,"START")) { | |
266 | return fSTART; | |
267 | } else if (strstr(option,"TOF")) { | |
268 | return fTOF; | |
269 | } else if (strstr(option,"TPC")) { | |
270 | return fTPC; | |
271 | } else if (strstr(option,"TRD")) { | |
272 | return fTRD; | |
273 | } else if (strstr(option,"ZDC")) { | |
274 | return fZDC; | |
275 | } else if (strstr(option,"EMCAL")) { | |
276 | return fEMCAL; | |
277 | } else { | |
278 | cerr<<"Unknown detector required."<<endl; | |
279 | return -1; | |
280 | } | |
281 | } | |
282 | //////////////////////////////////////////////////////////////////////// | |
283 | Bool_t AliMergeSteer::SetDetectorFlag(Option_t* option, Int_t flag) | |
284 | { | |
285 | // | |
286 | // return current flag value for a given detector | |
287 | // | |
288 | if (strstr(option,"FMD")) { | |
289 | fFMD = flag; | |
290 | } else if (strstr(option,"ITS")) { | |
291 | fITS = flag; | |
292 | } else if (strstr(option,"MUON")) { | |
293 | fMUON = flag; | |
294 | } else if (strstr(option,"PHOS")) { | |
295 | fPHOS = flag; | |
296 | } else if (strstr(option,"PMD")) { | |
297 | fPMD = flag; | |
298 | } else if (strstr(option,"RICH")) { | |
299 | fRICH = flag; | |
300 | } else if (strstr(option,"START")) { | |
301 | fSTART = flag; | |
302 | } else if (strstr(option,"TOF")) { | |
303 | fTOF = flag; | |
304 | } else if (strstr(option,"TPC")) { | |
305 | fTPC = flag; | |
306 | } else if (strstr(option,"TRD")) { | |
307 | fTRD = flag; | |
308 | } else if (strstr(option,"ZDC")) { | |
309 | fZDC = flag; | |
310 | } else if (strstr(option,"EMCAL")) { | |
311 | fEMCAL = flag; | |
312 | } else { | |
313 | cerr<<"Unknown detector required."<<endl; | |
314 | return kFALSE; | |
315 | } | |
316 | return kTRUE; | |
317 | } | |
318 | //////////////////////////////////////////////////////////////////////// | |
319 | Bool_t AliMergeSteer::ImportgAlice(TFile *file) { | |
320 | // read in gAlice object from the file | |
321 | gAlice = (AliRun*)file->Get("gAlice"); | |
322 | if (!gAlice) return kFALSE; | |
323 | return kTRUE; | |
324 | } | |
325 | //////////////////////////////////////////////////////////////////////// | |
326 | Bool_t AliMergeSteer::ExtractVertex(TString fn, Int_t eventNr) | |
327 | { | |
328 | // Open file with TPC geom and digits | |
329 | TFile *file=TFile::Open(fn); | |
330 | if (!file->IsOpen()) {cerr<<"Cannnot open "<<fn.Data()<<" !\n"; return kFALSE;} | |
331 | if (!(gAlice=(AliRun*)file->Get("gAlice"))) { | |
332 | cerr<<"gAlice was not found in "<<fn.Data()<<" !\n"; | |
333 | return kFALSE; | |
334 | } | |
335 | ||
336 | AliHeader *header = gAlice->GetHeader(); | |
337 | if (!header) { | |
338 | cerr<<"header was not found in "<<fn.Data()<<" !\n"; | |
339 | return kFALSE; | |
340 | } | |
341 | AliGenEventHeader* genEventHeader = header->GenEventHeader(); | |
342 | if (!genEventHeader) { | |
343 | cerr<<"GenEventHeader was not found in "<<fn.Data()<<" !\n"; | |
344 | return kFALSE; | |
345 | } | |
346 | ||
347 | TArrayF primaryVertex(3); | |
348 | genEventHeader->PrimaryVertex(primaryVertex); | |
349 | PrintVertex(primaryVertex); | |
350 | ExportVertex(primaryVertex); | |
351 | // delete header; | |
352 | ||
353 | // Following two lines should be there, but .... | |
354 | // delete genEventHeader; | |
355 | // delete gAlice; | |
356 | gAlice = 0; | |
357 | file->Close(); | |
358 | ||
359 | return kTRUE; | |
360 | ||
361 | } | |
362 | //////////////////////////////////////////////////////////////////////// | |
363 | void AliMergeSteer::PrintVertex(TArrayF &primaryVertex) | |
364 | { | |
365 | cout <<"CONFIG_VERTEX: " | |
366 | <<primaryVertex[0]<<" " | |
367 | <<primaryVertex[1]<<" " | |
368 | <<primaryVertex[2]<<" "<<endl; | |
369 | return; | |
370 | } | |
371 | ||
372 | //////////////////////////////////////////////////////////////////////// | |
373 | void AliMergeSteer::ExportVertex(TArrayF &primaryVertex) | |
374 | { | |
375 | char vertexAsString[30]; | |
376 | sprintf(vertexAsString,"%f",primaryVertex[0]); | |
377 | gSystem->Setenv("CONFIG_VERTEX_X",vertexAsString); | |
378 | sprintf(vertexAsString,"%f",primaryVertex[1]); | |
379 | gSystem->Setenv("CONFIG_VERTEX_Y",vertexAsString); | |
380 | sprintf(vertexAsString,"%f",primaryVertex[2]); | |
381 | gSystem->Setenv("CONFIG_VERTEX_Z",vertexAsString); | |
382 | return; | |
383 | } | |
384 | //////////////////////////////////////////////////////////////////////// | |
385 | Bool_t AliMergeSteer::Simulate() | |
386 | { | |
387 | char cmd[100]; | |
388 | TFile *f; | |
389 | ||
390 | TDirectory *saveDir = gDirectory; | |
391 | cout<< "The original directory is: "; | |
392 | saveDir->pwd(); | |
393 | if (!ExtractVertex(fFileNameBgrHits,fBgrEventNr)) { | |
394 | cerr<<" ExtractVertexAndSimulateSignal: Error in ExtractVertex"<<endl; | |
395 | return kFALSE; | |
396 | } | |
397 | saveDir->cd(); | |
398 | new AliRun("gAlice","Signal for Merging"); | |
399 | gAlice->Init("Config.C"); | |
400 | // gSystem->Setenv("CONFIG_FILE",fileNameSigHits); | |
401 | TStopwatch timer; | |
402 | timer.Start(); | |
403 | gAlice->Run(fNEvents); | |
404 | timer.Stop(); | |
405 | cout<<"Simulation of "<<fNEvents<<" of signal took: "<<endl; | |
406 | timer.Print(); | |
407 | delete gAlice; | |
408 | gAlice = 0; | |
409 | f = static_cast<TFile *>(gROOT->FindObject("galice.root")); | |
410 | if (f) f->Close(); | |
411 | f = 0; | |
412 | sprintf(cmd,"mv galice.root %s",fFileNameHits.Data()); | |
413 | gSystem->Exec(cmd); | |
414 | return kTRUE; | |
415 | ||
416 | } | |
417 | ||
418 | //////////////////////////////////////////////////////////////////////// | |
419 | Bool_t AliMergeSteer::CreateSDigits() | |
420 | { | |
421 | char macroName[200]; | |
422 | char funcName[200]; | |
423 | sprintf(macroName,"AliHits2SDigits.C"); | |
424 | sprintf(funcName, | |
425 | "AliHits2SDigits(\"%s\",\"%s\",%d,%d,%d,%d,%d,%d,%d,%d);", | |
426 | fFileNameSDigits.Data(),fFileNameHits.Data(), | |
427 | fNEvents,0,fITS,fTPC,fTRD,fPHOS,fTOF,0); | |
428 | cerr<<"I'll do: "<<funcName<<endl; | |
429 | gROOT->LoadMacro(macroName); | |
430 | if (fDEBUG) cerr<<"I'll do: "<<funcName<<endl; | |
431 | gInterpreter->ProcessLine(funcName); | |
432 | if (fDEBUG) cerr<<"SDigits created"<<endl; | |
433 | return kTRUE; | |
434 | } | |
435 | ||
436 | ||
437 | //////////////////////////////////////////////////////////////////////// | |
438 | Bool_t AliMergeSteer::Merge() | |
439 | { | |
440 | char macroName[200]; | |
441 | char funcName[200]; | |
442 | cerr<<"Start merging"<<endl; | |
443 | sprintf(macroName,"MergeV1.C"); | |
444 | sprintf(funcName, | |
445 | "Merge(\"%s\",\"%s\",\"%s\",%d,%d,%d,%d,%d,%d,%d,%d);", | |
446 | fFileNameDigitsMerged.Data(),fFileNameSDigits.Data(), | |
447 | fFileNameBgrSDigits.Data(), | |
448 | fNEvents,fITS,fTPC,fTRD,fPHOS,fMUON,fRICH,0); | |
449 | cerr<<"I'll do: "<<funcName<<endl; | |
450 | gROOT->LoadMacro(macroName); | |
451 | if (fDEBUG) cerr<<"I'll do: "<<funcName<<endl; | |
452 | gInterpreter->ProcessLine(funcName); | |
453 | if (fDEBUG) cerr<<"Merging done"<<endl; | |
454 | ||
455 | // return kTRUE; | |
456 | // add ITS fast points, no merging yet | |
457 | // return ITSFastPoints(fFileNameDigitsMerged.Data(), | |
458 | // fFileNameHits.Data()); | |
459 | ||
460 | } | |
461 | //////////////////////////////////////////////////////////////////////// | |
462 | Bool_t AliMergeSteer::NoMerge() | |
463 | { | |
464 | char macroName[200]; | |
465 | char funcName[200]; | |
466 | cerr<<"Start NoMerging"<<endl; | |
467 | sprintf(macroName,"AliSDigits2Digits.C"); | |
468 | sprintf(funcName, | |
469 | "AliSDigits2Digits(\"%s\",\"%s\",%d,%d,%d,%d,%d,%d,%d,%d);", | |
470 | fFileNameDigitsSignalOnly.Data(),fFileNameSDigits.Data(), | |
471 | fNEvents,fITS,fTPC,fTRD,fPHOS,fMUON,fRICH,0); | |
472 | if (fDEBUG) cerr<<"I'll do: "<<funcName<<endl; | |
473 | gROOT->LoadMacro(macroName); | |
474 | gInterpreter->ProcessLine(funcName); | |
475 | if (fDEBUG) cerr<<"NoMerging done"<<endl; | |
476 | // return kTRUE; | |
477 | // add ITS fast points, no merging | |
478 | // return ITSFastPoints(fFileNameDigitsSignalOnly.Data(), | |
479 | // fFileNameHits.Data()); | |
480 | ||
481 | } | |
482 | //////////////////////////////////////////////////////////////////////// | |
483 | Bool_t AliMergeSteer::ITSFastPoints(const char *outputFile, const char *inputFile) { | |
484 | ||
485 | char macroName[200]; | |
486 | char funcName[200]; | |
487 | sprintf(macroName,"AliITSHits2SDR.C"); | |
488 | sprintf(funcName,"AliITSH2FR2files(\"%s\",\"%s\");", | |
489 | inputFile, outputFile); | |
490 | if (fDEBUG) cerr<<"I'll do: "<<funcName<<endl; | |
491 | gROOT->LoadMacro(macroName); | |
492 | gInterpreter->ProcessLine(funcName); | |
493 | if (fDEBUG) cerr<<"ITSFastPoints done"<<endl; | |
494 | ||
495 | return kTRUE; | |
496 | } | |
497 | ||
498 | //////////////////////////////////////////////////////////////////////// | |
499 | Bool_t AliMergeSteer::RecoMerged() | |
500 | { | |
501 | // | |
502 | // | |
503 | // | |
504 | char macroName[200]; | |
505 | char funcName[200]; | |
506 | cerr<<"Start RecoMerged"<<endl; | |
507 | sprintf(macroName,"AliBarrelRecoV3.C"); | |
508 | sprintf(funcName,"AliBarrelRecoMerged(%d);",fNEvents); | |
509 | gROOT->LoadMacro(macroName); | |
510 | if (fDEBUG) cerr<<"I'll do: "<<funcName<<endl; | |
511 | gInterpreter->ProcessLine(funcName); | |
512 | if (fDEBUG) cerr<<"RecoMerged done"<<endl; | |
513 | return kTRUE; | |
514 | } | |
515 | ||
516 | //////////////////////////////////////////////////////////////////////// | |
517 | Bool_t AliMergeSteer::RecoSignalOnly() | |
518 | { | |
519 | // | |
520 | // | |
521 | // | |
522 | char macroName[200]; | |
523 | char funcName[200]; | |
524 | cerr<<"Start RecoSignalOnly"<<endl; | |
525 | sprintf(macroName,"AliBarrelRecoNoITSClass.C"); | |
526 | sprintf(funcName,"AliBarrelReco(%d);",fNEvents); | |
527 | gROOT->LoadMacro(macroName); | |
528 | if (fDEBUG) cerr<<"I'll do: "<<funcName<<endl; | |
529 | gInterpreter->ProcessLine(funcName); | |
530 | if (fDEBUG) cerr<<"RecoSignalOnly done"<<endl; | |
531 | return kTRUE; | |
532 | } | |
533 | ||
534 | //////////////////////////////////////////////////////////////////////// | |
535 | Bool_t AliMergeSteer::CmpMerged() | |
536 | { | |
537 | // | |
538 | // | |
539 | // | |
540 | char macroName[200]; | |
541 | char funcName[200]; | |
542 | cerr<<"Start CmpMerged"<<endl; | |
543 | sprintf(macroName,"CmpGaRS.C"); | |
544 | sprintf(funcName, | |
545 | "CmpGaRS(%d,%d,\"%s\",\"AliTPCtracks_merged.root\",\"%s\");", | |
546 | fNEvents, fFirstEvent, fFileNameHits.Data(), | |
547 | fFileNameCmpMerged.Data()); | |
548 | gROOT->LoadMacro(macroName); | |
549 | if (fDEBUG) cerr<<"I'll do: "<<funcName<<endl; | |
550 | gInterpreter->ProcessLine(funcName); | |
551 | if (fDEBUG) cerr<<"CmpMerged done"<<endl; | |
552 | return kTRUE; | |
553 | } | |
554 | //////////////////////////////////////////////////////////////////////// | |
555 | Bool_t AliMergeSteer::CmpSignalOnly() | |
556 | { | |
557 | // | |
558 | // | |
559 | // | |
560 | char macroName[200]; | |
561 | char funcName[200]; | |
562 | cerr<<"Start CmpSignalOnly"<<endl; | |
563 | sprintf(macroName,"CmpGaRS.C"); | |
564 | sprintf(funcName, | |
565 | "CmpGaRS(%d,%d,\"%s\",\"AliTPCtracks.root\",\"%s\");", | |
566 | fNEvents, fFirstEvent, fFileNameHits.Data(), | |
567 | fFileNameCmpSignalOnly.Data()); | |
568 | gROOT->LoadMacro(macroName); | |
569 | if (fDEBUG) cerr<<"I'll do: "<<funcName<<endl; | |
570 | gInterpreter->ProcessLine(funcName); | |
571 | if (fDEBUG) cerr<<"CmpSignalOnly done"<<endl; | |
572 | return kTRUE; | |
573 | } | |
574 | //////////////////////////////////////////////////////////////////////// | |
575 | Bool_t AliMergeSteer::AliCopy(TFile *inputFile, TFile *outputFile) | |
576 | { | |
577 | // | |
578 | // copy gAlice object, AliceGeom and TreeE | |
579 | // | |
580 | ||
581 | // copy gAlice | |
582 | if (fDEBUG) cout<<"Copy gAlice: "; | |
583 | outputFile->cd(); | |
584 | if (gAlice) { | |
585 | Error("AliCopy", | |
586 | "gAlice must be deleted before AliCopy is called."); | |
587 | return kFALSE; | |
588 | } | |
589 | if (!ImportgAlice(inputFile)) return kFALSE; | |
590 | gAlice->Write(); | |
591 | if (fDEBUG) cout<<"done"<<endl; | |
592 | ||
593 | ||
594 | // copy TreeE | |
595 | TTree *treeE = gAlice->TreeE(); | |
596 | if (!treeE) { | |
597 | cerr<<"No TreeE found "<<endl; | |
598 | return kFALSE; | |
599 | } | |
600 | if (fDEBUG) cout<<"Copy TreeE: "; | |
601 | AliHeader *header = new AliHeader(); | |
602 | treeE->SetBranchAddress("Header", &header); | |
603 | treeE->SetBranchStatus("*",1); | |
604 | TTree *treeENew = treeE->CloneTree(); | |
605 | treeENew->Write(); | |
606 | if (fDEBUG) cout<<"done"<<endl; | |
607 | ||
608 | // copy AliceGeom | |
609 | if (fDEBUG) cout<<"Copy AliceGeom: "; | |
610 | TGeometry *AliceGeom = static_cast<TGeometry*>(inputFile->Get("AliceGeom")); | |
611 | if (!AliceGeom) { | |
612 | cerr<<"AliceGeom was not found in the input file "<<endl; | |
613 | return kFALSE; | |
614 | } | |
615 | AliceGeom->Write(); | |
616 | if (fDEBUG) cout<<"done"<<endl; | |
617 | ||
618 | delete gAlice; | |
619 | gAlice = 0; | |
620 | ||
621 | return kTRUE; | |
622 | ||
623 | } | |
624 | ||
625 | //////////////////////////////////////////////////////////////////////// | |
626 | Bool_t AliMergeSteer::AliCopy(TString inputFileName, TString outputFileName) | |
627 | { | |
628 | // | |
629 | // open iput and output files, | |
630 | // ask to copy gAlice object, AliceGeom and TreeE | |
631 | // close input and ouput files | |
632 | // | |
633 | if (fDEBUG) { | |
634 | cout<<"AliCopy: will copy gAlice from "<<inputFileName.Data()<<" to " | |
635 | <<outputFileName.Data()<<endl; | |
636 | } | |
637 | ||
638 | TFile *inputFile = TFile::Open(inputFileName.Data()); | |
639 | if (!inputFile->IsOpen()) { | |
640 | cerr<<"Can't open "<<inputFileName.Data()<<" !\n"; | |
641 | return kFALSE; | |
642 | } | |
643 | ||
644 | TFile *outputFile = TFile::Open(outputFileName.Data(),"UPDATE"); | |
645 | if (!outputFile->IsOpen()) { | |
646 | cerr<<"Can't open "<<outputFileName.Data()<<" !\n"; | |
647 | return kFALSE; | |
648 | } | |
649 | ||
650 | AliCopy(inputFile, outputFile); | |
651 | ||
652 | inputFile->Close(); | |
653 | outputFile->Close(); | |
654 | ||
655 | if (fDEBUG) { | |
656 | cout<<"AliCopy copied gAlice from "<<inputFileName.Data()<<" to " | |
657 | <<outputFileName.Data()<<endl; | |
658 | } | |
659 | ||
660 | return kTRUE; | |
661 | } | |
662 | //////////////////////////////////////////////////////////////////////// |