Merging added and test macro
authorvicinanz <vicinanz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 13 Jun 2002 08:43:46 +0000 (08:43 +0000)
committervicinanz <vicinanz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 13 Jun 2002 08:43:46 +0000 (08:43 +0000)
TOF/AliTOF.cxx
TOF/AliTOF.h
TOF/AliTOFDigitizer.cxx
TOF/AliTOFDigitizer.h
TOF/AliTOFSDigit.cxx
TOF/AliTOFSDigit.h
TOF/AliTOFtestDigitizer.C [new file with mode: 0644]

index 9d2c32470136c03b99422513030cce9643449235..b88da0e134c06e7e54956ee7d826ba7eb3a2f267 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.37  2002/05/03 07:34:19  vicinanz
+Updated SDigitizer; Added AliTOFanalyzeSDigits.C macro
+
 Revision 1.36  2002/04/19 14:40:51  vicinanz
 Updated SDigitizer
 
@@ -170,6 +173,7 @@ AliTOF::AliTOF()
   fReTask = 0x0;
   fIshunt   = 0;
   fSDigits       = 0 ;
+  fNSDigits = 0;
   fDigits        = 0 ;
   fReconParticles = 0x0;
   fName="TOF";
@@ -201,6 +205,7 @@ AliTOF::AliTOF(const char *name, const char *title, Option_t *option)
   fIshunt  = 0;
   fSDigits       = new TClonesArray("AliTOFSDigit",  1000);
   fDigits        = new TClonesArray("AliTOFdigit",  1000);
+  fNSDigits = 0;
 
   fFGeom = 0x0;
   fDTask = 0x0;
index 36311c467eb857499401833f15a3c820a6f3b250..126ec0037225dc16503eeca523de212049708d24 100644 (file)
@@ -92,8 +92,8 @@ protected:
   TFolder* fFGeom ;       //  Folder that holds the Geometry definition
   TTask*   fDTask ;       //  TOF Digitizer container
   TTask*   fReTask;       //  TOF Reconstructioner container
-  TClonesArray* fSDigits; //! List of summable digits
-  Int_t    fNSDigits;           // Number of sdigits
+  TClonesArray* fSDigits; //!  List of summable digits
+  Int_t    fNSDigits;           //! Number of sdigits
   TClonesArray* fReconParticles; // List of reconstructed particles
   AliTOFMerger *fMerger;   // ! pointer to merger
   Int_t   fNTof;  // number of TOF sectors
@@ -129,7 +129,7 @@ protected:
 
 private:
 
-  ClassDef(AliTOF,4)  // Time Of Flight base class
+  ClassDef(AliTOF,5)  // Time Of Flight base class
 };
  
 #endif /* ALITOF_H */
index 38ad4437eb72cd5eadd0eb0363ff68b9066366b6..5a816dc1790ce3cd4baaf16717e62f2cb4b70413 100644 (file)
@@ -1,5 +1,5 @@
 /**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * Copyright(c) 1998-2000, ALICE Experiment at CERN, All rights reserved. *
  *                                                                        *
  * Author: The ALICE Off-line Project.                                    *
  * Contributors are mentioned in the code where appropriate.              *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-
 //_________________________________________________________________________
-// This is a TTask that makes TOF-Digits out of TOF-Hits.
-// A TOF Digit is essentially a TOF hit with the smearing for strip 
-// time resolution and simulation of the ADC correlation signal. 
+// This is a TTask that makes TOF-Digits out of TOF-SDigits. 
+// The simulation of the detector is performed at sdigits level:
+// during digitization the unique task is the sum of all sdigits in the
+// same pad.
 // Digits are written to TreeD in branch "TOF".
-// AliTOFDigitizer with all current parameters used for digitization 
-// (time resolution and ADC parameter) is written 
-// to TreeD branch "AliTOFDigitizer".
-// Both branches have the same title. If necessary one can produce 
-// another set of Digits with different parameters. Two versions
-// can be distunguished using titles of the branches.
-// User case:
-//  root [0] AliTOFDigitizer * s = new AliTOFDigitizer("galice.root")
-//  Warning in <AliITSgeomSPD425Long::Default Creator>: Detector size may not be write.
-//  Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
-//  root [1] s->ExecuteTask()
-//             // Makes Digits for all events stored in galice.root
-//  root [2] s->SetTimeRes(100.)
-//             // One can change parameters of digitization
-//  root [3] s->SetDigitsBranch("Time Resolution 100. ps")
-//             // and write them into the new branch
-//  root [4] s->ExecuteTask("deb all tim")
-//             // available parameters:
-//             deb - print number of produced Digits
-//             deb all  - print number and list of produced Digits
-//             tim - print benchmarking information
 //
 // -- Author :  F. Pierella (Bologna University) pierella@bo.infn.it
 //////////////////////////////////////////////////////////////////////////////
 
-#include "TFile.h"
-#include "TTask.h"
-#include "TTree.h"
-#include "TSystem.h"
-#include "TROOT.h"
-#include "TFolder.h"
-#include "TBenchmark.h"
-#include "TObjString.h"
+#include <TTree.h> 
+#include <TVector.h>
+#include <TObjArray.h>
+#include <TFile.h>
+#include <TDirectory.h>
+#include <TRandom.h>
 
-#include <iomanip.h>
 
-#include "AliRun.h"
+#include "AliTOFDigitizer.h"
 #include "AliTOF.h"
-#include "AliTOFdigit.h"
+#include "AliTOFSDigitizer.h"
 #include "AliTOFhit.h"
-#include "AliTOFDigitizer.h"
+#include "AliTOFdigit.h"
+#include "AliTOFSDigit.h"
+#include "AliTOFHitMap.h"
+#include "AliDigitizer.h"
+#include "AliRunDigitizer.h"
 
+#include "AliRun.h"
+#include "AliPDG.h"
+
+#include <stdlib.h>
+#include <iostream.h>
+#include <fstream.h>
 
 ClassImp(AliTOFDigitizer)
 
-           
-//____________________________________________________________________________ 
-  AliTOFDigitizer::AliTOFDigitizer():TTask("AliTOFDigitizer","") 
+//___________________________________________
+  AliTOFDigitizer::AliTOFDigitizer()  :AliDigitizer()
 {
-  // ctor
-  fTimeRes       = 100;  // ps
-  fChrgRes       = 100.; // pC
-  fNevents       = 0 ;      
-  fDigits        = 0 ;
-  fHits          = 0 ;
-  fIsInitialized = kFALSE ;
-
+  // Default ctor - don't use it
+  fDigits=0;
+  fSDigitsArray=0;
+  fhitMap=0;
 }
 
-//____________________________________________________________________________ 
-AliTOFDigitizer::AliTOFDigitizer(const char* headerFile, const char *digitsTitle):TTask("AliTOFDigitizer","")
+//___________________________________________
+AliTOFDigitizer::AliTOFDigitizer(AliRunDigitizer* manager) 
+    :AliDigitizer(manager) 
 {
-  // ctor
-  fTimeRes       = 100;  // ps
-  fChrgRes       = 100.; // pC
-  fNevents       = 0 ;      
-  fDigitsTitle   = digitsTitle ;
-  fHeadersFile   = headerFile ;
-  fIsInitialized = kFALSE ;
-  Init();
+  fDigits=0;
+  fSDigitsArray=0;
+  fhitMap=0;
 }
 
-//____________________________________________________________________________ 
+//------------------------------------------------------------------------
 AliTOFDigitizer::~AliTOFDigitizer()
 {
-  // dtor
-  if(fDigits)
-    delete fDigits ;
-  if(fHits)
-    delete fHits ;
+  // Destructor
 }
-//____________________________________________________________________________ 
-void AliTOFDigitizer::Init()
+
+//---------------------------------------------------------------------
+
+void AliTOFDigitizer::Exec(Option_t* option)
 {
-  // Initialization: open root-file, allocate arrays for hits and digits,
-  // attach task Digitizer to the list of TOF tasks
-  // 
-  // Initialization can not be done in the default constructor
+  //
+  // Perform digitization and merging.
+  // The algorithm is the following:
+  // - a hitmap is created to check if a pad is already activated;
+  // - an sdigits container is created to collect all sdigits from
+  //   different files;
+  // - sdigits are summed using the hitmap;
+  // - the sdigits container is used to create the array of AliTOFdigit.
+  //
 
-  if(!fIsInitialized){
+  if(strstr(option,"deb")) cout<<"AliTOFDigitizer::Exec\n";
 
-    if(fHeadersFile.IsNull())
-      fHeadersFile="galice.root" ;
 
-    TFile * file = (TFile*) gROOT->GetFile(fHeadersFile.Data() ) ;
-    
-    //if file was not opened yet, read gAlice
-    if(file == 0){
-      if(fHeadersFile.Contains("rfio"))
-       file =  TFile::Open(fHeadersFile,"update") ;
-      else
-       file = new TFile(fHeadersFile.Data(),"update") ;
-      gAlice = (AliRun *) file->Get("gAlice") ;
-    }
-    fHits    = new TClonesArray("AliTOFhit"  , 405);
-    fDigits  = new TClonesArray("AliTOFdigit", 405);
-    
-    //add Task to //FPAlice/tasks/(S)Digitizer/TOF
-    TList * aList = gROOT->GetListOfBrowsables();
-    if (aList) {
-      TFolder * alice  = (TFolder*)aList->FindObject("FPAlice") ;
-      if (alice) {
-        TTask * aliceSD  = (TTask*)alice->FindObject("tasks/(S)Digitizer") ;
-        if (aliceSD) {
-          TTask * tofD   = (TTask*)aliceSD->GetListOfTasks()->FindObject("TOF") ;   
-          tofD->Add(this) ;
-        }
-      }
-    }
+  // get the ptr to TOF detector
+  AliTOF * tof = (AliTOF *) gAlice->GetDetector("TOF") ;
 
-    fIsInitialized = kTRUE ;
-  }
-}
-//____________________________________________________________________________
-void AliTOFDigitizer::Exec(Option_t *option) 
-{ 
-  Int_t    tracks[3];    // track info
-  Int_t    vol[5];       // dummy location for digit
-  Float_t  digit[2];     // TOF digit variables
-
-  // Collects all hits in the same active volume into digit
-  
-  if(!fIsInitialized)
-    Init() ;
+  //Make branches
+  char branchname[20];
+  sprintf (branchname, "%s", tof->GetName ());
+
+  fDigits=new TClonesArray("AliTOFdigit",4000);
 
-  if(strstr(option,"tim"))
-    gBenchmark->Start("TOFDigitizer");
+  TTree* treeD = fManager->GetTreeD();
+  //Make branch for digits (to be created in Init())
+  tof->MakeBranchInTree(treeD,branchname,&fDigits,4000);
+
+  // container for all summed sdigits (to be created in Init())
+  fSDigitsArray=new TClonesArray("AliTOFSDigit",1000);
   
-  fNevents = (Int_t) gAlice->TreeE()->GetEntries() ; 
+  // create hit map (to be created in Init())
+  fhitMap = new AliTOFHitMap(fSDigitsArray);
   
-  Int_t ievent ;
-  // start loop on events
-  for(ievent = 0; ievent < fNevents; ievent++){
-    gAlice->GetEvent(ievent) ;
-    gAlice->SetEvent(ievent) ;
+  // Loop over files to digitize
+
+  for (Int_t inputFile=0; inputFile<fManager->GetNinputs();
+       inputFile++) {
+    ReadSDigit(inputFile);
+  }
+
+  // create digits
+  CreateDigits();
+
+  // free used memory for Hit Map in current event
+  delete fhitMap;
+  fSDigitsArray->Delete();
+  treeD->Fill();
+  fManager->GetTreeD()->AutoSave(); // to fit with the framework
+  fDigits->Delete();
+  delete fDigits;
+
+}
+
+//---------------------------------------------------------------------
+
+void AliTOFDigitizer::CreateDigits()
+{
+  // loop on sdigits container to fill the AliTOFdigit TClonesArray
+  // start digitizing all the collected sdigits 
+
+  Int_t ndump=15; // dump the first ndump created digits for each event
+
+  // get the total number of collected sdigits
+  Int_t ndig = fSDigitsArray->GetEntriesFast();
+
+  for (Int_t k = 0; k < ndig; k++) {
     
-    if(gAlice->TreeH()==0){
-      cout << "AliTOFDigitizer: There is no Hit Tree" << endl;
-      return ;
-    }
+    Int_t    vol[5];       // location for a digit
     
-    //set address of the hits 
-    TBranch * branch = gAlice->TreeH()->GetBranch("TOF");
-    if (branch) 
-      branch->SetAddress(&fHits);
-    else{
-      cout << "ERROR in AliTOFDigitizer: "<< endl ;
-      cout << "      no branch TOF in TreeH"<< endl ;
-      cout << "      do nothing " << endl ;
-      return ;
-    }
+    // Get the information for this digit
+    AliTOFSDigit *tofsdigit = (AliTOFSDigit *) fSDigitsArray->UncheckedAt(k);
     
-    fDigits->Clear();
-    Int_t ndigits = 0 ;
+    Int_t nslot=tofsdigit->GetNDigits(); // get the number of slots
+    // for current sdigit
     
-    //Now made Digits from hits, for TOF it is the same a part for the tof smearing
-    // and some missing MC variables     
-    Int_t itrack ;
-    for (itrack=0; itrack < gAlice->GetNtrack(); itrack++){
-
-      //=========== Get the TOF branch from Hits Tree for the Primary track itrack
-      branch->GetEntry(itrack,0);
-      
-      Int_t i;
-      for ( i = 0 ; i < fHits->GetEntries() ; i++ ) {
-
-       AliTOFhit * hit = (AliTOFhit*)fHits->At(i) ;
-
-        vol[0] = hit->GetSector();
-        vol[1] = hit->GetPlate();
-        vol[2] = hit->GetPadx();
-        vol[3] = hit->GetPadz();
-        vol[4] = hit->GetStrip();
-        // 95% of efficiency to be inserted here
-        // edge effect to be inserted here
-        // cross talk  to be inserted here
-        // simulation of the detector response
-        Float_t idealtime = hit->GetTof(); // unit s
-        idealtime *= 1.E+12;  // conversion from s to ps  
-                              // fTimeRes is given usually in ps
-        Float_t tdctime   = gRandom->Gaus(idealtime, fTimeRes);
-        digit[0] = tdctime;
-        // typical Landau Distribution to be inserted here
-        Float_t idealcharge = hit->GetEdep();
-        Float_t adccharge = gRandom->Gaus(idealcharge, fChrgRes);
-        digit[1] = adccharge;
-        // to be added a check for overlaps
-        new((*fDigits)[ndigits]) AliTOFdigit(tracks, vol, digit);
-       ndigits++ ;  
-      } 
-      
-    } // end loop over tracks
-
-    ndigits = fDigits->GetEntriesFast() ;
-    printf("AliTOFDigitizer: Total number of digits %d\n",ndigits);
-
-    if(gAlice->TreeD() == 0)
-      gAlice->MakeTree("D") ;
+    // TOF sdigit volumes (always the same for all slots)
+    Int_t sector    = tofsdigit->GetSector(); // range [1-18]
+    Int_t plate     = tofsdigit->GetPlate();  // range [1- 5]
+    Int_t strip     = tofsdigit->GetStrip();  // range [1-20]
+    Int_t padz      = tofsdigit->GetPadz();   // range [1- 2]
+    Int_t padx      = tofsdigit->GetPadx();   // range [1-48]
     
-    //check, if this branch already exits
-    TBranch * digitsBranch = 0;
-    TBranch * digitizerBranch = 0;
+    vol[0] = sector;
+    vol[1] = plate;
+    vol[2] = strip;
+    vol[3] = padx;
+    vol[4] = padz;
     
-    TObjArray * branches = gAlice->TreeD()->GetListOfBranches() ;
-    Int_t ibranch;
-    Bool_t tofNotFound = kTRUE ;
-    Bool_t digitizerNotFound = kTRUE ;
+    //--------------------- QA section ----------------------
+    // in the while, I perform QA
+    Bool_t isSDigitBad = (sector<1 || sector>18 || plate<1 || plate >5 || padz<1 || padz>2 || padx<1 || padx>48);
     
-    for(ibranch = 0;ibranch <branches->GetEntries();ibranch++){
-      
-      if(tofNotFound){
-       digitsBranch=(TBranch *) branches->At(ibranch) ;
-       if( (strcmp("TOF",digitsBranch->GetName())==0 ) &&
-           (fDigitsTitle.CompareTo(digitsBranch->GetTitle()) == 0) )
-         tofNotFound = kFALSE ;
-      }
-      if(digitizerNotFound){
-       digitizerBranch = (TBranch *) branches->At(ibranch) ;
-       if( (strcmp(digitizerBranch->GetName(),"AliTOFDigitizer") == 0)&&
-           (fDigitsTitle.CompareTo(digitizerBranch->GetTitle()) == 0) )
-         digitizerNotFound = kFALSE ;
-      }
-    }
-
-    if(!(digitizerNotFound && tofNotFound)){
-      cout << "AliTOFdigitizer error:" << endl ;
-      cout << "Can not overwrite existing branches: do not write" << endl ;
-      return ;
+    if (isSDigitBad) {
+      cout << "<AliTOFSDigits2Digits>  strange sdigit found" << endl;
+      abort();
     }
+    //-------------------------------------------------------
     
-    //Make (if necessary) branches    
-    char * file =0;
-    if(gSystem->Getenv("CONFIG_SPLIT_FILE")){ //generating file name
-      file = new char[strlen(gAlice->GetBaseFile())+20] ;
-      sprintf(file,"%s/TOF.Digits.root",gAlice->GetBaseFile()) ;
+    //------------------- Dump section ----------------------
+    if(k<ndump){
+      cout << k << "-th | " << "Sector " << sector << " | Plate " << plate << " | Strip " << strip << " | PadZ " << padz << " | PadX " << padx << endl;
+      cout << k << "-th sdigit" << endl;
+      cout << "----------------------------------------------------"<< endl;
     }
+    // ------------------------------------------------------
     
-    TDirectory *cwd = gDirectory;
-    
-    //First list of digits
-    Int_t bufferSize = 32000 ;    
-    digitsBranch = gAlice->TreeD()->Branch("TOF",&fDigits,bufferSize);
-    digitsBranch->SetTitle(fDigitsTitle.Data());
-    if (file) {
-      digitsBranch->SetFile(file);
-      TIter next( digitsBranch->GetListOfBranches());
-      TBranch * subbr;
-      while ((subbr=(TBranch*)next())) {
-       subbr->SetFile(file);
-      }   
-      cwd->cd();
-    } 
+    // start loop on number of slots for current sdigit
+    for (Int_t islot = 0; islot < nslot; islot++) {
+      Float_t  digit[2];     // TOF digit variables
+      Int_t tracknum[kMAXDIGITS];     // contributing tracks for the current slot
+      
+      Float_t tdc=tofsdigit->GetTdc(islot); digit[0]=tdc;
+      Float_t adc=tofsdigit->GetAdc(islot); digit[1]=adc;
+      
+      tracknum[0]=tofsdigit->GetTrack(islot,0);
+      tracknum[1]=tofsdigit->GetTrack(islot,1);
+      tracknum[2]=tofsdigit->GetTrack(islot,2);
       
-    //second - Digitizer
-    Int_t splitlevel = 0 ;
-    AliTOFDigitizer * digtz = this ;
-    digitizerBranch = gAlice->TreeD()->Branch("AliTOFDigitizer","AliTOFDigitizer",
-                                              &digtz,bufferSize,splitlevel); 
-    digitizerBranch->SetTitle(fDigitsTitle.Data());
-    if (file) {
-      digitizerBranch->SetFile(file);
-      TIter next( digitizerBranch->GetListOfBranches());
-      TBranch * subbr ;
-      while ((subbr=(TBranch*)next())) {
-       subbr->SetFile(file);
-      }   
-      cwd->cd();
-      delete file;
+      
+      // adding a TOF digit for each slot
+      AliTOFdigit* newDigit=new AliTOFdigit(tracknum, vol, digit);
+      fDigits->Add(newDigit);
     }
-
-    digitsBranch->Fill();
-    digitizerBranch->Fill();
-    gAlice->TreeD()->Write(0,TObject::kOverwrite) ;
-    
-    if(strstr(option,"deb"))
-      PrintDigits(option) ;
     
-  }
-  
-  if(strstr(option,"tim")){
-    gBenchmark->Stop("TOFDigitizer");
-    cout << "AliTOFDigitizer:" << endl ;
-    cout << "   took " << gBenchmark->GetCpuTime("TOFDigitizer") << " seconds for Digitizing " 
-        <<  gBenchmark->GetCpuTime("TOFDigitizer")/fNevents << " seconds per event " << endl ;
-    cout << endl ;
-  }
-  
-  
-}
-//__________________________________________________________________
-void AliTOFDigitizer::SetDigitsBranch(const char* title )
-{
-  // Setting title to branch Digits 
-  if(!fDigitsTitle.IsNull())
-    cout << "AliTOFdigitizer: changing Digits file from " <<fDigitsTitle.Data() << " to " << title << endl ;
-  fDigitsTitle=title ;
+  } // end loop on sdigits - end digitizing all collected sdigits
+
 }
-//__________________________________________________________________
-void AliTOFDigitizer::Print(Option_t* option)const
+
+//---------------------------------------------------------------------
+
+void AliTOFDigitizer::ReadSDigit(Int_t inputFile )
 {
-  // Prints parameters of Digitizer
-  cout << "------------------- "<< GetName() << " -------------" << endl ;
-  cout << "   Writing Digits to branch with title  " << fDigitsTitle.Data() << endl ;
-  cout << "   with digitization parameters Time resolution        = " << fTimeRes << endl ;
-  cout << "                                Adc smearing parameter = " << fChrgRes << endl ;
-  cout << "---------------------------------------------------"<<endl ;
+  // Read sdigits for current event and inputFile; 
+  // store them into the sdigits container
+  // and update the hit map
+  // SDigits from different files are assumed to
+  // be created with the same simulation parameters.
   
-}
-//__________________________________________________________________
-Bool_t AliTOFDigitizer::operator==( AliTOFDigitizer const &digtz )const
-{
-  // Equal operator.
-  // Dititizers are equal if their time resolution and Adc 
-  // smearing parameter are equal
-
-  if( (fTimeRes==digtz.fTimeRes)&&(fChrgRes==digtz.fChrgRes))
-    return kTRUE ;
-  else
-    return kFALSE ;
-}
-//__________________________________________________________________
-void AliTOFDigitizer::PrintDigits(Option_t * option)
-{
-  // Prints list of digits produced in the current pass of AliTOFDigitizer
+  // get the treeS from manager
+  TTree* currentTreeS=fManager->GetInputTreeS(inputFile);
+  
+  // get the branch TOF inside the treeS
+  TClonesArray * sdigitsDummyContainer= new TClonesArray("AliTOFSDigit",  1000); 
+
+  // check if the branch exist
+  TBranch* tofBranch=currentTreeS->GetBranch("TOF");
+
+  if(!tofBranch){
+    Fatal("ReadSDigit","TOF branch not found for input %d",inputFile);
+  }
   
-  cout << "AliTOFDigitizer: " << endl ;
-  cout << "       Number of entries in Digits list  " << fDigits->GetEntriesFast() << endl ;
-  cout << endl ;
+  tofBranch->SetAddress(&sdigitsDummyContainer);           
   
-  if(strstr(option,"all")){// print all digits
+  Int_t nEntries = (Int_t)tofBranch->GetEntries();                                
+
+  // Loop through all entries in the tree
+  Int_t nbytes;
+  
+  for (Int_t iEntry = 0; iEntry < nEntries; iEntry++) {
     
-    //loop over digits
-    AliTOFdigit * digit;
-    cout << "Digit # " << " Time of flight(ps) " << 
-            "  ADC(pC)"  <<  " Sector #" << " Plate #" << 
-            " Strip #" << " Pad # (x) " << " Pad # (z) " << endl;    
-    Int_t index ;
-    for (index = 0 ; index < fDigits->GetEntries() ; index++) {
-      digit = (AliTOFdigit * )  fDigits->At(index) ;
-
-      // set the width of the output with the setw(int width) manipulator
-
-      cout << setw(7)  <<  index << " " 
-           << setw(13) <<  digit->GetTdc()    << "  "  
-          << setw(13) <<  digit->GetAdc()    << "  "   
-          << setw(6)  <<  digit->GetSector() << "  "   
-          << setw(6)  <<  digit->GetPlate()  << "  "   
-          << setw(6)  <<  digit->GetStrip()  << "  "   
-          << setw(7)  <<  digit->GetPadx()   << "  "   
-          << setw(7)  <<  digit->GetPadz()   << "  " << endl;   
-      
-    } // end loop on digits
+    // Import the tree
+    nbytes += tofBranch->GetEvent(iEntry);
     
-  } // close if "all" option selected
+    // Get the number of sdigits
+    Int_t ndig = sdigitsDummyContainer->GetEntriesFast();
+    
+    for (Int_t k=0; k<ndig; k++) {
+      AliTOFSDigit *tofSdigit= (AliTOFSDigit*) sdigitsDummyContainer->UncheckedAt(k);
+      
+      Int_t    vol[5];       // location for a sdigit
+      
+      // check the sdigit volume
+      vol[0] = tofSdigit->GetSector();
+      vol[1] = tofSdigit->GetPlate();
+      vol[2] = tofSdigit->GetStrip();
+      vol[3] = tofSdigit->GetPadx();
+      vol[4] = tofSdigit->GetPadz();
+      
+      if (fhitMap->TestHit(vol) != kEmpty) {
+       AliTOFSDigit *sdig = static_cast<AliTOFSDigit*>(fhitMap->GetHit(vol));
+       sdig->Update(tofSdigit);
+
+      } else {
+
+       CollectSDigit(tofSdigit); // collect the current sdigit
+       fhitMap->SetHit(vol);     // update the hitmap for location vol
+
+      } // if (hitMap->TestHit(vol) != kEmpty)
+      
+    } // for (Int_t k=0; k<ndig; k++)
+
+  } // end loop on entries
+
+  sdigitsDummyContainer->Delete();
+  sdigitsDummyContainer=0;
+
+}
+
+
+//_____________________________________________________________________________
+void AliTOFDigitizer::CollectSDigit(AliTOFSDigit * sdigit)
+{
+  //
+  // Add a TOF digit
+  // new with placement used
+  AliTOFSDigit sdigitCopy=AliTOFSDigit(*sdigit); // make a copy of the current sdigit
+  fSDigitsArray->Add(&sdigitCopy); // put it into tmp array
 }
index cc9c81fa238bfe81bfa6c84ab331588d1a1240c2..c56c9ec14ba753d5419e3c7fdaf1622bcefd4209 100644 (file)
@@ -1,57 +1,44 @@
-#ifndef ALITOFDigitizer_H
-#define ALITOFDigitizer_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+#ifndef ALITOFDIGITIZER_H
+#define ALITOFDIGITIZER_H
+/* Copyright(c) 1998-2000, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
 //_________________________________________________________________________
-//  Task Class for making Digits in TOF
-//  Comment:
-//
-// -- Author: F. Pierella (Bologna University) pierella@bo.infn.it
+//  Task Class for making Digits in TOF      
+// Class performs digitization of Summable digits (in the TOF case this is just
+// sum of contributions of all signals into a given pad). 
+// In addition it performs mixing of summable digits from different events.
+//                  
+//*-- Author: Fabrizio Pierella (Bologna University)
 
+#include "AliDigitizer.h"
 
-#include "TTask.h"
-#include "TString.h"
+class AliRunDigitizer;
+class AliTOFHitMap;
+class AliTOFSDigit;
 
-class AliTOFDigitizer ;
-
-class AliTOFDigitizer: public TTask {
-
-public:
-  AliTOFDigitizer() ;          // ctor
-  AliTOFDigitizer(const char* HeaderFile,const char* digitsTitle = 0) ; 
-  virtual ~AliTOFDigitizer() ; // dtor
-  virtual void  Exec(Option_t* option); 
+class AliTOFDigitizer : public AliDigitizer {
+ public:
   
-  Float_t  GetTimeRes() const {return fTimeRes;}
-  Float_t  GetChrgRes() const {return fChrgRes;}
-  char*    GetDigitsBranch()const{return (char*) fDigitsTitle.Data();}  
-
-  virtual void Print(Option_t* option) const ;
-
-  void     SetTimeRes(Float_t timeRes)  {fTimeRes = timeRes ;}
-  void     SetChrgRes(Float_t chrgRes)  {fChrgRes = chrgRes ;}
-  void     SetDigitsBranch(const char* title ) ;
-
-  Bool_t   operator == (const AliTOFDigitizer & sd) const ;
-
-private:
-  void     Init() ;
-  void     PrintDigits(Option_t* option) ;
-
-private:
-  Float_t fTimeRes;                // Time Resolution
-  Float_t fChrgRes;                // ADC parameter
-  Int_t   fNevents ;               // Number of events to digitize
-  TString fDigitsTitle ;           // title of Digits branch
-  TString fHeadersFile ;           // input file
-  Bool_t  fIsInitialized ;         // kTRUE if Digitizer is initialized
-  TClonesArray* fDigits ;          // list of Digits
-  TClonesArray* fHits ;            // list of Hits
-
-
-  ClassDef(AliTOFDigitizer,1)  // Task Class for making Digits in TOF
-
-};
-
-#endif // AliTOFDigitizer_H
+  AliTOFDigitizer();
+  AliTOFDigitizer(AliRunDigitizer * manager);
+  virtual ~AliTOFDigitizer();
+  
+  // Do the main work
+  void Exec(Option_t* option=0) ;
+  TClonesArray* SDigits() const {return fSDigitsArray;}
+  void ReadSDigit(Int_t);
+  void CreateDigits();
+  
+ private:
+  void CollectSDigit(AliTOFSDigit * sdigit) ;
+  Int_t PutNoise(Int_t charge){return 0;}; // not yet implemented
+                                           // due to the low noise expected level
+  TClonesArray *fDigits;             //! array with digits
+  TClonesArray *fSDigitsArray      ; //! List of summable digits; used as a container for all sdigits to be merged
+  AliTOFHitMap *fhitMap ;            //! hit map used to perform the merging
+  
+  ClassDef(AliTOFDigitizer,0)  // TOF/Merging/Digitization
+};    
+#endif
+    
index 5d34990a4ec27a66034091f52d47a850b02c4225..9b77a7b2cce749090e64cc36ab9fb4992e87d497 100644 (file)
@@ -178,6 +178,67 @@ void AliTOFSDigit::Update(Float_t tdcbin, Int_t tdc, Int_t adc, Int_t track)
   }
   
 }
+
+////////////////////////////////////////////////////////////////////////
+void AliTOFSDigit::Update(AliTOFSDigit* sdig)
+{
+
+  //
+  // Perform the sum with sdig
+  //
+
+  // start loop on all sdig locations
+  Int_t nlocations=sdig->GetNDigits();
+
+  for (Int_t j = 0; j < nlocations; j++) {
+    Float_t tdcbin=50.; // [ps] hardwired for the time being
+    Int_t tdc=(Int_t)sdig->GetTdc(j);
+    Int_t adc=(Int_t)sdig->GetAdc(j);
+    // getting here only the first track number
+    Int_t track=GetTrack(j,0);
+    
+    
+    Int_t sameTime = -1;
+    Float_t tdcwindow=((Float_t)AliTOFConstants::fgkTimeDiff)/tdcbin;
+    for (Int_t i = 0; i < fNDigits; i++) {
+      if (TMath::Abs(tdc-fTdc->At(i)) < tdcwindow) {
+       sameTime = i;
+       break;
+      }
+    }
+    
+    if (sameTime >= 0) {
+      (*fAdc)[sameTime] += static_cast<Float_t>(adc);
+      // update track - find the first -1  value and replace it by the
+      // track number
+      for (Int_t iTrack=0; iTrack<kMAXDIGITS; iTrack++) {
+       if ((*fTracks)[sameTime*kMAXDIGITS+iTrack] == -1) {
+         (*fTracks)[sameTime*kMAXDIGITS+iTrack] = track;
+         break;
+       }
+       // write warning about many tracks going to this pad
+       if (iTrack == kMAXDIGITS) {
+         cerr<<"WARNING: AliTOFSDigit::Update  Many hits in the padhit"<<endl;
+         cerr<<"         ";
+         //    PrintPad();
+       }
+      }
+    } else {
+      // add new time slot
+      fNDigits++;
+      fTdc->Set(fNDigits);
+      (*fTdc)[fNDigits-1] = tdc;
+      fAdc->Set(fNDigits);
+      (*fAdc)[fNDigits-1] = adc;
+      fTracks->Set(fNDigits*kMAXDIGITS);
+      (*fTracks)[(fNDigits-1)*kMAXDIGITS] = track;
+      for (Int_t i = 1; i <kMAXDIGITS; i++) {
+       (*fTracks)[(fNDigits-1)*kMAXDIGITS+i] = -1;
+      } // for (Int_t i = 1; i <kMAXDIGITS; i++)
+    } // if (sameTime >= 0)
+  } // end loop on sdig locations
+}
+
 ////////////////////////////////////////////////////////////////////////
 AliTOFSDigit::~AliTOFSDigit()
 {
index ed81213440ac2df8919054c764979516e28574a7..1224118b5d84dfee9d02cf0fb6215653cd4ffd7d 100644 (file)
@@ -39,6 +39,7 @@ class AliTOFSDigit : public TObject {
   Int_t           GetTotPad() const;
 
   void Update(Float_t tdcbin, Int_t tdc, Int_t adc, Int_t track);
+  void Update(AliTOFSDigit* sdig);
 
 // getters for AliTOFSDigit object 
   Int_t   GetNDigits() const    {return fNDigits;}
diff --git a/TOF/AliTOFtestDigitizer.C b/TOF/AliTOFtestDigitizer.C
new file mode 100644 (file)
index 0000000..7a1d204
--- /dev/null
@@ -0,0 +1,143 @@
+////////////////////////////////////////////////////////////////////////
+//
+// name: AliTOFtestDigitizer
+// date: 11-VI-2002
+// last update: 11-VI-2002
+// author: F. Pierella | pierella@bo.infn.it
+// version: 1.0
+//
+// description: 
+//       creates digits from sdigits for TOF detector
+//       stores sdigits in separate file (or in the source file
+//       with sdigits). Stores gAlice object and copies TE to the
+//       file with digits
+//
+// input:
+//       TString fileNameSDigits ... input file with sdigits
+//       TString fileNameDigits ... output file with digits
+//       Int_t nEvents  ... how many events to process
+//
+
+#if !defined(__CINT__) || defined(__MAKECINT__)
+#include "iostream.h"
+#include "AliTOFDigitizer.h"
+#include "../STEER/AliRunDigitizer.h"
+#include "../STEER/AliDigitizer.h"
+#include "TStopwatch.h"
+#endif
+
+//#include "AliHits2SDigits.C"
+
+TFile* OpenFile(TString fileName);
+Bool_t ImportgAlice(TFile *file);
+void AliCopyN(TString inputFile, TString outputFile);
+void AliCopy(TFile *inputFile, TFile *outputFile);
+Int_t gDEBUG = 1;
+
+
+Int_t AliTOFtestDigitizer(TString fileNameDigits="digits.root", 
+                       TString fileNameSDigits="rfio:sdigits.root", 
+                       Int_t nEvents = 1, Int_t iTOF = 1, Int_t iCopy = 1)
+{
+// delete the current gAlice object, the one from input file
+//  will be used
+
+  if(gAlice){
+    delete gAlice;
+    gAlice = 0;
+  } // end if gAlice
+  AliRunDigitizer * manager = new AliRunDigitizer(1,1);
+  manager->SetInputStream(0,fileNameSDigits.Data());
+  if (fileNameDigits != "") {
+    if (iCopy) {
+      AliCopyN(fileNameSDigits,fileNameDigits);
+    }
+    manager->SetOutputFile(fileNameDigits);
+  }
+  manager->SetNrOfEventsToWrite(nEvents);
+  if (iTOF) AliTOFDigitizer *dTOF  = new AliTOFDigitizer(manager);
+  TStopwatch timer;
+  timer.Start();
+  manager->Exec("deb all");
+  timer.Stop(); 
+  timer.Print();
+  delete manager;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+void AliCopyN(TString inputFileName, TString outputFileName) {
+// copy some objects
+
+  TFile *inputFile = OpenFile(inputFileName);
+  if (!inputFile) return;
+
+  TFile *outputFile = TFile::Open(outputFileName.Data(),"update");
+  if (!outputFile->IsOpen()) {
+    cerr<<"Can't open "<<outputFileName.Data()<<" !\n";
+    return;
+  }
+  if (!ImportgAlice(inputFile)) return;
+  AliCopy(inputFile, outputFile);
+  inputFile->Close();
+  delete inputFile;
+  outputFile->Close();
+  delete outputFile;
+}
+
+////////////////////////////////////////////////////////////////////////
+TFile* OpenFile(TString fileName) {
+  // open file fileName
+  TFile *file = TFile::Open(fileName.Data());
+  if (!file->IsOpen()) {
+    cerr<<"Can't open "<<fileName.Data()<<" !\n";
+    return 0;
+  }
+  return file;
+}
+
+////////////////////////////////////////////////////////////////////////
+Bool_t ImportgAlice(TFile *file) {
+  // read in gAlice object from the file
+  gAlice = (AliRun*)file->Get("gAlice");
+  if (!gAlice)  return kFALSE;
+  return kTRUE;
+}
+
+////////////////////////////////////////////////////////////////////////
+void AliCopy(TFile *inputFile, TFile *outputFile) {
+// copy some objects
+  
+// copy gAlice
+  if (gDEBUG) cout<<"Copy gAlice: ";
+  outputFile->cd();
+  gAlice->Write();
+  if (gDEBUG) cout<<"done"<<endl;
+  TTree *treeE  = gAlice->TreeE();
+  if (!treeE) {
+    cerr<<"No TreeE found "<<endl;
+    return;
+  }
+  
+// copy TreeE
+  if (gDEBUG) cout<<"Copy TreeE: ";
+  AliHeader *header = new AliHeader();
+  treeE->SetBranchAddress("Header", &header);
+  treeE->SetBranchStatus("*",1);  
+  TTree *treeENew =  treeE->CloneTree();
+  treeENew->Write();
+  if (gDEBUG) cout<<"done"<<endl;
+   
+// copy AliceGeom
+  if (gDEBUG) cout<<"Copy AliceGeom: ";
+  TGeometry *AliceGeom = static_cast<TGeometry*>(inputFile->Get("AliceGeom"));
+  if (!AliceGeom) {
+    cerr<<"AliceGeom was not found in the input file "<<endl;
+    return;
+  }
+  AliceGeom->Write();
+  if (gDEBUG) cout<<"done"<<endl;
+   
+}
+