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 #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 ////////////////////////////////////////////////////////////////////////