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