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