new classes for digitization derived from TTask
authorschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 12 Mar 2001 15:26:48 +0000 (15:26 +0000)
committerschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 12 Mar 2001 15:26:48 +0000 (15:26 +0000)
PHOS/AliPHOSDigit.cxx
PHOS/AliPHOSDigit.h
PHOS/AliPHOSDigitizer.cxx [new file with mode: 0644]
PHOS/AliPHOSDigitizer.h [new file with mode: 0644]
PHOS/AliPHOSEmcRecPoint.h
PHOS/AliPHOSSDigitizer.cxx [new file with mode: 0644]
PHOS/AliPHOSSDigitizer.h [new file with mode: 0644]
PHOS/Makefile
PHOS/PHOSLinkDef.h

index 18aa5c1..8857742 100644 (file)
@@ -129,7 +129,14 @@ Int_t AliPHOSDigit::GetPrimary(Int_t index) const
   return rv ; 
   
 }
-
+//____________________________________________________________________________
+void AliPHOSDigit::ShiftPrimary(Int_t shift){
+  //shifts primary nimber to BIG offset, to separate primary in different TreeK
+  Int_t index  ;
+  for(index = 0; index <fNprimary; index ++ ){
+    fPrimary[index] = fPrimary[index]+ shift * 10000000   ;
+  } 
+}
 //____________________________________________________________________________
 Bool_t AliPHOSDigit::operator==(AliPHOSDigit const & digit) const 
 {
index c8bafc6..299a033 100644 (file)
@@ -50,6 +50,7 @@ class AliPHOSDigit : public AliDigitNew {
   void    SetAmp(Int_t Amp) { 
     // sets the amplitude data member 
     fAmp=Amp ; } 
+  void ShiftPrimary(Int_t shift); // shift to semarate different TreeK in merging
 
  private:
 
diff --git a/PHOS/AliPHOSDigitizer.cxx b/PHOS/AliPHOSDigitizer.cxx
new file mode 100644 (file)
index 0000000..b26517d
--- /dev/null
@@ -0,0 +1,573 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+//_________________________________________________________________________
+// This is a TTask that constructs SDigits out of Hits
+// A Summable Digits is the sum of all hits in a cell
+// A threshold is applied 
+//
+//*-- Author :  Dmitri Peressounko (SUBATECH & Kurchatov Institute) 
+//////////////////////////////////////////////////////////////////////////////
+// Class performs digitization of Summable digits (in the PHOS case this is just
+// sum of contributions of all primary particles into give cell). 
+// In addition it performs mixing of summable digits from different events.
+// Examples of use:
+// root[0] AliPHOSDigitizer * d = new AliPHOSDigitizer() ;
+// root[1] d->ExecuteTask()             
+// Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
+//                       //Digitizes SDigitis in all events found in file galice.root 
+//                       //Depending on variable "CONFIG_SPLIT_FILE" reads branches stored in galice.root
+//                       //or in PHOS.SDigits.root
+// root[2] AliPHOSDigitizer * d1 = new AliPHOSDigitizer("galice1.root") ;  // Will read sdigits from galice1.root
+// root[3] d1->MixWith("galice2.root",1)       // Reads another portion of sdigits from galice2.root
+//                                             // says, that this will be output file
+// Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
+// root[3] d1->MixWith("galice3.root",1)       // Reads another portion of sdigits from galice3.root
+//                                             // overwrides previous definition of output file
+// root[4] d->ExecuteTask()    // Reads SDigits from files galice1.root, galice2.root ....
+//                             // mixes them and stores produced Digits in file galice3.root          
+//
+//
+// 
+
+// --- ROOT system ---
+#include "TTask.h"
+#include "TTree.h"
+#include "TSystem.h"
+// --- Standard library ---
+
+// --- AliRoot header files ---
+
+#include "AliPHOSDigit.h"
+#include "AliPHOSHit.h"
+#include "AliPHOSv1.h"
+#include "AliPHOSDigitizer.h"
+#include "AliPHOSSDigitizer.h"
+#include "TROOT.h"
+#include "TFolder.h"
+
+ClassImp(AliPHOSDigitizer)
+
+
+//____________________________________________________________________________ 
+  AliPHOSDigitizer::AliPHOSDigitizer():TTask("AliPHOSDigitizer","") 
+{
+  // ctor
+
+  fSDigitizer = 0 ;
+  fNinputs = 1 ;
+  fPinNoise = 0.01 ;
+  fEMCDigitThreshold = 0.01 ;
+  fCPVNoise = 0.01;
+  fCPVDigitThreshold = 0.09 ;
+  fPPSDNoise = 0.0000001;
+  fPPSDDigitThreshold = 0.0000002 ;
+  fInitialized = kFALSE ;
+  // add Task to //root/Tasks folder
+  TTask * roottasks = (TTask*)gROOT->GetRootFolder()->FindObject("Tasks") ; 
+  roottasks->Add(this) ; 
+
+}
+//____________________________________________________________________________ 
+void AliPHOSDigitizer::Init(Int_t isOutFile){
+// Mades all memory allocations and defiles, 
+// whether first (default) file will be output file (isOutFile !=0) 
+
+  if(!fInitialized){
+
+    fHeaderFiles  = new TClonesArray("TObjString",1) ;
+    new((*fHeaderFiles)[0]) TObjString("galice.root") ;
+    TFile * file ;
+
+    if(isOutFile)
+      file = new TFile(((TObjString *) fHeaderFiles->At(0))->GetString(),"update") ;
+    else
+      file = new TFile(((TObjString *) fHeaderFiles->At(0))->GetString()) ;
+
+    file->cd() ;
+  
+    fSDigitsFiles = new TClonesArray("TObjString",1);
+    if(gSystem->Getenv("CONFIG_SPLIT_FILE")) 
+      new((*fSDigitsFiles)[0]) TObjString("./PHOS.SDigits.root") ;   
+    else
+      new((*fSDigitsFiles)[0]) TObjString("") ;   
+    
+    fSDigits      = new TClonesArray("TClonesArray",1) ;
+    new((*fSDigits)[0]) TClonesArray("AliPHOSDigit",1000) ;
+    
+    fDigits = new TClonesArray("AliPHOSDigit",200000) ;
+    
+    fIevent    = new TArrayI(1) ;
+    fIevent->AddAt(-1,0 ) ; 
+    fIeventMax = new TArrayI(1) ;
+
+    //Store digits in this file
+    if(isOutFile){
+      gAlice = (AliRun *) file->Get("gAlice") ;
+      fIeventMax->AddAt((Int_t) gAlice->TreeE()->GetEntries(), 0 );
+      fOutFileNumber = 0 ;
+    }
+    else{
+      TTree * te = (TTree *) file->Get("TE") ;
+      fIeventMax->AddAt((Int_t) te->GetEntries(), 0 );
+      fOutFileNumber = -1 ;
+    }
+
+    fInitialized = kTRUE ;
+  }
+
+}
+
+
+//____________________________________________________________________________ 
+AliPHOSDigitizer::AliPHOSDigitizer(char *HeaderFile,char *DigitsFile = 0):TTask("AliPHOSDigitizer","")
+{
+  // ctor
+  fHeaderFiles  = new TClonesArray("TFile",1) ;          
+  new((*fHeaderFiles)[0]) TObjString(HeaderFile) ;
+  TFile * file = new TFile(((TObjString *) fHeaderFiles->At(0))->GetString(),"update") ;      // Header file, where result will be stored
+
+  file->cd() ;
+  
+  fSDigitsFiles = new TClonesArray("TObjString",1);         // File name of the SDigits branch
+  if(DigitsFile)
+    new((*fSDigitsFiles)[0]) TObjString(DigitsFile) ;   
+  else
+    if(gSystem->Getenv("CONFIG_SPLIT_FILE")) 
+      new((*fSDigitsFiles)[0]) TObjString("./PHOS.SDigits.root") ;   
+    else
+      new((*fSDigitsFiles)[0]) TObjString("") ;   
+    
+  fSDigits      = new TClonesArray("TClonesArray",1) ;      // here list of SDigits wil be stored
+  new((*fSDigits)[0]) TClonesArray("AliPHOSDigit",1000) ;
+    
+  fDigits = new TClonesArray("AliPHOSDigit",200000) ;
+  fDigitsFile="PHOS.Digits" ; 
+    
+  fIevent    = new TArrayI(1) ;
+  fIevent->AddAt(-1,0 ) ; 
+  fIeventMax = new TArrayI(1) ;
+  //Should be check whether gAlice in memory is the same as in file
+  //However, there is no such method (?) ==> we are forced to read it
+  // if(gAlice->TreeE()==0)
+
+  gAlice = (AliRun *) file->Get("gAlice") ;  //If not read yet
+
+  // Get number of events to process
+  fIeventMax->AddAt((Int_t) gAlice->TreeE()->GetEntries(), 0 );
+  fOutFileNumber = 0 ;
+
+  fNinputs = 1 ;
+
+  fPinNoise = 0.01 ;
+  fEMCDigitThreshold = 0.01 ;
+  fCPVNoise = 0.01;
+  fCPVDigitThreshold = 0.09 ;
+  fPPSDNoise = 0.0000001;
+  fPPSDDigitThreshold = 0.0000002 ;  
+
+  // add Task to //root/Tasks folder
+  TTask * roottasks = (TTask*)gROOT->GetRootFolder()->FindObject("Tasks") ; 
+  roottasks->Add(this) ; 
+  fInitialized = kTRUE ;
+    
+}
+
+//____________________________________________________________________________ 
+  AliPHOSDigitizer::~AliPHOSDigitizer()
+{
+  // dtor
+  delete fHeaderFiles ;
+  delete fSDigitsFiles ;
+  delete fSDigits ;
+  delete fDigits ;
+}
+//____________________________________________________________________________
+Bool_t AliPHOSDigitizer::Combinator() { 
+
+  //Makes all desirable combinations Signal+Background,
+  // returns kFALSE when all combinations are made
+  // May be useful to introduce some options like "One-to-One", "All-to-One" and "All-to-All" ?
+
+  //realizing "One-to-One" option...
+
+  if(!fInitialized)
+    Init(1) ;
+
+  Int_t inputs ;
+  Bool_t endNotReached = kTRUE ;
+
+  for(inputs = 0; (inputs < fNinputs) && endNotReached ;inputs++){
+    if(fIevent->At(inputs)+1 < fIeventMax->At(inputs))
+      fIevent->AddAt(fIevent->At(inputs)+1, inputs ) ;
+    else
+      endNotReached = kFALSE ;
+  }
+  return endNotReached ;
+
+}
+
+//____________________________________________________________________________
+void AliPHOSDigitizer::Digitize(Option_t *option) { 
+
+  //Makes the digitization of the collected summable digits
+
+  if(!fInitialized)
+    Init(1) ;
+
+  //Collects all hits in the same active volume into digit
+  //if(option == "raw")    // add simulated data to row data -- to be implemented
+
+
+  fDigits->Clear() ;
+
+  AliPHOS * PHOS = (AliPHOS *) gAlice->GetDetector("PHOS") ;   
+  AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance( PHOS->GetGeometry()->GetName(), PHOS->GetGeometry()->GetTitle() );
+
+  //Making digits with noise, first EMC
+  Int_t nEMC = geom->GetNModules()*geom->GetNPhi()*geom->GetNZ();
+  
+  Int_t nCPV ;
+  Int_t nPPSD ;
+  Int_t absID ;
+  TString name      =  geom->GetName() ;
+  
+  if ( name == "IHEP" || name == "MIXT" )    
+    nCPV =nEMC + geom->GetNumberOfCPVPadsZ()*geom->GetNumberOfCPVPadsPhi()*
+      geom->GetNCPVModules()*geom->GetNumberOfCPVLayers() ;
+  else
+    nCPV = nEMC; 
+  
+  if ( name == "GPS2" || name == "MIXT" )    
+    nPPSD =nCPV+2*geom->GetNPPSDModules()*geom->GetNumberOfModulesPhi()*geom->GetNumberOfModulesZ()*
+      geom->GetNumberOfPadsPhi()*geom->GetNumberOfPadsZ() ;
+  else
+    nPPSD = nCPV; 
+  
+  for(absID = 1; absID <= nEMC; absID++){
+    Float_t noise = gRandom->Gaus(0., fPinNoise) ; 
+    new((*fDigits)[absID-1]) AliPHOSDigit( -1,absID,fSDigitizer->Digitize(noise) ) ;
+  }
+  
+  for(absID = nEMC+1; absID <= nCPV; absID++){
+    Float_t noise = gRandom->Gaus(0., fCPVNoise) ; 
+    new((*fDigits)[absID-1]) AliPHOSDigit( -1,absID,fSDigitizer->Digitize(noise) ) ;
+  }
+  
+  for(absID = nCPV+1; absID <= nPPSD; absID++){
+    Float_t noise = gRandom->Gaus(0., fPPSDNoise) ; 
+    new((*fDigits)[absID-1]) AliPHOSDigit( -1,absID,fSDigitizer->Digitize(noise) ) ;
+  }
+  
+
+  // Now look throught (unsorted) list of SDigits and add corresponding digits  
+  AliPHOSDigit *curSDigit ;
+  AliPHOSDigit *digit ;
+    
+  Int_t inputs;
+  for(inputs = 0; inputs< fNinputs ; inputs++){  //loop over (possible) merge sources
+    
+    TClonesArray * sdigits= (TClonesArray *)fSDigits->At(inputs) ;
+    Int_t isdigit ;
+    Int_t nSDigits = sdigits->GetEntries() ;     
+    for(isdigit=0;isdigit< nSDigits; isdigit++){
+      curSDigit = (AliPHOSDigit *)sdigits->At(isdigit) ;
+      if(inputs)                                       //Shift primaries for non-background sdigits
+       curSDigit->ShiftPrimary(inputs) ;
+      digit = (AliPHOSDigit *)fDigits->At(curSDigit->GetId() - 1);
+      *digit = *digit + *curSDigit ;
+    }  
+  }
+
+
+
+  //remove digits below thresholds
+  for(absID = 0; absID < nEMC ; absID++)
+    if(fSDigitizer->Calibrate(((AliPHOSDigit*)fDigits->At(absID))->GetAmp()) < fEMCDigitThreshold)
+      fDigits->RemoveAt(absID) ;
+  for(absID = nEMC; absID < nCPV ; absID++)
+    if(fSDigitizer->Calibrate(((AliPHOSDigit*)fDigits->At(absID))->GetAmp()) < fCPVDigitThreshold)
+      fDigits->RemoveAt(absID) ;
+  for(absID = nCPV; absID < nPPSD ; absID++)
+    if(fSDigitizer->Calibrate(((AliPHOSDigit *)fDigits->At(absID))->GetAmp()) < fPPSDDigitThreshold)
+      fDigits->RemoveAt(absID) ;
+  
+  fDigits->Compress() ;  
+  
+  Int_t ndigits = fDigits->GetEntries() ;
+  fDigits->Expand(ndigits) ;
+
+
+  //Set indexes in list of digits
+  Int_t i ;
+  for (i = 0 ; i < ndigits ; i++) { 
+    AliPHOSDigit * digit = (AliPHOSDigit *) fDigits->At(i) ; 
+    digit->SetIndexInList(i) ;     
+  }
+}
+//____________________________________________________________________________
+void AliPHOSDigitizer::WriteDigits(){
+
+  //Made TreeD in the output file if necessary and writes digiths there.
+
+  gAlice->GetEvent(fIevent->At(fOutFileNumber)) ;  // Suitable only for One-To-One mixing
+  gAlice->SetEvent(fIevent->At(fOutFileNumber)) ;  // for all-to-all will produce a lot of branches in TreeD
+
+  if(gAlice->TreeD()==0)
+    gAlice->MakeTree("D") ;
+  
+  //Make branches in TreeD for digits and Digitizer
+  char branchname[20];
+  sprintf(branchname,"PHOS");  
+
+  Int_t bufferSize = 16000 ;
+  char * filename = 0;
+  if(!fDigitsFile.IsNull())
+    filename = (char*) fDigitsFile.Data() ; //ievent ;
+  else
+    if(gSystem->Getenv("CONFIG_SPLIT_FILE")!=0){ //generating file name
+      filename = new char[30] ;
+      //       sprintf(filename,"PHOS.Digits%d.root",ievent) ;
+      sprintf(filename,"PHOS.Digits.root") ;
+    }
+    else
+      filename = 0 ;
+  
+  //Link digits  
+  gAlice->MakeBranchInTree(gAlice->TreeD(),branchname,&fDigits,bufferSize,filename);  
+  //Link Digitizer
+  AliPHOSDigitizer * d = this ;
+  Int_t splitlevel = 0 ;
+  sprintf(branchname,"AliPHOSDigitizer");   
+  gAlice->MakeBranchInTree(gAlice->TreeD(),branchname,"AliPHOSDigitizer",&d, bufferSize, splitlevel,filename); 
+
+  gAlice->TreeD()->Fill() ;
+   
+  gAlice->TreeD()->Write(0,kOverwrite) ;  
+}
+
+//____________________________________________________________________________
+void AliPHOSDigitizer::Exec(Option_t *option) { 
+  //manager
+
+  if(!fInitialized)    Init(1) ;
+  
+  while(Combinator()){  
+    
+    if(!ReadSDigits()) //read sdigits event(s) evaluated by Combinator() from file(s)
+      return ;    
+    
+    Digitize(option) ; //Add prepared SDigits to digits and add the noise
+    WriteDigits() ;
+  }
+
+//   //Close all opened files
+//   Int_t input ;
+//   for(input = 0; input < fNinputs ; input ++){
+//     TFile * file = (TFile*) gROOT->GetFile(((TObjString *) fHeaderFiles->At(input))->GetString() ) ;
+//     file->Close() ;
+//   }
+
+  
+}
+
+//__________________________________________________________________
+Bool_t AliPHOSDigitizer::ReadSDigits(){
+// Reads summable digits from the opened files for the particular set of events given by fIevent
+
+  if(!fInitialized)    Init(1) ;
+
+  Int_t inputs ;
+  for(inputs = fNinputs-1; inputs >= 0; inputs --){
+
+    Int_t event = fIevent->At(inputs) ;
+
+    TFile * file = (TFile*) gROOT->GetFile(((TObjString *) fHeaderFiles->At(inputs))->GetString() ) ;
+    file->cd() ;
+
+    // Get SDigits Tree header from file
+    char treeName[20]; 
+    sprintf(treeName,"TreeS%d",event);
+    TTree * treeS = (TTree*)file->Get(treeName);
+   
+    if(treeS==0){
+      cout << "Error at AliPHOSDigitizer: no "<<treeName << "   in file " << file->GetName() << endl ;
+      cout << "Do nothing " << endl ;
+      return kFALSE ;
+    }
+
+    TBranch * sdigitsBranch = 0;
+    TBranch * sdigitizerBranch = 0;
+
+    TObjArray * branches = treeS->GetListOfBranches() ;
+    Int_t ibranch;
+    Bool_t phosNotFound = kTRUE ;
+    Bool_t sdigitizerNotFound = kTRUE ;
+  
+    for(ibranch = 0;ibranch <branches->GetEntries();ibranch++){
+
+      if(phosNotFound){
+       sdigitsBranch=(TBranch *) branches->At(ibranch) ;
+       if( ((TObjString*)fSDigitsFiles->At(inputs))->GetString().CompareTo(sdigitsBranch->GetFileName())==0 ){
+         if( strcmp(sdigitsBranch->GetName(),"PHOS") == 0) {
+           phosNotFound = kFALSE ;
+         }
+       }
+      }
+
+      if(sdigitizerNotFound){
+       sdigitizerBranch = (TBranch *) branches->At(ibranch) ;
+       if( ((TObjString*)fSDigitsFiles->At(inputs))->GetString().CompareTo(sdigitizerBranch->GetFileName()) == 0){
+         if( strcmp(sdigitizerBranch->GetName(),"AliPHOSSDigitizer") == 0) {
+           sdigitizerNotFound = kFALSE ;
+         }
+       }
+      }
+      
+    }
+
+    if(sdigitizerNotFound || phosNotFound){
+      cout << "Can't find Branch with sdigits or SDigitizer in the file " ;
+      if( ((TObjString*)fSDigitsFiles->At(inputs))->GetString().IsNull() )
+       cout << file->GetName() << endl ;       
+      else
+       cout << ((TObjString*)fSDigitsFiles->At(inputs))->GetString().Data() << endl ;
+      cout << "Do nothing" <<endl  ;
+      return kFALSE ;
+    }
+
+
+    TClonesArray * sdigits = (TClonesArray*) fSDigits->At(inputs) ;  
+    sdigitsBranch->SetAddress(&sdigits) ;
+    
+    AliPHOSSDigitizer *sDigitizer = new AliPHOSSDigitizer();
+    sdigitizerBranch->SetAddress(&sDigitizer) ;
+    treeS->GetEvent(0) ;
+
+    if(fSDigitizer == 0)
+      fSDigitizer = sDigitizer ;
+    else
+      if(!((*fSDigitizer)==(*sDigitizer)) ){
+       cout << "ERROR: you are using sdigits made with different SDigitizers" << endl ;
+       fSDigitizer->Print("") ;
+       sDigitizer->Print("") ;
+       cout << "Do Nothing " << endl ;
+       return kFALSE ;
+      }
+    
+  }
+  
+
+  return kTRUE ;
+
+}
+//__________________________________________________________________
+void AliPHOSDigitizer::MixWith(char* HeaderFile,Int_t isOutFile = 1, char* SDigitsFile =0){
+//
+
+  if(!fInitialized)
+    if(isOutFile)
+      Init(0) ;     //Do not read gAlice from Background file
+    else
+      Init(1) ;     //read gAlice from background file
+
+  if(HeaderFile == 0){
+    cout << "Specify at least header file to merge"<< endl ;
+    return ;
+  }
+  
+  Int_t inputs ;
+  for(inputs = 0; inputs < fNinputs ; inputs++){
+    if(strcmp(((TObjString *)fHeaderFiles->At(inputs))->GetString(),HeaderFile) == 0 ){
+      if(SDigitsFile == 0){ 
+       if(((TObjString*)fSDigitsFiles->At(inputs))->GetString().CompareTo("")  == 0){
+         cout << "Entry already exists, do not add" << endl ;
+         return ;
+       }
+      }
+      else
+       if(((TObjString*)fSDigitsFiles->At(inputs))->GetString().CompareTo(SDigitsFile) == 0){
+       cout << "Entry already exists, do not add" << endl ;
+       return;
+      }
+    }  
+  }  
+  
+  fHeaderFiles->Expand(fNinputs+1) ;
+  new((*fHeaderFiles)[fNinputs]) TObjString(HeaderFile) ;
+
+  
+  TFile * file ;
+  if(isOutFile)
+    file = new TFile(((TObjString *) fHeaderFiles->At(fNinputs))->GetString(),"update") ;  
+  else
+    file = new TFile(((TObjString *) fHeaderFiles->At(fNinputs))->GetString()) ;  
+
+  file->cd() ;
+
+  fSDigitsFiles->Expand(fNinputs+1) ;
+  new((*fSDigitsFiles)[fNinputs]) TObjString(SDigitsFile) ;
+
+  fSDigits->Expand(fNinputs+1) ;
+  new((*fSDigits)[fNinputs]) TClonesArray("AliPHOSDigit",1000) ;
+
+  fIevent->Set(fNinputs+1) ;
+  fIevent->AddAt(-1, fNinputs) ;
+
+  fIeventMax->Set(fNinputs+1) ;  
+
+  if(isOutFile){
+    gAlice = (AliRun*) file->Get("gAlice") ;
+    fIeventMax->AddAt((Int_t) gAlice->TreeE()->GetEntries(), fNinputs );
+    fOutFileNumber = fNinputs ;
+  }
+  else{
+    TTree * te = (TTree *) file->Get("TE") ;
+    fIeventMax->AddAt((Int_t) te->GetEntries(), fNinputs );
+  }
+
+  fNinputs++ ;
+
+}
+//__________________________________________________________________
+void AliPHOSDigitizer::Print(Option_t* option){
+
+  if(!fInitialized)    Init(1) ;
+
+  cout << "------------------- "<< GetName() << " -------------" << endl ;
+  cout << "Digitizing sDigits from file(s): " <<endl ;
+  Int_t input ;
+  for(input = 0; input < fNinputs ; input++) {
+    cout << "          " << ((TObjString *) fHeaderFiles->At(input))->GetString() << 
+      "   Branch: " << ((TObjString *) fSDigitsFiles->At(input))->GetString() << endl ;
+  }
+  cout << endl ;
+  cout << "Writing digits to " << ((TObjString *) fHeaderFiles->At(fOutFileNumber))->GetString() << endl ;
+
+  cout << endl ;
+  cout << "With following parameters: " << endl ;
+  cout << "     Electronics noise in EMC (fPinNoise) = " << fPinNoise << endl ;
+  cout << "  Threshold  in EMC  (fEMCDigitThreshold) = " << fEMCDigitThreshold  << endl ; ;
+  cout << "                 Noise in CPV (fCPVNoise) = " << fCPVNoise << endl ; 
+  cout << "    Threshold in CPV (fCPVDigitThreshold) = " << fCPVDigitThreshold << endl ; 
+  cout << "               Noise in PPSD (fPPSDNoise) = " << fPPSDNoise << endl ;
+  cout << "  Threshold in PPSD (fPPSDDigitThreshold) = " << fPPSDDigitThreshold << endl ;
+  cout << "---------------------------------------------------" << endl ;
+
+
+}
diff --git a/PHOS/AliPHOSDigitizer.h b/PHOS/AliPHOSDigitizer.h
new file mode 100644 (file)
index 0000000..89d133f
--- /dev/null
@@ -0,0 +1,78 @@
+#ifndef ALIPHOSDigitizer_H
+#define ALIPHOSDigitizer_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+//_________________________________________________________________________
+//  Task Class for making SDigits in PHOS      
+//                  
+//*-- Author: Dmitri Peressounko(SUBATECH & KI)
+
+
+// --- ROOT system ---
+#include "TTask.h"
+#include "TObjString.h"
+// --- Standard library ---
+
+// --- AliRoot header files ---
+
+class AliPHOSSDigitizer ;
+
+class AliPHOSDigitizer: public TTask {
+
+public:
+  AliPHOSDigitizer() ;          // ctor
+  AliPHOSDigitizer(char *HeaderFile,char * SDigitsBrancheFile = 0) ; 
+  virtual ~AliPHOSDigitizer() ;       
+  Bool_t  Combinator() ;                         // makes all desirable combination sig+Bg
+  void    Exec(Option_t *option);                // Does the job
+  void    Digitize(Option_t *option);            // Digitizes SDigits stored in fSDigits
+  Float_t GetPinNoise()     const { return fPinNoise;}
+  Float_t GetEMCThreshold() const { return fEMCDigitThreshold;}
+  Float_t GetCPVNoise()     const { return fCPVNoise ;}
+  Float_t GetCPVThreshold() const { return fCPVDigitThreshold ;}
+  Float_t GetPPSDNoise()    const { return fPPSDNoise ;}
+  Float_t GetPPSDThreshold()const { return fPPSDDigitThreshold ;}
+  void    MixWith(char* HeaderFile, Int_t isOutFile = 1, char* SDigitsFile =0) ; // Add another one file to mix
+  void    Print(Option_t* option) ;
+  void    SetPinNoise(Float_t PinNoise )         {fPinNoise = PinNoise;}
+  void    SetEMCThreshold(Float_t EMCThreshold)  {fEMCDigitThreshold = EMCThreshold;}
+  void    SetCPVNoise(Float_t CPVNoise)          {fCPVNoise = CPVNoise;}
+  void    SetCPVThreshold(Float_t CPVThreshold)  {fCPVDigitThreshold= CPVThreshold;}
+  void    SetPPSDNoise(Float_t PPSDNoise)        {fPPSDNoise = PPSDNoise;}
+  void    SetPPSDThreshold(Float_t PPSDThreshold){fPPSDDigitThreshold = PPSDThreshold;}
+
+private:
+  void   Init(Int_t isOutFile);                   
+  Bool_t ReadSDigits() ;            // Read sdigits for particular events
+  void   WriteDigits() ;            // Writes Digits for particular event
+
+private:
+  TClonesArray * fSDigitsFiles ;    // Names of sdigits branches
+  TClonesArray * fHeaderFiles ;     // Names of files with headers to merge
+  TString        fDigitsFile ;      // Name of the Digits Branch  
+  Int_t          fOutFileNumber ;   // Number of the header file into which Digits are written
+  TClonesArray * fSDigits ;         // ! Lists of SDigits 
+  TClonesArray * fDigits ;          // ! Final list of digits
+  AliPHOSSDigitizer * fSDigitizer ; // ! SDigitizer to extarct some digitizing parameters
+  Int_t   fNinputs ;                // Number of input files
+  Bool_t  fInitialized ;            // if background file already read?
+  TArrayI * fIevent ;               // events to read at the next ReadSDigits() call
+  TArrayI * fIeventMax ;            // Maximal number of events in each input file
+
+  Float_t fPinNoise ;               // Electronics noise in EMC
+  Float_t fEMCDigitThreshold  ;     // Threshold for storing digits in EMC
+  Float_t fCPVNoise ;               // Noise in CPV
+  Float_t fCPVDigitThreshold  ;     // Threshold for storing digits in CPV
+  Float_t fPPSDNoise ;              // Noise in PPSD
+  Float_t fPPSDDigitThreshold ;     // Threshold for storing digits in PPSD
+
+
+  ClassDef(AliPHOSDigitizer,1)  // description 
+
+};
+
+
+#endif // AliPHOSDigitizer_H
index e7e9b83..aae870e 100644 (file)
@@ -42,7 +42,7 @@ public:
 
   virtual void  AddDigit(AliPHOSDigit & digit, Float_t Energy) ;  // add a digit to the digits list  
   Int_t       Compare(const TObject * obj) const;                         // method for sorting  
-  Float_t CoreEnergy() ;
+  Float_t     CoreEnergy() ;
   void        EvalAll() ;
   void        EvalLocalPosition() ;                                // computes the position in the PHOS module 
   Float_t     GetDelta () const {     return fDelta ; }    
diff --git a/PHOS/AliPHOSSDigitizer.cxx b/PHOS/AliPHOSSDigitizer.cxx
new file mode 100644 (file)
index 0000000..9780671
--- /dev/null
@@ -0,0 +1,222 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+//_________________________________________________________________________
+// This is a TTask that constructs SDigits out of Hits
+// A Summable Digits is the sum of all hits in a cell
+// A threshold is applied 
+//
+//*-- Author :  Dmitri Peressounko (SUBATECH & KI) 
+//////////////////////////////////////////////////////////////////////////////
+
+// --- ROOT system ---
+#include "TTask.h"
+#include "TTree.h"
+#include "TSystem.h"
+// --- Standard library ---
+
+// --- AliRoot header files ---
+
+#include "AliPHOSDigit.h"
+#include "AliPHOSHit.h"
+#include "AliPHOSv1.h"
+#include "AliPHOSSDigitizer.h"
+
+#include "TROOT.h"
+#include "TFolder.h"
+
+ClassImp(AliPHOSSDigitizer)
+
+           
+//____________________________________________________________________________ 
+  AliPHOSSDigitizer::AliPHOSSDigitizer():TTask("AliPHOSSDigitizer","") 
+{
+  // ctor
+  fA = 0;
+  fB = 10000000. ;
+  fPrimThreshold = 0.01 ;
+  fNevents = 0 ;     // Number of events to digitize, 0 means all evens in current file
+  // add Task to //root/Tasks folder
+  TTask * roottasks = (TTask*)gROOT->GetRootFolder()->FindObject("Tasks") ; 
+  roottasks->Add(this) ; 
+
+}
+//____________________________________________________________________________ 
+AliPHOSSDigitizer::AliPHOSSDigitizer(char* HeaderFile, char *SDigitsFile):TTask("AliPHOSSDigitizer","")
+{
+  // ctor
+  fA = 0;
+  fB = 10000000.;
+  fPrimThreshold = 0.01 ;
+  fNevents = 0 ;         // Number of events to digitize, 0 means all events in current file
+  fSDigitsFile = SDigitsFile ;
+  fHeadersFile = HeaderFile ;
+  //add Task to //root/Tasks folder
+  TTask * roottasks = (TTask*)gROOT->GetRootFolder()->FindObject("Tasks") ; 
+  roottasks->Add(this) ; 
+    
+}
+
+//____________________________________________________________________________ 
+  AliPHOSSDigitizer::~AliPHOSSDigitizer()
+{
+  // dtor
+}
+
+
+//____________________________________________________________________________
+void AliPHOSSDigitizer::Exec(Option_t *option) { 
+  //Collects all hits in the same active volume into digit
+
+  TFile * file = 0;
+
+  // if(gAlice->TreeE()==0)        //If gAlice not yet read/constructed
+  if(fHeadersFile.IsNull())
+    file = new TFile("galice.root", "update") ;
+  else
+    file = new TFile(fHeadersFile.Data(),"update") ;
+
+  gAlice = (AliRun *) file->Get("gAlice") ;
+  
+  
+  
+  TClonesArray * sdigits = new TClonesArray("AliPHOSDigit",1000) ;
+
+  AliPHOS * PHOS = (AliPHOS *) gAlice->GetDetector("PHOS") ;
+  
+    
+  if(fNevents == 0) 
+    fNevents = (Int_t) gAlice->TreeE()->GetEntries() ; 
+  
+  Int_t ievent ;
+  for(ievent = 0; ievent < fNevents; ievent++){
+    gAlice->GetEvent(ievent) ;
+    gAlice->SetEvent(ievent) ;
+    
+    if(gAlice->TreeH()==0){
+      cout << "AliPHOSSDigitizer: There is no Hit Tree" << endl;
+      return ;
+    }
+    
+    if(gAlice->TreeS() == 0)
+      gAlice->MakeTree("S") ;
+    
+    TClonesArray * hits = PHOS->Hits() ;
+    
+    sdigits->Clear();
+    Int_t nSdigits = 0 ;
+    
+    //Make branches
+    char branchname[20];
+    sprintf(branchname,"%s",PHOS->GetName());  
+    
+    Int_t bufferSize = 16000 ;
+    char * file =0;
+    if(!fSDigitsFile.IsNull())
+      file = (char*) fSDigitsFile.Data() ; //ievent ;
+    else
+      if(gSystem->Getenv("CONFIG_SPLIT_FILE")){ //generating file name
+       file = new char[30] ;
+       //      sprintf(file,"PHOS.SDigits%d.root",ievent) ;
+       sprintf(file,"PHOS.SDigits.root") ;
+      }
+      else
+       file = 0 ;
+    
+    gAlice->MakeBranchInTree(gAlice->TreeS(),branchname,&sdigits,bufferSize,file);  
+
+
+    Int_t splitlevel = 0 ;
+    sprintf(branchname,"AliPHOSSDigitizer");   
+    AliPHOSSDigitizer * sd = this ;
+    gAlice->MakeBranchInTree(gAlice->TreeS(),branchname,"AliPHOSSDigitizer",&sd, bufferSize, splitlevel,file); 
+    
+
+    //Now made SDigits from hits, for PHOS it is the same
+
+    Int_t itrack ;
+    for (itrack=0; itrack<gAlice->GetNtrack(); itrack++){
+      
+      //=========== Get the Hits Tree for the Primary track itrack
+      gAlice->ResetHits();    
+      gAlice->TreeH()->GetEvent(itrack);
+      
+      Int_t i;
+      for ( i = 0 ; i < hits->GetEntries() ; i++ ) {
+       AliPHOSHit * hit = (AliPHOSHit*)hits->At(i) ;
+       AliPHOSDigit * newdigit ;
+
+       // Assign primary number only if contribution is significant
+       if( hit->GetEnergy() > fPrimThreshold)
+         newdigit = new AliPHOSDigit( hit->GetPrimary(), hit->GetId(), Digitize( hit->GetEnergy() ) ) ;
+       else
+         newdigit = new AliPHOSDigit( -1               , hit->GetId(), Digitize( hit->GetEnergy() ) ) ;
+       
+       new((*sdigits)[nSdigits]) AliPHOSDigit(* newdigit) ;
+       nSdigits++ ;  
+       
+       delete newdigit ;    
+      } 
+      
+    } // loop over tracks
+    
+    sdigits->Sort() ;
+    
+    nSdigits = sdigits->GetEntries() ;
+    sdigits->Expand(nSdigits) ;
+    
+    Int_t i ;
+    for (i = 0 ; i < nSdigits ; i++) { 
+      AliPHOSDigit * digit = (AliPHOSDigit *) sdigits->At(i) ; 
+      digit->SetIndexInList(i) ;     
+    }
+    
+    gAlice->TreeS()->Fill() ;
+    gAlice->TreeS()->Write(0,TObject::kOverwrite) ;
+  }
+
+  delete sdigits ;
+  if(file)
+    file->Close() ;
+
+}
+//__________________________________________________________________
+void AliPHOSSDigitizer::SetSDigitsFile(char * file ){
+  if(!fSDigitsFile.IsNull())
+    cout << "Changing SDigits file from " <<(char *)fSDigitsFile.Data() << " to " << file << endl ;
+  fSDigitsFile=file ;
+}
+//__________________________________________________________________
+void AliPHOSSDigitizer::Print(Option_t* option)const{
+  cout << "------------------- "<< GetName() << " -------------" << endl ;
+  if(fSDigitsFile.IsNull())
+    cout << " Writing SDigitis to file galice.root "<< endl ;
+  else
+    cout << "    Writing SDigitis to file  " << (char*) fSDigitsFile.Data() << endl ;
+  cout << "   with digitization parameters A = " << fA << endl ;
+  cout << "                                B = " << fB << endl ;
+  cout << "Threshold for Primary assignment  = " << fPrimThreshold << endl ; 
+  cout << "---------------------------------------------------"<<endl ;
+
+}
+//__________________________________________________________________
+Bool_t AliPHOSSDigitizer::operator==( AliPHOSSDigitizer const &sd )const{
+  if( (fA==sd.fA)&&(fB==sd.fB)&&(fPrimThreshold==sd.fPrimThreshold))
+    return kTRUE ;
+  else
+    return kFALSE ;
+}
diff --git a/PHOS/AliPHOSSDigitizer.h b/PHOS/AliPHOSSDigitizer.h
new file mode 100644 (file)
index 0000000..c452591
--- /dev/null
@@ -0,0 +1,55 @@
+#ifndef ALIPHOSSDigitizer_H
+#define ALIPHOSSDigitizer_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+//_________________________________________________________________________
+//  Task Class for making SDigits in PHOS      
+//                  
+//*-- Author: Dmitri Peressounko(SUBATECH & KI)
+
+
+// --- ROOT system ---
+#include "TTask.h"
+#include "TString.h"
+// --- Standard library ---
+
+// --- AliRoot header files ---
+
+class AliPHOSSDigitizer: public TTask {
+
+public:
+  AliPHOSSDigitizer() ;          // ctor
+  AliPHOSSDigitizer(char* HeaderFile,char *SdigitsFile = 0) ; 
+
+  virtual ~AliPHOSSDigitizer() ; // dtor
+  Float_t  Calibrate(Int_t amp){return (amp - fA)/fB ; }
+  Int_t    Digitize(Float_t Energy){ return (Int_t ) ( fA + Energy*fB); }
+
+  Float_t GetPedestalParameter(){return fA;}
+  Float_t GetCalibrationParameter(){return fB;}
+  char *GetSDigitsFile()const{return (char*) fSDigitsFile.Data();}  
+  virtual void  Exec(Option_t *option); 
+  void SetNEvents(Int_t Nevents){fNevents = Nevents;}
+  void SetPedestalParameter(Float_t A){fA = A ;}
+  void SetSlopeParameter(Float_t B){fB = B ;}
+  void SetSDigitsFile(char * file ) ;
+  virtual void Print(Option_t* option) const ;
+  Bool_t operator == (const AliPHOSSDigitizer & sd) const ;
+
+private:
+  Float_t fA ;              //Pedestal parameter
+  Float_t fB ;              //Slope Digitizition parameters
+  Int_t   fNevents ;        // Number of events to digitize
+  Float_t fPrimThreshold ;  // To store primari if Elos > threshold
+  TString fSDigitsFile ;    //output file 
+  TString fHeadersFile ;    //input file
+
+
+  ClassDef(AliPHOSSDigitizer,1)  // description 
+
+};
+
+#endif // AliPHOSSDigitizer_H
index eff8884..717fefd 100644 (file)
@@ -19,7 +19,8 @@ SRCS          =  AliPHOS.cxx AliPHOSv0.cxx AliPHOSv1.cxx AliPHOSv2.cxx \
                 AliPHOSCPVDigit.cxx AliPHOSDigit.cxx  \
                  AliPHOSRecPoint.cxx AliPHOSEmcRecPoint.cxx \
                 AliPHOSPpsdRecPoint.cxx AliPHOSCpvRecPoint.cxx \
-                AliPHOSClusterizer.cxx AliPHOSClusterizerv1.cxx  AliPHOSLink.cxx \
+                AliPHOSClusterizer.cxx AliPHOSClusterizerv1.cxx  \
+                 AliPHOSLink.cxx AliPHOSSDigitizer.cxx AliPHOSDigitizer.cxx\
                 AliPHOSReconstructioner.cxx  AliPHOSTrackSegment.cxx \
                  AliPHOSTrackSegmentMaker.cxx AliPHOSTrackSegmentMakerv1.cxx \
                  AliPHOSRecParticle.cxx AliPHOSPID.cxx AliPHOSPIDv1.cxx \
index 99839d2..35e2563 100644 (file)
@@ -18,6 +18,8 @@
 #pragma link C++ class AliPHOSPpsdRecPoint+;
 #pragma link C++ class AliPHOSReconstructioner+;
 #pragma link C++ class AliPHOSRecPoint+;
+#pragma link C++ class AliPHOSSDigitizer+;
+#pragma link C++ class AliPHOSDigitizer+;
 #pragma link C++ class AliPHOSv0+;
 #pragma link C++ class AliPHOSv1+;
 #pragma link C++ class AliPHOSv2+;