Small correction in SDigitization
authordecaro <decaro@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 16 Dec 2003 11:40:02 +0000 (11:40 +0000)
committerdecaro <decaro@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 16 Dec 2003 11:40:02 +0000 (11:40 +0000)
TOF/AliTOF.cxx
TOF/AliTOF.h
TOF/AliTOFSDigitizer.cxx
TOF/AliTOFSDigitizer.h
TOF/AliTOFanalyzeDigits.C
TOF/AliTOFanalyzeHits.C
TOF/AliTOFanalyzeSDigitsV2.C
TOF/AliTOFhits2sdigits.C

index 497097f..c843772 100644 (file)
@@ -595,6 +595,15 @@ void AliTOF::ResetDigits ()
   AliDetector::ResetDigits ();
   //
 } 
+//____________________________________________
+void AliTOF::ResetSDigits ()
+{
+  //
+  // Reset number of sdigits and the sdigits array for this detector
+  fNSDigits = 0;
+  fSDigits = 0x0;
+  //
+} 
 //_____________________________________________________________________________
 void AliTOF::Init()
 {
@@ -710,29 +719,44 @@ AliTOFMerger*  AliTOF::Merger()
     return fMerger;
 }
 
-
 //---------------------------------------------------------------------
-
 void AliTOF::Hits2SDigits()
 {
 //
 // Use the TOF SDigitizer to make TOF SDigits
 //
-//
-  //#ifdef DEBUG
-  cout<<"ALiTOF::Hits2SDigits> start...\n";
-  //#endif
+
+  cout<<"AliTOF::Hits2SDigits> start...\n";
   
-  //char * fileSDigits = 0 ;
   const char * fileHeader = fLoader->GetRunLoader()->GetFileName().Data();
-  AliTOFSDigitizer * sd = new AliTOFSDigitizer(fileHeader) ;
+  AliTOFSDigitizer * sd = new AliTOFSDigitizer(fileHeader);
+  sd->Print("");
 
   sd->Exec("") ;
+
+}
+
+//---------------------------------------------------------------------
+void AliTOF::Hits2SDigits(Int_t evNumber1, Int_t evNumber2)
+{
+//
+// Use the TOF SDigitizer to make TOF SDigits
+//
+
+  if ((evNumber2-evNumber1)==1) 
+      cout << "<AliTOF::Hits2SDigits>: I am making sdigits for the " << evNumber1 << "th event \n";
+  else if ((evNumber2-evNumber1)>1)
+      cout << "<AliTOF::Hits2SDigits>: I am making sdigits for the events from the " 
+           << evNumber1 << "th to the " << evNumber2-1 << "th \n";
+  const char * fileHeader = fLoader->GetRunLoader()->GetFileName().Data();
+  AliTOFSDigitizer * sd = new AliTOFSDigitizer(fileHeader,evNumber1,evNumber2) ;
   sd->Print("");
 
-//  delete sd ;
-  
+  sd->Exec("") ;
+
 }
+
 //___________________________________________________________________________
 AliDigitizer* AliTOF::CreateDigitizer(AliRunDigitizer* manager)
 {
index 19e8070..2598dfd 100644 (file)
@@ -76,12 +76,14 @@ public:
   virtual AliTOFMerger* Merger();
 //  virtual void    Hits2Digits();   
   virtual void    Hits2SDigits();
+  virtual void    Hits2SDigits(Int_t evNumber1, Int_t evNumber2);
   virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager); 
   virtual void    Digits2Reco() {cout << "AliTOF::Digits2Reco()  dummy function called" << endl;}
           void    Digits2Raw (Int_t evNumber=0);
           void    Raw2Digits (Int_t evNumber=0);
   virtual void    ResetHits();
   virtual void    ResetDigits();
+  virtual void    ResetSDigits();
   TClonesArray *SDigits() const {return fSDigits;}
   TClonesArray *ReconParticles() const {return fReconParticles;}
   void RecreateSDigitsArray();
index 93cd7e5..2980c51 100644 (file)
@@ -25,7 +25,6 @@
 // Use case: see AliTOFhits2sdigits.C macro in the CVS
 //////////////////////////////////////////////////////////////////////////////
 
-
 #include <Riostream.h>
 #include <stdlib.h>
 
@@ -64,63 +63,70 @@ ClassImp(AliTOFSDigitizer)
 {
   // ctor
 
-  fRunLoader     = 0 ;
+  fRunLoader      = 0;
+  fTOFLoader      = 0;
 
-  fEvent1=0;
-  fEvent2=0;
-  ftail    = 0;
-  fSelectedSector=-1; //0; // AdC
-  fSelectedPlate =-1; //0; // AdC
+  fEvent1         = 0;
+  fEvent2         = 0;
+  ftail           = 0;
+  fSelectedSector = -1;
+  fSelectedPlate  = -1;
 }
-           
+
 //____________________________________________________________________________ 
-  AliTOFSDigitizer::AliTOFSDigitizer(const char* HeaderFile, Int_t evNumber1, Int_t nEvents):TTask("AliTOFSDigitizer","") 
+AliTOFSDigitizer::AliTOFSDigitizer(const char* HeaderFile, Int_t evNumber1, Int_t nEvents):TTask("AliTOFSDigitizer","")
 {
   ftail    = 0;
-  fSelectedSector=-1; //0; // AdC // by default we sdigitize all sectors
-  fSelectedPlate =-1; //0; // AdC // by default we sdigitize all plates in all sectors
-
+  fSelectedSector=-1; // by default we sdigitize all sectors
+  fSelectedPlate =-1; // by default we sdigitize all plates in all sectors
+  
   fHeadersFile = HeaderFile ; // input filename (with hits)
-  TFile * file = (TFile*) gROOT->GetFile(fHeadersFile.Data() ) ;
-
-  //File was not opened yet
-  // open file and get alirun object
-  if(file == 0){
-      file =    TFile::Open(fHeadersFile.Data(),"update") ;
-      gAlice = (AliRun *) file->Get("gAlice") ;
+  TFile * file = (TFile*) gROOT->GetFile(fHeadersFile.Data());
+  
+  //File was not opened yet open file and get alirun object
+  if (file == 0) {
+    file   = TFile::Open(fHeadersFile.Data(),"update") ;
+    gAlice = (AliRun *) file->Get("gAlice") ;
   }
   
   // add Task to //root/Tasks folder
   fRunLoader = AliRunLoader::Open(HeaderFile);//open session and mount on default event folder
   if (fRunLoader == 0x0)
-   {
-     Fatal("AliTOFSDigitizer","Event is not loaded. Exiting");
-     return;
-   }
+    {
+      Fatal("AliTOFSDigitizer","Event is not loaded. Exiting");
+      return;
+    }
 
   fRunLoader->LoadHeader();
-  if (nEvents<0) {
-    fEvent1=0;
-    fEvent2 = (Int_t)((fRunLoader->TreeE())->GetEntries());
-  } else {
-    fEvent1=evNumber1;
-    fEvent2=fEvent1+nEvents;
+  
+  if (evNumber1>=0) fEvent1 = evNumber1;
+  else fEvent1=0;
+  
+  if (nEvents==0) fEvent2 = (Int_t)(fRunLoader->GetNumberOfEvents());
+  else if (nEvents>0) fEvent2 = evNumber1+nEvents;
+  else fEvent2 = 1;
+  
+  if (!(fEvent2>fEvent1)) {
+    cout << " ERROR: fEvent2 = " << fEvent2 << " <= fEvent1 = " << fEvent1 << endl;
+    fEvent1 = 0;
+    fEvent2 = 1;
+    cout << " Correction: fEvent2 = " << fEvent2 << " <= fEvent1 = " << fEvent1 << endl;
   }
-
+  
   // init parameters for sdigitization
   InitParameters();
-
-  AliLoader* gime = fRunLoader->GetLoader("TOFLoader");
-  if (gime == 0x0)
-   {
-     Fatal("AliTOFSDigitizer","Can not find TOF loader in event. Exiting.");
-     return;
-   }
-  gime->PostSDigitizer(this);
+  
+  fTOFLoader = fRunLoader->GetLoader("TOFLoader");
+  if (fTOFLoader == 0x0)
+    {
+      Fatal("AliTOFSDigitizer","Can not find TOF loader in event. Exiting.");
+      return;
+    }
+  fTOFLoader->PostSDigitizer(this);
 }
 
 //____________________________________________________________________________ 
-  AliTOFSDigitizer::~AliTOFSDigitizer()
+AliTOFSDigitizer::~AliTOFSDigitizer()
 {
   // dtor
 }
@@ -129,7 +135,7 @@ ClassImp(AliTOFSDigitizer)
 void AliTOFSDigitizer::InitParameters()
 {
   // set parameters for detector simulation
-
+  
   fTimeResolution =0.120;
   fpadefficiency  =0.99 ;
   fEdgeEffect     = 2   ;
@@ -157,8 +163,8 @@ void AliTOFSDigitizer::InitParameters()
   fLogChargeSmearing=0.13;
   fTimeSmearing   =0.022;
   fAverageTimeFlag=0    ;
-  fTdcBin   = 50.;      // 1 TDC bin = 50 ps
-  fAdcBin   = 0.25;     // 1 ADC bin = 0.25 pC (or 0.03 pC)
+  fTdcBin   = 50.;     // 1 TDC bin = 50 ps
+  fAdcBin   = 0.25;    // 1 ADC bin = 0.25 pC (or 0.03 pC)
   fAdcMean  = 50.;     // ADC distribution mpv value for Landau (in bins)
                        // it corresponds to a mean value of ~100 bins
   fAdcRms   = 25.;     // ADC distribution rms value (in bins)
@@ -183,40 +189,13 @@ Double_t TimeWithTail(Double_t* x, Double_t* par)
 
 
 //____________________________________________________________________________
-void AliTOFSDigitizer::Exec(Option_t *verboseOption, Option_t *allEvents) { 
+void AliTOFSDigitizer::Exec(Option_t *verboseOption) { 
 
-  fRunLoader->LoadgAlice();
-  //fRunLoader->LoadHeader();
-  fRunLoader->LoadKinematics();
-  gAlice = fRunLoader->GetAliRun();
-  
-  AliLoader* gime = fRunLoader->GetLoader("TOFLoader");
-  gime->LoadHits("read");
-  gime->LoadSDigits("recreate");
-  if(strstr(verboseOption,"tim") || strstr(verboseOption,"all"))
+  if (strstr(verboseOption,"tim") || strstr(verboseOption,"all"))
     gBenchmark->Start("TOFSDigitizer");
 
-  AliTOF *TOF = (AliTOF *) gAlice->GetDetector("TOF");
-
-  if (!TOF) {
-    Error("AliTOFSDigitizer","TOF not found");
-    return;
-  }
-
-  // is pointer to fSDigits non zero after changes?
-  cout<<"TOF fSDigits pointer:"<<TOF->SDigits()<<endl;
-
-  // recreate TClonesArray fSDigits - for backward compatibility
-  if (TOF->SDigits() == 0) {
-    TOF->CreateSDigitsArray();
-  } else {
-    TOF->RecreateSDigitsArray();
-  }
-
-  Int_t version=TOF->IsVersion();
-
   if (fEdgeTails) ftail = new TF1("tail",TimeWithTail,-2,2,3);
-
+  
   Int_t nselectedHits=0;
   Int_t ntotalsdigits=0;
   Int_t ntotalupdates=0;
@@ -226,41 +205,53 @@ void AliTOFSDigitizer::Exec(Option_t *verboseOption, Option_t *allEvents) {
   Int_t nHitsFromSec=0;
   Int_t nlargeTofDiff=0;
 
-  if (strstr(allEvents,"all")){
-    fEvent1=0;
-    fEvent2= (Int_t) gAlice->TreeE()->GetEntries();
-  }
-
-  //Bool_t thereIsNotASelection=(fSelectedSector==0) && (fSelectedPlate==0); // AdC
   Bool_t thereIsNotASelection=(fSelectedSector==-1) && (fSelectedPlate==-1);
 
-  for (Int_t ievent = fEvent1; ievent < fEvent2; ievent++) {
-    cout << "------------------- "<< GetName() << " -------------" << endl ;
-    cout << "Sdigitizing event " << ievent << endl;
+  fRunLoader->LoadgAlice();
+  gAlice = fRunLoader->GetAliRun();
 
-    Int_t nselectedHitsinEv=0;
-    Int_t ntotalsdigitsinEv=0;
-    Int_t ntotalupdatesinEv=0;
-    Int_t nnoisesdigitsinEv=0;
-    Int_t nsignalsdigitsinEv=0;
+  fRunLoader->LoadKinematics();
+  
+  AliTOF *TOF = (AliTOF *) gAlice->GetDetector("TOF");
+  
+  if (!TOF) {
+    Error("AliTOFSDigitizer","TOF not found");
+    return;
+  }
+  
+  fTOFLoader->LoadHits("read");
+  fTOFLoader->LoadSDigits("recreate");
+  
+  for (Int_t iEvent=fEvent1; iEvent<fEvent2; iEvent++) {
+    cout << "------------------- "<< GetName() << " ------------- \n";
+    cout << "Sdigitizing event " << iEvent << endl;
 
-    fRunLoader->GetEvent(ievent);
-    TOF->SetTreeAddress();
-    TTree *TH = gime->TreeH ();
-    if (!TH)
-      return;
-    if (gime->TreeS () == 0)
-      gime->MakeTree ("S");
+    fRunLoader->GetEvent(iEvent);
 
-      
-    //Make branches
-    char branchname[20];
-    sprintf (branchname, "%s", TOF->GetName ());
+    TTree *TH = fTOFLoader->TreeH ();
+    if (!TH) return;
+
+    if (fTOFLoader->TreeS () == 0) fTOFLoader->MakeTree ("S");
+    
     //Make branch for digits
     TOF->MakeBranch("S");
     
-    //Now made SDigits from hits
+    TOF->SetTreeAddress();
 
+    // recreate TClonesArray fSDigits - for backward compatibility
+    if (TOF->SDigits() == 0) {
+      TOF->CreateSDigitsArray();
+    } else {
+      TOF->RecreateSDigitsArray();
+    }
+
+    Int_t version=TOF->IsVersion();
+
+    Int_t nselectedHitsinEv=0;
+    Int_t ntotalsdigitsinEv=0;
+    Int_t ntotalupdatesinEv=0;
+    Int_t nnoisesdigitsinEv=0;
+    Int_t nsignalsdigitsinEv=0;
 
     TParticle *particle;
     //AliTOFhit *tofHit;
@@ -269,32 +260,26 @@ void AliTOFSDigitizer::Exec(Option_t *verboseOption, Option_t *allEvents) {
     // create hit map
     AliTOFHitMap *hitMap = new AliTOFHitMap(TOF->SDigits());
 
-    // increase performances in terms of CPU time
-    //PH     TH->SetBranchStatus("*",0); // switch off all branches
-    //PH     TH->SetBranchStatus("TOF*",1); // switch on only TOF
-
     TBranch * tofHitsBranch = TH->GetBranch("TOF");
 
     Int_t ntracks = static_cast<Int_t>(TH->GetEntries());
     for (Int_t track = 0; track < ntracks; track++)
     {
       gAlice->ResetHits();
-      //PH      TH->GetEvent(track);
       tofHitsBranch->GetEvent(track);
       particle = gAlice->GetMCApp()->Particle(track);
       Int_t nhits = TOFhits->GetEntriesFast();
       // cleaning all hits of the same track in the same pad volume
       // it is a rare event, however it happens
 
-      Int_t previousTrack =-1; //0; // AdC
-      Int_t previousSector=-1; //0; // AdC
-      Int_t previousPlate =-1; //0; // AdC
-      Int_t previousStrip =-1; //0; // AdC
-      Int_t previousPadX  =-1; //0; // AdC
-      Int_t previousPadZ  =-1; //0; // AdC
+      Int_t previousTrack =-1;
+      Int_t previousSector=-1;
+      Int_t previousPlate =-1;
+      Int_t previousStrip =-1;
+      Int_t previousPadX  =-1;
+      Int_t previousPadZ  =-1;
 
-      for (Int_t hit = 0; hit < nhits; hit++)
-      {
+      for (Int_t hit = 0; hit < nhits; hit++) {
        Int_t    vol[5];       // location for a digit
        Float_t  digit[2];     // TOF digit variables
        Int_t tracknum;
@@ -327,9 +312,9 @@ void AliTOFSDigitizer::Exec(Option_t *verboseOption, Option_t *allEvents) {
          Zpad = tofHit->GetDz();
          geantTime = tofHit->GetTof(); // unit [s]
        }
-
+       
        geantTime *= 1.e+09;  // conversion from [s] to [ns]
-           
+       
        // selection case for sdigitizing only hits in a given plate of a given sector
        if(thereIsNotASelection || (vol[0]==fSelectedSector && vol[1]==fSelectedPlate)){
          
@@ -351,16 +336,11 @@ void AliTOFSDigitizer::Exec(Option_t *verboseOption, Option_t *allEvents) {
            
            nselectedHits++;
            nselectedHitsinEv++;
-           if (particle->GetFirstMother() < 0){
-             nHitsFromPrim++;
-           } // counts hits due to primary particles
+           if (particle->GetFirstMother() < 0) nHitsFromPrim++; // counts hits due to primary particles
            
-           //Float_t xStrip=AliTOFConstants::fgkXPad*(vol[3]-0.5-0.5*AliTOFConstants::fgkNpadX)+Xpad;
-           //Float_t zStrip=AliTOFConstants::fgkZPad*(vol[4]-0.5-0.5*AliTOFConstants::fgkNpadZ)+Zpad;
-           Float_t xStrip=AliTOFConstants::fgkXPad*(vol[3]+0.5-0.5*AliTOFConstants::fgkNpadX)+Xpad; // AdC
-           Float_t zStrip=AliTOFConstants::fgkZPad*(vol[4]+0.5-0.5*AliTOFConstants::fgkNpadZ)+Zpad; // AdC
+           Float_t xStrip=AliTOFConstants::fgkXPad*(vol[3]+0.5-0.5*AliTOFConstants::fgkNpadX)+Xpad;
+           Float_t zStrip=AliTOFConstants::fgkZPad*(vol[4]+0.5-0.5*AliTOFConstants::fgkNpadZ)+Zpad;
 
-           //cout << "geantTime " << geantTime << " [ns]" << endl;
            Int_t nActivatedPads = 0, nFiredPads = 0;
            Bool_t isFired[4] = {kFALSE, kFALSE, kFALSE, kFALSE};
            Float_t tofAfterSimul[4] = {0., 0., 0., 0.};
@@ -379,15 +359,14 @@ void AliTOFSDigitizer::Exec(Option_t *verboseOption, Option_t *allEvents) {
                  
                  Float_t landauFactor = gRandom->Landau(fAdcMean, fAdcRms); 
                  digit[1] = (Int_t) (qInduced[indexOfPad] * landauFactor); // ADC bins (each bin -> 0.25 (or 0.03) pC)
-                 
+
                  // recalculate the volume only for neighbouring pads
                  if(indexOfPad){
-                   (nPlace[indexOfPad]<=AliTOFConstants::fgkNpadX) ? vol[4] = 0/*1*/ : vol[4] = 1/*2*/; // AdC
-                   (nPlace[indexOfPad]<=AliTOFConstants::fgkNpadX) ? vol[3] = nPlace[indexOfPad] - 1 : vol[3] = nPlace[indexOfPad] - AliTOFConstants::fgkNpadX - 1; // AdC
+                   (nPlace[indexOfPad]<=AliTOFConstants::fgkNpadX) ? vol[4] = 0 : vol[4] = 1;
+                   (nPlace[indexOfPad]<=AliTOFConstants::fgkNpadX) ? vol[3] = nPlace[indexOfPad] - 1 : vol[3] = nPlace[indexOfPad] - AliTOFConstants::fgkNpadX - 1;
                  }
-                 
-                 // check if two sdigit are on the same pad; in that case we sum
-                 // the two or more sdigits
+                 // check if two sdigit are on the same pad;
+                 // in that case we sum the two or more sdigits
                  if (hitMap->TestHit(vol) != kEmpty) {
                    AliTOFSDigit *sdig = static_cast<AliTOFSDigit*>(hitMap->GetHit(vol));
                    Int_t tdctime = (Int_t) digit[0];
@@ -419,25 +398,31 @@ void AliTOFSDigitizer::Exec(Option_t *verboseOption, Option_t *allEvents) {
     } // end loop on ntracks
     
     delete hitMap;
-      
-    gime->TreeS()->Reset();
-    gime->TreeS()->Fill();
-    //gAlice->TreeS()->Write(0,TObject::kOverwrite) ;
-    gime->WriteSDigits("OVERWRITE");
-
-    if(strstr(verboseOption,"all")){
-      cout << "----------------------------------------" << endl;
-      cout << "       <AliTOFSDigitizer>     " << endl;
-      cout << "After sdigitizing " << nselectedHitsinEv << " hits" << " in event " << ievent << endl;
+    
+    fTOFLoader->TreeS()->Reset();
+    fTOFLoader->TreeS()->Fill();
+    fTOFLoader->WriteSDigits("OVERWRITE");
+    
+    if (TOF->SDigits()) TOF->ResetSDigits();
+    
+    if (strstr(verboseOption,"all")) {
+      cout << "---------------------------------------- \n";
+      cout << "       <AliTOFSDigitizer>    \n";
+      cout << "After sdigitizing " << nselectedHitsinEv << " hits" << " in event " << iEvent << endl;
       //" (" << nHitsFromPrim << " from primaries and " << nHitsFromSec << " from secondaries) TOF hits, " 
-      cout << ntotalsdigitsinEv << " digits have been created " << endl;
-      cout << "(" << nsignalsdigitsinEv << " due to signals and " <<  nnoisesdigitsinEv << " due to border effect)" << endl;
-      cout << ntotalupdatesinEv << " total updates of the hit map have been performed in current event" << endl;
-      cout << "----------------------------------------" << endl;
+      cout << ntotalsdigitsinEv << " digits have been created \n";
+      cout << "(" << nsignalsdigitsinEv << " due to signals and " <<  nnoisesdigitsinEv << " due to border effect) \n";
+      cout << ntotalupdatesinEv << " total updates of the hit map have been performed in current event \n";
+      cout << "---------------------------------------- \n";
     }
 
   } //event loop on events
 
+    fTOFLoader->UnloadSDigits();
+    fTOFLoader->UnloadHits();
+    fRunLoader->UnloadKinematics();
+    fRunLoader->UnloadgAlice();
+
   // free used memory
   if (ftail){
     delete ftail;
@@ -446,54 +431,51 @@ void AliTOFSDigitizer::Exec(Option_t *verboseOption, Option_t *allEvents) {
   
   nHitsFromSec=nselectedHits-nHitsFromPrim;
   if(strstr(verboseOption,"all")){
-    cout << "----------------------------------------" << endl;
-    cout << "----------------------------------------" << endl;
-    cout << "-----------SDigitization Summary--------" << endl;
-    cout << "       <AliTOFSDigitizer>     " << endl;
-    cout << "After sdigitizing " << nselectedHits << " hits" << endl;
-    cout << "in " << (fEvent2-fEvent1) << " events" << endl;
+    cout << "---------------------------------------- \n";
+    cout << "---------------------------------------- \n";
+    cout << "-----------SDigitization Summary-------- \n";
+    cout << "       <AliTOFSDigitizer>     \n";
+    cout << "After sdigitizing " << nselectedHits << " hits  \n";
+    cout << "in " << (fEvent2-fEvent1) << " events  \n";
 //" (" << nHitsFromPrim << " from primaries and " << nHitsFromSec << " from secondaries) TOF hits, " 
-    cout << ntotalsdigits << " sdigits have been created " << endl;
-    cout << "(" << nsignalsdigits << " due to signals and " <<  nnoisesdigits << " due to border effect)" << endl;
-    cout << ntotalupdates << " total updates of the hit map have been performed" << endl;
-    cout << "in " << nlargeTofDiff << " cases the time of flight difference is greater than 200 ps" << endl;
+    cout << ntotalsdigits << " sdigits have been created \n";
+    cout << "(" << nsignalsdigits << " due to signals and " 
+         <<  nnoisesdigits << " due to border effect) \n";
+    cout << ntotalupdates << " total updates of the hit map have been performed \n";
+    cout << "in " << nlargeTofDiff << " cases the time of flight difference is greater than 200 ps \n";
   }
 
 
   if(strstr(verboseOption,"tim") || strstr(verboseOption,"all")){
     gBenchmark->Stop("TOFSDigitizer");
-    cout << "AliTOFSDigitizer:" << endl ;
+    cout << "AliTOFSDigitizer: \n";
     cout << "   took " << gBenchmark->GetCpuTime("TOFSDigitizer") << " seconds in order to make sdigits " 
-        <<  gBenchmark->GetCpuTime("TOFSDigitizer")/(fEvent2-fEvent1) << " seconds per event " << endl ;
-    cout << endl ;
+        <<  gBenchmark->GetCpuTime("TOFSDigitizer")/(fEvent2-fEvent1) << " seconds per event \n";
+    cout << " +++++++++++++++++++++++++++++++++++++++++++++++++++  \n";
   }
 
-  Print("");
 }
 
 //__________________________________________________________________
 void AliTOFSDigitizer::Print(Option_t* /*opt*/)const
 {
-  cout << "------------------- "<< GetName() << " -------------" << endl ;
-
+  cout << "------------------- "<< GetName() << " ------------- \n";
 }
 
 //__________________________________________________________________
 void AliTOFSDigitizer::SelectSectorAndPlate(Int_t sector, Int_t plate)
 {
-  //Bool_t isaWrongSelection=(sector < 1) || (sector > AliTOFConstants::fgkNSectors) || (plate < 1) || (plate > AliTOFConstants::fgkNPlates);
-  Bool_t isaWrongSelection=(sector < 0) || (sector >= AliTOFConstants::fgkNSectors) || (plate < 0) || (plate >= AliTOFConstants::fgkNPlates); // AdC
+  Bool_t isaWrongSelection=(sector < 0) || (sector >= AliTOFConstants::fgkNSectors) || (plate < 0) || (plate >= AliTOFConstants::fgkNPlates);
   if(isaWrongSelection){
     cout << "You have selected an invalid value for sector or plate " << endl;
-    //cout << "The correct range for sector is [1,"<< AliTOFConstants::fgkNSectors <<"]" << endl;
-    //cout << "The correct range for plate  is [1,"<< AliTOFConstants::fgkNPlates  <<"]" << endl;
-    cout << "The correct range for sector is [0,"<< AliTOFConstants::fgkNSectors-1 <<"]\n"; // AdC
-    cout << "The correct range for plate  is [0,"<< AliTOFConstants::fgkNPlates-1  <<"]\n"; // AdC
-    cout << "By default we continue sdigitizing all hits in all plates of all sectors" << endl;
+    cout << "The correct range for sector is [0,"<< AliTOFConstants::fgkNSectors-1 <<"]\n";
+    cout << "The correct range for plate  is [0,"<< AliTOFConstants::fgkNPlates-1  <<"]\n";
+    cout << "By default we continue sdigitizing all hits in all plates of all sectors \n";
   } else {
     fSelectedSector=sector;
     fSelectedPlate =plate;
-    cout << "SDigitizing only hits in plate " << fSelectedPlate << " of the sector " << fSelectedSector << endl;
+    cout << "SDigitizing only hits in plate " << fSelectedPlate << " of the sector " 
+         << fSelectedSector << endl;
   }
 }
 
index 20b7e88..7d484a1 100644 (file)
@@ -13,6 +13,7 @@
 #include "TTask.h"
 #include "TString.h"
 class AliRunLoader;
+class AliLoader;
 
 class TF1;
 
@@ -20,19 +21,20 @@ class AliTOFSDigitizer: public TTask {
 
 public:
   AliTOFSDigitizer() ;          // ctor
-  AliTOFSDigitizer(const char* HeaderFile, Int_t evNumber1=0, Int_t nEvents=-1) ; // par ctor
+  //AliTOFSDigitizer(const char* HeaderFile) ; // par ctor
+  AliTOFSDigitizer(const char* HeaderFile, Int_t evNumber1=-1, Int_t nEvents=0) ; // par ctor
 
   virtual ~AliTOFSDigitizer() ; // dtor
 
-  virtual void  Exec(Option_t *verboseOption, Option_t *allEvents="noAll"); 
+  virtual void  Exec(Option_t *verboseOption); 
   void SetSDigitsFile(char * /*file*/ ) {;}
   
   void InitParameters();
   virtual void PrintParameters() const ;
-  virtual void  SimulateDetectorResponse(Float_t z0, Float_t x0, Float_t geantTime, Int_t& nActivatedPads, Int_t& nFiredPads, Bool_t* isFired, Int_t* nPlace, Float_t* qInduced, Float_t* tofTime, Float_t& averageTime);
+  virtual void SimulateDetectorResponse(Float_t z0, Float_t x0, Float_t geantTime, Int_t& nActivatedPads, Int_t& nFiredPads, Bool_t* isFired, Int_t* nPlace, Float_t* qInduced, Float_t* tofTime, Float_t& averageTime);
   virtual void Print(Option_t* opt) const ;
-  void  SetFirstEvent(Int_t event1)      {fEvent1=event1;}
-  void  SetSecondEvent(Int_t event2)     {fEvent2=event2;}
+  void  SetFirstEvent(Int_t event1)      {fEvent1 = event1;}
+  void  SetSecondEvent(Int_t event2)     {fEvent2 = event2;}
   Int_t GetFirstEvent()  const {return fEvent1;}
   Int_t GetSecondEvent() const {return fEvent2;}
   Int_t GetNEvents() const {return (fEvent2-fEvent1);}
@@ -107,7 +109,8 @@ private:
   Int_t   fEvent2;          // upper bound for events to sdigitize
   TF1     *ftail;           // pointer to formula for time with tail
   TString fHeadersFile;     // input file
-  AliRunLoader* fRunLoader;  //! Run Loader
+  AliRunLoader* fRunLoader; //! Run Loader
+  AliLoader* fTOFLoader;    //! Loader
   
 
   Int_t fSelectedSector;    // sector number for sdigitization
@@ -119,11 +122,11 @@ private:
   Float_t fpadefficiency;   // intrinsic pad efficiency, used if fEdgeEffect==0
   Int_t   fEdgeEffect;      // edge effects option
   Int_t   fEdgeTails;       // edge tails option
-  Float_t fHparameter;      // sensitive edge (to produce hits on the
-  // neighbouring pads) =0.7, new = 0.4 cm
+  Float_t fHparameter;      // sensitive edge (to produce hits on the neighbouring pads)
+                            //                 0.7 cm (old); 0.4 cm (new)
   Float_t fH2parameter;     // parameter to fit the efficiency
-  Float_t fKparameter;      // sensitive edge (going ahead towards the
-  // center no delay effects are suffered) =1.0, new = 0.5 cm
+  Float_t fKparameter;      // sensitive edge (going ahead towards the center
+                            // no delay effects are suffered) 1.0 cm (old); 0.5 cm (new)
   Float_t fK2parameter;     // parameter to fit the efficiency
   // Pad Efficiency and Resolution parameters
   Float_t fEffCenter;       // efficiency in the central region of the pad
index 7bccbac..cb26abd 100644 (file)
@@ -1,11 +1,17 @@
-Int_t AliTOFanalyzeDigits(Int_t ndump=15, Int_t iEvNum=0)
+Int_t AliTOFanalyzeDigits(Int_t ndump=0, Int_t numberOfEvents=0)
 {
+
+  /////////////////////////////////////////////////////////////////////////
   //
   // Analyzes the TOF digits and fills QA-histograms 
-  // report problems to pierella@bo.infn.it
-  // iEvNum=0 means all events in the file
+  // numberOfEvents=0 means all events in the file
+  //
   // Author: F. Pierella (Bologna University)
   // Updated to the new I/O by: A. De Caro, C. Zampolli
+  //
+  // Report problems to decaro@sa.infn.it
+  //
+  /////////////////////////////////////////////////////////////////////////
 
   Int_t rc = 0;
   
@@ -62,18 +68,14 @@ Int_t AliTOFanalyzeDigits(Int_t ndump=15, Int_t iEvNum=0)
       return rc;
     }
   
-  cout << "First " << ndump << " Digits found in TOF TreeD branch have:" << endl;
-
- if (iEvNum == 0) 
-    { 
-      rl->LoadHeader();
-      TTree *TE = rl->TreeE();
-      iEvNum = (Int_t)TE->GetEntries();
-    } 
+  if (ndump) cout << "First " << ndump << " Digits found in TOF TreeD branch have: \n";
+
+  rl->LoadHeader();
+  if (numberOfEvents == 0) numberOfEvents = (Int_t)(rl->GetNumberOfEvents());
   
   AliTOFdigit *tofdigit;  
 
-  for (Int_t ievent = 0; ievent < iEvNum; ievent++) {
+  for (Int_t ievent = 0; ievent < numberOfEvents; ievent++) {
     printf ("Processing event %d \n", ievent);
     rl->GetEvent(ievent);
     
@@ -126,9 +128,9 @@ Int_t AliTOFanalyzeDigits(Int_t ndump=15, Int_t iEvNum=0)
            }
          
          if(k<ndump){
-           cout << k << "-th | " << "Sector " << sector << " | Plate " << plate << " | Strip " << strip << " | PadZ " << padz << " | PadX " << padx << endl;
-           cout << k << "-th | ADC " << adc << " [bin] | TDC " << tdc << " [bin]" << endl;
-           cout << "----------------------------------------------------"<< endl;
+           cout << k << "-th | Sector " << sector << " | Plate " << plate << " | Strip " << strip << " | PadZ " << padz << " | PadX " << padx << endl;
+           cout << k << "-th | ADC " << adc << " [bin] | TDC " << tdc << " [bin] \n";
+           cout << "---------------------------------------------------- \n";
          }
          
          // filling digit volume histos
@@ -143,11 +145,12 @@ Int_t AliTOFanalyzeDigits(Int_t ndump=15, Int_t iEvNum=0)
       }
     
     tofl->UnloadDigits();
-    rl->UnloadHeader();
-    rl->UnloadgAlice();
   
   } // end loop on events
   
+  rl->UnloadHeader();
+  rl->UnloadgAlice();
+
   TFile *fout = new TFile("TOF_digitsQA.root","RECREATE");
   htdc->Write();
   hadc->Write();
index f41b6a6..10a4182 100644 (file)
@@ -1,13 +1,30 @@
-Int_t AliTOFanalyzeHits(Int_t nevents = 1, Bool_t drawing = kFALSE)
+Int_t AliTOFanalyzeHits(Int_t numberOfEvents=0, Bool_t drawing=kFALSE)
 {
+
+  /////////////////////////////////////////////////////////////////////////
+  //
+  // Analyzes TOF hits and fills QA-histograms
+  // and writes the histograms in the TOF_hitsQA.root file
   //
-  // Analyzes the hits and fills QA-histograms 
   // Use case:
   // start aliroot
   // root [0] .L AliTOFanalyzeHits.C
   // root [1] AliTOFanalyzeHits()
   //
-  // Updated to the new I/O by: A. De Caro, C. Zampolli
+  // By default, it analyzes hits for all the events in the header file
+  // and does not draw the histograms filled
+  //
+  // If you want analyze hits only the 1th event
+  // you can use the following line:
+  //
+  // root[0] .L AliTOFanalyzeHits.C
+  // root[1] AliTOFanalyzeHits(1)
+  //
+  // Updated to the new I/O: C. Zampolli
+  //
+  // Report problems to decaro@sa.infn.it
+  //
+  /////////////////////////////////////////////////////////////////////////
 
   Int_t rc = 0;
   
@@ -54,39 +71,41 @@ Int_t AliTOFanalyzeHits(Int_t nevents = 1, Bool_t drawing = kFALSE)
       delete gAlice;
       gAlice = 0x0;
     }
-  
+
   AliRunLoader *rl = AliRunLoader::Open("galice.root",AliConfig::fgkDefaultEventFolderName,"read");
   if (!rl)
     {
-      cerr<<"Can't load RunLoader from file"<<"!\n";
+      cerr<<"Can't load RunLoader from file! \n";
       rc = 1;
       return rc;
     }
-  
+
   rl->LoadgAlice();
   gAlice = rl->GetAliRun();
 
   if (!gAlice)
     {
-      cerr << "<AliTOFanalyzeHits> AliRun object not found on file\n ";
+      cerr << "<AliTOFanalyzeHits> AliRun object not found on file \n";
       rc = 2;
       return rc;
     }
 
+  rl->LoadHeader();
+
   // Get the pointer to the TOF detector
-  AliTOF *tof = (AliTOF *) gAlice->GetDetector("TOF");
   AliLoader *tofl = rl->GetLoader("TOFLoader");
+  AliTOF *tof = (AliTOF *) gAlice->GetDetector("TOF");
   if (tof == 0x0 || tofl == 0x0) {
-    cerr << "<AliTOFanalyzeHits> Can not find TOF or TOFLoader\n";
+    cerr << "<AliTOFanalyzeHits> Can not find TOF or TOFLoader \n";
     rc = 3;
     return rc;
   }
 
   Int_t countHits = 0;
 
-  rl->LoadHeader();
+  if (numberOfEvents==0) numberOfEvents=(Int_t)(rl->GetNumberOfEvents());
 
-  for (Int_t ievent=0; ievent<nevents; ievent++) {
+  for (Int_t ievent=0; ievent<numberOfEvents; ievent++) {
     printf ("Processing event %d \n", ievent);
     rl->GetEvent(ievent);
 
@@ -107,7 +126,7 @@ Int_t AliTOFanalyzeHits(Int_t nevents = 1, Bool_t drawing = kFALSE)
     // (Number of primary particles creating a hit somewhere)
     Int_t nTrack = (Int_t) hitTree->GetEntries();
     cout << "<AliTOFanalyzeHits> Found " << nTrack 
-         << " primary particles with hits" << endl;
+         << " primary particles with hits \n";
 
     Int_t nPrimaryOnTof = 0;
     Int_t nSecondaryOnTof = 0;
@@ -155,23 +174,21 @@ Int_t AliTOFanalyzeHits(Int_t nevents = 1, Bool_t drawing = kFALSE)
         Int_t padx   = hit->GetPadx();   // range [1-48]
         // it is QA, then I perform QA!
 
-       
         Bool_t isHitBad = (sector<0 || sector>17 || 
-                          plate<0 || plate>4 || 
-                          padz<0 || padz>1 || 
-                          padx<0 || padx>47 ||
-
+                           plate<0 || plate>4   || 
+                            padz<0 || padz>1    || 
+                            padx<0 || padx>47   ||
                           ((strip<0 || strip>14) && plate == 2) ||
                           ((strip<0 || strip>18) && (plate == 1 || plate == 3)) ||
                           ((strip<0 || strip>19) && (plate == 0 || plate == 4)));
-       
+
        if (isHitBad) {
           cout << "<AliTOFanalyzeHits>  strange hit found \n";
          cout << "sector = " << sector <<
-           " plate = " << plate <<
-           " strip = " << strip <<
-           " padx = " << padx <<
-           " padz = " << padz << endl;
+                 " plate = " << plate <<
+                 " strip = " << strip <<
+                 " padx = " << padx <<
+                 " padz = " << padz << endl;
          rc = 5;
          return rc;
         }
@@ -198,9 +215,9 @@ Int_t AliTOFanalyzeHits(Int_t nevents = 1, Bool_t drawing = kFALSE)
         hstrip->Fill(strip);
         hpadx->Fill(padx);
         hpadz->Fill(padz);
-
+/*
         Int_t track = hit->Track();
-        TParticle *part = gAlice->Particle(track);
+        TParticle *part = gAlice->GetMCApp()->Particle(track);
 
         // getting MC info for the current track
         if (part->GetFirstMother()<0){
@@ -229,7 +246,7 @@ Int_t AliTOFanalyzeHits(Int_t nevents = 1, Bool_t drawing = kFALSE)
          htofs->Fill(flightTime);
          htofmoms->Fill(tofmom);
         }
-
+*/
         // go to next hit
         hit = (AliTOFhitT0 *) tof->NextHit();
 
@@ -240,12 +257,12 @@ Int_t AliTOFanalyzeHits(Int_t nevents = 1, Bool_t drawing = kFALSE)
     tofl->UnloadHits();
     rl->UnloadKinematics();
 
-    cout << "<AliTOFanalyzeHits> Found " << countHits << " hits in total" << endl;
-    cout << npion     << " primary pions reached the TOF detector"     << endl;
-    cout << nkaon     << " primary kaons reached the TOF detector"     << endl;
-    cout << nproton   << " primary protons reached the TOF detector"   << endl;
-    cout << nelectron << " primary electrons reached the TOF detector" << endl;
-    cout << nmuon     << " primary muons reached the TOF detector"     << endl;
+    cout << "<AliTOFanalyzeHits> Found " << countHits << " hits in total \n";
+    cout << npion     << " primary pions reached the TOF detector \n";
+    cout << nkaon     << " primary kaons reached the TOF detector \n";
+    cout << nproton   << " primary protons reached the TOF detector \n";
+    cout << nelectron << " primary electrons reached the TOF detector \n";
+    cout << nmuon     << " primary muons reached the TOF detector \n";
 
   }
 
@@ -324,7 +341,7 @@ Int_t AliTOFanalyzeHits(Int_t nevents = 1, Bool_t drawing = kFALSE)
       delete gAlice;
       gAlice = 0x0;
     }
-  
+
   return rc;
 
 }
index e5012ea..20e0ba0 100644 (file)
@@ -1,11 +1,25 @@
-Int_t AliTOFanalyzeSDigitsV2(Int_t ndump=15, Int_t iEvNum=0)
+Int_t AliTOFanalyzeSDigitsV2(Int_t ndump=0, Int_t iEvNum=-1, Int_t nEvent=0)
 {
+
+  /////////////////////////////////////////////////////////////////////////
   //
   // Analyzes the TOF sdigits and fills QA-histograms 
-  // report problems to pierella@bo.infn.it
-  // iEvNum=0 means all events in the file
+  // iEvNum=-1 and nEvent=0 means all events in the file
+  // 
+  // root[0] .L AliTOFanalyzeSDigitsV2.C
+  // root[1] AliTOFanalyzeSDigitsV2()
+  //
+  // If you want analyze only the sdigits in the 2th event
+  // (existing int the header file), see in the following:
+  //
+  // root[0] .L AliTOFanalyzeSDigitsV2.C
+  // root[1] AliTOFanalyzeSDigitsV2(0,2,1)
   //
   // Updated to the new I/O by: A. De Caro, C. Zampolli
+  //
+  // Report problems to: decaro@sa.infn.it
+  //
+  /////////////////////////////////////////////////////////////////////////
 
   Int_t rc = 0;
 
@@ -52,6 +66,8 @@ Int_t AliTOFanalyzeSDigitsV2(Int_t ndump=15, Int_t iEvNum=0)
       return rc;
     }
 
+  rl->LoadHeader();
+
   AliLoader *tofl = rl->GetLoader("TOFLoader");
   AliTOF *tof = (AliTOF *) rl->GetAliRun()->GetDetector("TOF");
 
@@ -62,35 +78,39 @@ Int_t AliTOFanalyzeSDigitsV2(Int_t ndump=15, Int_t iEvNum=0)
       return rc;
     }
   
-  cout << "First " << ndump << " SDigits found in TOF TreeS branch have:" << endl;
+  cout << "First " << ndump << " SDigits found in TOF TreeS branch have: \n";
 
-  if (iEvNum == 0)
-    {
-      rl->LoadHeader();
-      TTree *TE = rl->TreeE();
-      iEvNum = (Int_t)TE->GetEntries();
-    }
+  Int_t upperLimit;
+  Int_t bottomLimit;
+
+  if (iEvNum<0) bottomLimit=0;
+  else bottomLimit = iEvNum;
+
+  if (nEvent == 0) upperLimit = (Int_t)(rl->GetNumberOfEvents());
+  else upperLimit = nEvent+bottomLimit;
 
   AliTOFSDigit *tofsdigit;
   
-  for (Int_t ievent = 0; ievent < iEvNum; ievent++) {
-    printf ("Processing event %d \n", ievent);
+  for (Int_t ievent = bottomLimit; ievent < upperLimit; ievent++) {
+
     rl->GetEvent(ievent);
+    printf ("Processing event %d \n", ievent);
     
     // Get the pointer SDigit tree
-    tofl->LoadSDigits();
+    tofl->LoadSDigits("read");
     TTree *TS=tofl->TreeS();
     tof->SetTreeAddress();
     
     if(!TS)
       {
-       cout << "<AliTOFanalyzeSDigits> No TreeS found" << endl;
+       cout << "<AliTOFanalyzeSDigits> No TreeS found \n";
        rc = 4;
        return rc;
       }
     
     TClonesArray * TOFsdigits = new TClonesArray("AliTOFSDigit",1000);
-    TOFsdigits = tof->SDigits();
+    //TOFsdigits = tof->SDigits();
+    tof->SDigits();
     TOFsdigits = TS->GetBranch("TOF")->SetAddress(&TOFsdigits); 
 
     Int_t nEntries = TS->GetEntries(); 
@@ -120,15 +140,15 @@ Int_t AliTOFanalyzeSDigitsV2(Int_t ndump=15, Int_t iEvNum=0)
          
 
          if (isSDigitBad) {
-           cout << "<AliTOFanalyzeSDigits>  strange sdigit found" << endl;
+           cout << "<AliTOFanalyzeSDigits>  strange sdigit found \n";
            rc = 4;
            return rc;
          }
          
          if(k<ndump){
-           cout << k << "-th | " << "Sector " << sector << " | Plate " << plate << " | Strip " << strip << " | PadZ " << padz << " | PadX " << padx << endl;
-           cout << k << "-th | ADC " << firstADC << " [bin] | TDC " << firstTDC << " [bin]" << endl;
-           cout << "----------------------------------------------------"<< endl;
+           cout << k << "-th | Sector " << sector << " | Plate " << plate << " | Strip " << strip << " | PadZ " << padz << " | PadX " << padx << endl;
+           cout << k << "-th | ADC " << firstADC << " [bin] | TDC " << firstTDC << " [bin] \n";
+           cout << "---------------------------------------------------- \n";
          }
          
          // filling sdigit volume histos
index 94b64dd..39fc343 100644 (file)
@@ -1,11 +1,9 @@
-void AliTOFhits2sdigits(Int_t firstEvent=0,Int_t nEvents=1) 
+void AliTOFhits2sdigits(Int_t evNumber1=-1, Int_t numberOfEvents=0)
 {
 
   /////////////////////////////////////////////////////////////////////////
   //
-  // Creates TOF summable digits from the hit information. 
-  //
-  // Report problems to pierella@bo.infn.it
+  // Creates TOF summable digits from the hits for all event in the header file
   //
   // Use case:
   // start root
@@ -13,8 +11,19 @@ void AliTOFhits2sdigits(Int_t firstEvent=0,Int_t nEvents=1)
   // root[0] .L AliTOFhits2sdigits.C
   // root[1] AliTOFhits2sdigits()
   //
+  // By default, it creates sdigits for all the events in the header file.
+  //
+  // If you want create sdigits only the 3th event (existing in the header file)
+  // you can use the following line:
+  //
+  // root[0] .L AliTOFhits2sdigits.C
+  // root[1] AliTOFhits2sdigits(3,1)
+  //
+  // Created by: F. Pierella
   // Updated to the new I/O: C. Zampolli
   //
+  // Report problems to decaro@sa.infn.it
+  //
   /////////////////////////////////////////////////////////////////////////
 
   // Dynamically link some shared libs
@@ -32,41 +41,33 @@ void AliTOFhits2sdigits(Int_t firstEvent=0,Int_t nEvents=1)
       gAlice = 0x0;
     }
   
-  // Create the TOF sdigitzer and sdigitize by default the first event
-  // (in fact by default Int_t firstEvent=0,Int_t nEvents=1)
-  AliTOFSDigitizer *sdigitizer = new AliTOFSDigitizer("galice.root",firstEvent,nEvents); // it is the same nevents numbering
+  // Create the TOF sdigitzer and sdigitize all events by default
+  AliTOFSDigitizer *sdigitizer = new AliTOFSDigitizer("galice.root",evNumber1,numberOfEvents);
 
   // Activate this line if you want to print the parameters
   // used in sdigitization
   // sdigitizer->PrintParameters();
 
-  // e.g. Activate this line if you want to sdigitize only hits from plate 3
-  // in sector 15
+  // e.g. Activate this line if you want to sdigitize only hits 
+  // with the plate number 3 and the sector number 15
   // pay attention that sector must be in the range [0,17]
   //                and plate  must be in the range [0,4]
   // by default we sdigitize hits of all plates in all sectors
   // sdigitizer->SelectSectorAndPlate(15,3);
 
-
-  // performs sdigitization of the above events with "all" verbose option
+  // performs sdigitization with "all" verbose option
   // "tim" option is also available for benchmarking only
-  //sdigitizer->Exec("all");  
 
-  // N.B.: in order to maintain the functionality to sdigitize 
-  // all events in current file add a second option
-   sdigitizer->Exec("all","all");
-  // the second "all" option overrides the previous settings for 
-  // lower and upper  bounds for event to sdigitize and allow
-  // the sdigitization for ALL events in fileNameHits
+  sdigitizer->Exec("all");
+
+  sdigitizer = 0x0;
+  delete sdigitizer;
+
+  if (gAlice)
+    {
+      delete gAlice->GetRunLoader();
+      delete gAlice;
+      gAlice = 0x0;
+    }
 
-   sdigitizer = 0x0;
-   delete sdigitizer;
-   
-   if (gAlice)
-     {
-       delete gAlice->GetRunLoader();
-       delete gAlice;
-       gAlice = 0x0;
-     }
-   
 }