MixWith method has been corrected: only one event per file is in the folder
[u/mrichter/AliRoot.git] / PHOS / AliPHOSDigitizer.cxx
index a35c0af74a2efda071c788b4a15c843db42199ed..a01511fad926e258dc1bfb6304963b35f480a728 100644 (file)
 /* $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). 
+// This TTask performs digitization of Summable digits (in the PHOS case it is just
+// the sum of contributions from all primary particles into a given cell). 
 // In addition it performs mixing of summable digits from different events.
-// Examples of use:
+// The name of the TTask is also the title of the branch that will contain 
+// the created SDigits
+// The title of the TTAsk is the name of the file that contains the hits from
+// which the SDigits are created
+//
+// For each event two branches are created in TreeD:
+//   "PHOS" - list of digits
+//   "AliPHOSDigitizer" - AliPHOSDigitizer with all parameters used in digitization
+//
+// Note, that one can set a title for new digits branch, and repeat digitization with
+// another set of parameters.
+//
+// Use case:
 // 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[2] AliPHOSDigitizer * d1 = new AliPHOSDigitizer("galice1.root") ;  
+//                       // Will read sdigits from galice1.root
+// root[3] d1->MixWith("galice2.root")       
+// Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
+//                       // Reads another set of sdigits from galice2.root
+// root[3] d1->MixWith("galice3.root")       
+//                       // Reads another set of sdigits from galice3.root
+// root[4] d->ExecuteTask("deb timing")    
+//                       // Reads SDigits from files galice1.root, galice2.root ....
+//                       // mixes them and stores produced Digits in file galice1.root          
+//                       // deb - prints number of produced digits
+//                       // deb all - prints list of produced digits
+//                       // timing  - prints time used for digitization
 //
-// 
 
 // --- ROOT system ---
-#include "TTask.h"
+#include "TFile.h"
 #include "TTree.h"
 #include "TSystem.h"
+#include "TROOT.h"
+#include "TFolder.h"
+#include "TObjString.h"
+#include "TBenchmark.h"
 // --- Standard library ---
+#include <iomanip.h>
 
 // --- AliRoot header files ---
 
+#include "AliRun.h"
 #include "AliPHOSDigit.h"
-#include "AliPHOSHit.h"
-#include "AliPHOSv1.h"
+#include "AliPHOS.h"
+#include "AliPHOSGetter.h"
 #include "AliPHOSDigitizer.h"
 #include "AliPHOSSDigitizer.h"
-#include "TROOT.h"
-#include "TFolder.h"
+#include "AliPHOSGeometry.h"
 
 ClassImp(AliPHOSDigitizer)
 
 
 //____________________________________________________________________________ 
-  AliPHOSDigitizer::AliPHOSDigitizer():TTask("AliPHOSDigitizer","") 
+  AliPHOSDigitizer::AliPHOSDigitizer():TTask("","") 
 {
   // 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 ;
-  }
+  fPinNoise           = 0.01 ;
+  fEMCDigitThreshold  = 0.01 ;
+  fCPVNoise           = 0.01;
+  fCPVDigitThreshold  = 0.09 ;
+  fPPSDNoise          = 0.0000001;
+  fPPSDDigitThreshold = 0.0000002 ;  
 
 }
 
-
 //____________________________________________________________________________ 
-AliPHOSDigitizer::AliPHOSDigitizer(char *HeaderFile,char *DigitsFile):TTask("AliPHOSDigitizer","")
+AliPHOSDigitizer::AliPHOSDigitizer(const char *headerFile,const char * name):
+  TTask(name, headerFile)
 {
   // 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;
+   
+  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 ;
-    
+  Init() ;
+  
 }
 
 //____________________________________________________________________________ 
   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) ;
+void AliPHOSDigitizer::Digitize(const Int_t event) 
+{ 
+  
+  // Makes the digitization of the collected summable digits.
+  //  It first creates the array of all PHOS modules
+  //  filled with noise (different for EMC, CPV and PPSD) and
+  //  then adds contributions from SDigits. 
+  // This design avoids scanning over the list of digits to add 
+  // contribution to new SDigits only.
 
-  //Collects all hits in the same active volume into digit
-  //if(option == "raw")    // add simulated data to row data -- to be implemented
+  if( strcmp(GetName(), "") == 0 )
+    Init() ;
 
+  AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ; 
+  TClonesArray * digits = gime->Digits() ; 
 
-  fDigits->Clear() ;
+  digits->Clear() ;
 
-  AliPHOS * PHOS = (AliPHOS *) gAlice->GetDetector("PHOS") ;   
-  AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance( PHOS->GetGeometry()->GetName(), PHOS->GetGeometry()->GetTitle() );
+  const AliPHOSGeometry *geom = gime->PHOSGeometry() ; 
 
   //Making digits with noise, first EMC
   Int_t nEMC = geom->GetNModules()*geom->GetNPhi()*geom->GetNZ();
@@ -257,317 +157,498 @@ void AliPHOSDigitizer::Digitize(Option_t *option) {
       geom->GetNumberOfPadsPhi()*geom->GetNumberOfPadsZ() ;
   else
     nPPSD = nCPV; 
-  
+
+
+  digits->Expand(nPPSD) ;
+
+
+  // sdigitize random gaussian noise and add it to all cells (EMCA+CPV+PPSD) 
+  // get first the sdigitizer from the tasks list (must have same name as the digitizer)
+  const AliPHOSSDigitizer * sDigitizer = gime->SDigitizer(GetName()); 
+  if ( !sDigitizer) {
+    cerr << "ERROR: AliPHOSDigitizer::Digitize -> SDigitizer with name " << GetName() << " not found " << endl ; 
+    abort() ; 
+  }
   for(absID = 1; absID <= nEMC; absID++){
     Float_t noise = gRandom->Gaus(0., fPinNoise) ; 
-    new((*fDigits)[absID-1]) AliPHOSDigit( -1,absID,fSDigitizer->Digitize(noise) ) ;
+    new((*digits)[absID-1]) AliPHOSDigit( -1,absID,sDigitizer->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) ) ;
+    new((*digits)[absID-1]) AliPHOSDigit( -1,absID,sDigitizer->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) ) ;
+    new((*digits)[absID-1]) AliPHOSDigit( -1,absID,sDigitizer->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 ;
-    }  
+  // loop through the sdigits posted to the White Board and add them to the noise
+  TCollection * folderslist = ((TFolder*)gROOT->FindObjectAny("YSAlice/WhiteBoard/SDigits/PHOS"))->GetListOfFolders() ; 
+  TIter next(folderslist) ; 
+  TFolder * folder = 0 ; 
+  TClonesArray * sdigits = 0 ;  
+  TString eventS ; 
+  eventS += event ;
+  while ( (folder = (TFolder*)next()) ) {
+    if ( (strcmp(folder->GetTitle(), eventS.Data()) == 0) || (strcmp(folder->GetTitle(), "") == 0) ) {
+      Int_t numberoffiles = 0 ; 
+      if ( (sdigits = (TClonesArray*)folder->FindObject(GetName()) ) ) {
+       cout << "INFO: AliPHOSDigitizer::Digitize -> Adding SDigits " << GetName() << " from " << folder->GetName() << endl ; 
+       numberoffiles++ ; 
+       Int_t index ; 
+       AliPHOSDigit * curSDigit ; 
+       AliPHOSDigit * digit ; 
+       for ( index = 0 ; index < sdigits->GetEntriesFast(); index++) { 
+         curSDigit = (AliPHOSDigit*)sdigits->At(index) ; 
+         curSDigit->ShiftPrimary(numberoffiles) ;
+         digit = (AliPHOSDigit*)digits->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) ;
+    if(sDigitizer->Calibrate(((AliPHOSDigit*)digits->At(absID))->GetAmp()) < fEMCDigitThreshold)
+      digits->RemoveAt(absID) ;
+  
   for(absID = nEMC; absID < nCPV ; absID++)
-    if(fSDigitizer->Calibrate(((AliPHOSDigit*)fDigits->At(absID))->GetAmp()) < fCPVDigitThreshold)
-      fDigits->RemoveAt(absID) ;
+    if(sDigitizer->Calibrate(((AliPHOSDigit*)digits->At(absID))->GetAmp()) < fCPVDigitThreshold)
+      digits->RemoveAt(absID) ;
+  
   for(absID = nCPV; absID < nPPSD ; absID++)
-    if(fSDigitizer->Calibrate(((AliPHOSDigit *)fDigits->At(absID))->GetAmp()) < fPPSDDigitThreshold)
-      fDigits->RemoveAt(absID) ;
+    if(sDigitizer->Calibrate(((AliPHOSDigit *)digits->At(absID))->GetAmp()) < fPPSDDigitThreshold)
+      digits->RemoveAt(absID) ;
   
-  fDigits->Compress() ;  
+  digits->Compress() ;  
   
-  Int_t ndigits = fDigits->GetEntries() ;
-  fDigits->Expand(ndigits) ;
+  Int_t ndigits = digits->GetEntriesFast() ;
+
+  digits->Expand(ndigits) ;
 
 
   //Set indexes in list of digits
   Int_t i ;
   for (i = 0 ; i < ndigits ; i++) { 
-    AliPHOSDigit * digit = (AliPHOSDigit *) fDigits->At(i) ; 
+    AliPHOSDigit * digit = (AliPHOSDigit *) digits->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
+//____________________________________________________________________________
+void AliPHOSDigitizer::Exec(Option_t *option) 
+{ 
+  // Managing method
 
-  if(gAlice->TreeD()==0)
-    gAlice->MakeTree("D") ;
+  if( strcmp(GetName(), "") == 0 )    
+    Init() ;
   
-  //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 ;
+  if (strstr(option,"print")) {
+    Print("");
+    return ; 
+  }
   
-  //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); 
+  if(strstr(option,"tim"))
+    gBenchmark->Start("PHOSDigitizer");
+
+  //Check, if this branch already exits
+  TObjArray * lob = (TObjArray*)gAlice->TreeD()->GetListOfBranches() ;
+  TIter next(lob) ; 
+  TBranch * branch = 0 ;  
+  Bool_t phosfound = kFALSE, digitizerfound = kFALSE ; 
+  
+  while ( (branch = (TBranch*)next()) && (!phosfound || !digitizerfound) ) {
+    if ( (strcmp(branch->GetName(), "PHOS")==0) && (strcmp(branch->GetTitle(), GetName())==0) ) 
+      phosfound = kTRUE ;
+    
+    else if ( (strcmp(branch->GetName(), "AliPHOSDigitizer")==0) && (strcmp(branch->GetTitle(), GetName())==0) ) 
+      digitizerfound = kTRUE ; 
+  }
 
-  gAlice->TreeD()->Fill() ;
-   
-  gAlice->TreeD()->Write(0,kOverwrite) ;  
-}
+  if ( phosfound || digitizerfound ) {
+    cerr << "WARNING: AliPHOSDigitizer::WriteDigits -> Digits and/or Digitizer branch with name " << GetName() 
+        << " already exits" << endl ;
+    return ; 
+  }   
 
-//____________________________________________________________________________
-void AliPHOSDigitizer::Exec(Option_t *option) { 
-  //manager
+  Int_t nevents = (Int_t) gAlice->TreeE()->GetEntries() ;
+  Int_t ievent ;
 
-  if(!fInitialized)    Init(1) ;
-  
-  while(Combinator()){  
+  for(ievent = 0; ievent < nevents; ievent++){
+
+    gAlice->GetEvent(ievent);
+    gAlice->SetEvent(ievent) ;
+    if(!ReadSDigits(ievent)) //read sdigits event(s) evaluated by Combinator() from file(s)
+      continue ;    
     
-    if(!ReadSDigits()) //read sdigits event(s) evaluated by Combinator() from file(s)
-      return ;    
+    Digitize(ievent) ; //Add prepared SDigits to digits and add the noise
     
-    Digitize(option) ; //Add prepared SDigits to digits and add the noise
-    WriteDigits() ;
+    WriteDigits(ievent) ;
+   
+    if(strstr(option,"deb"))
+      PrintDigits(option);
   }
 
-//   //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() ;
-//   }
-
+  if(strstr(option,"tim")){
+    gBenchmark->Stop("PHOSDigitizer");
+    cout << "AliPHOSDigitizer:" << endl ;
+    cout << "  took " << gBenchmark->GetCpuTime("PHOSDigitizer") << " seconds for SDigitizing " 
+        <<  gBenchmark->GetCpuTime("PHOSDigitizer") << " seconds per event " << endl ;
+    //  <<  gBenchmark->GetCpuTime("PHOSDigitizer")/(fIeventMax->At(0)) << " seconds per event " << endl ;
+    cout << endl ;
+  }
   
 }
 
-//__________________________________________________________________
-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);
+//____________________________________________________________________________ 
+void AliPHOSDigitizer::Init()
+{
+  // Makes all memory allocations
+  // Adds Digitizer task to the folder of PHOS tasks
+   //============================================================= YS
+  //  The initialisation is now done by AliPHOSGetter
+    
+  if( strcmp(GetTitle(), "") == 0 )
+    SetTitle("galice.root") ;
+  
    
-    if(treeS==0){
-      cout << "Error at AliPHOSDigitizer: no "<<treeName << "   in file " << file->GetName() << endl ;
-      cout << "Do nothing " << endl ;
-      return kFALSE ;
-    }
+  // the SDigits name is stored by AliPHOSGetter as the name of the TClones Array 
+  // //YSAlice/WhiteBoard/SDigits/PHOS/headerFile/branchname and has branchTitle as title.    
+    
+  AliPHOSGetter * gime = AliPHOSGetter::GetInstance(GetTitle(), GetName()) ; 
+  if ( gime == 0 ) {
+    cerr << "ERROR: AliPHOSDigitizer::Init -> Could not obtain the Getter object !" << endl ; 
+    return ;
+  } 
+   
+//   fIevent    = new TArrayI(1) ;
+//   fIevent->AddAt(-1,0 ) ; 
+//   fIeventMax = new TArrayI(1) ;
+  
+//   fIeventMax->AddAt((Int_t) gAlice->TreeE()->GetEntries(), 0 );
+  
+  //add Task to //YSAlice/tasks/Digitizer/PHOS
+  TTask * aliceSD  = (TTask*)gROOT->FindObjectAny("YSAlice/tasks/Digitizer") ; 
+  TTask * phosSD   = (TTask*)aliceSD->GetListOfTasks()->FindObject("PHOS") ;
+  phosSD->Add(this) ; 
+  // create a folder on the white board //YSAlice/WhiteBoard/Digits/PHOS/headerFile/digitsTitle
+  gime->Post(GetTitle(), "D",  GetName() ) ;   
 
-    TBranch * sdigitsBranch = 0;
-    TBranch * sdigitizerBranch = 0;
+}
 
-    TObjArray * branches = treeS->GetListOfBranches() ;
-    Int_t ibranch;
-    Bool_t phosNotFound = kTRUE ;
-    Bool_t sdigitizerNotFound = kTRUE ;
+//__________________________________________________________________
+void AliPHOSDigitizer::MixWith(const char* headerFile)
+{
+  // Alows to produce digits by superimposing background and signal event.
+  // It is assumed, that headers file with SIGNAL events is opened in 
+  // the constructor. 
+  // Sets the BACKGROUND event, with which the SIGNAL event is to be mixed 
+  // Thus we avoid writing (changing) huge and expensive 
+  // backgound files: all output will be writen into SIGNAL, i.e. 
+  // opened in constructor file. 
+  //
+  // One can open as many files to mix with as one needs.
+  // However only Sdigits with the same name (i.e. constructed with the same SDigitizer)
+  // can be mixed.
+
+  if( strcmp(GetName(), "") == 0 )
+    Init() ;
+
+  const char* sDigitsTitle = GetName() ; 
   
-    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 ;
-         }
-       }
-      }
-      
+  // check if the specified SDigits do not already exist on the White Board:
+  // //YSAlice/WhiteBoard/SDigits/PHOS/headerFile/sDigitsTitle
+
+  TString path = "YSAlice/WhiteBoard/SDigits/PHOS/" ; 
+  path += headerFile ; 
+  path += "/" ; 
+  path += sDigitsTitle ;
+  if ( gROOT->FindObjectAny(path.Data()) ) {
+    cerr << "WARNING: AliPHOSDigitizer::MixWith -> Entry already exists, do not add" << endl ;
+    return;
+  }
+  // check if the requested file is already open or exist and if SDigits Branch exist
+  TFile * file = (TFile*)gROOT->FindObject(headerFile); 
+  if ( !file ) { 
+    file = new TFile(headerFile, "READ") ; 
+    if (!file) { 
+      cerr << "ERROR: AliPHOSDigitizer::MixWith -> File " << headerFile << " does not exist!" << endl ; 
+      return ; 
     }
+  }
 
-    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 ;
-    }
+  // Read the first event with SDigits from the file-to-mix and post it to SDigits folder
 
+  Int_t ievent =0 ; 
+  TString tsname("TreeS") ; 
+  tsname += ievent ; 
+  TTree * ts = (TTree*)file->Get(tsname.Data()) ;
+  if ( !ts ) {
+    cerr << "ERROR: AliPHOSDigitizer::MixWith -> TreeS0 " << " does not exist in " << headerFile << endl ; 
+    return ;
+  }
+    
+  TObjArray * lob = (TObjArray*)ts->GetListOfBranches() ;
+  TIter next(lob) ; 
+  TBranch * branch = 0 ; 
+  TBranch * sdigitsbranch = 0 ; 
+  TBranch * sdigitizerbranch = 0 ; 
+  Bool_t phosfound = kFALSE, sdigitizerfound = kFALSE ; 
+    
+  while ( (branch = (TBranch*)next()) && (!phosfound || !sdigitizerfound) ) {
+    if ( (strcmp(branch->GetName(), "PHOS")==0) && (strcmp(branch->GetTitle(), sDigitsTitle)==0) ) {
+      sdigitsbranch = branch ; 
+      phosfound = kTRUE ;
+    }
+    else if ( (strcmp(branch->GetName(), "AliPHOSSDigitizer")==0) && (strcmp(branch->GetTitle(), sDigitsTitle)==0) ) {
+      sdigitizerbranch = branch ; 
+      sdigitizerfound = kTRUE ; 
+    }
+  }
+    
+  if ( !phosfound || !sdigitizerfound ) {
+    cerr << "WARNING: AliPHOSDigitizer::MixWith -> Cannot find SDigits and/or SDigitizer with name " << sDigitsTitle << endl ;
+    return ; 
+  }   
+    
+  // post the new SDigits to the White Board
+  AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ; 
+  gime->Post(headerFile, "S", sDigitsTitle) ; 
+  TClonesArray * sdigits = gime->SDigits(sDigitsTitle, headerFile) ;  
+  sdigitsbranch->SetAddress(&sdigits) ;
+  sdigitsbranch->GetEvent(0) ;
+}
 
-    TClonesArray * sdigits = (TClonesArray*) fSDigits->At(inputs) ;  
-    sdigitsBranch->SetAddress(&sdigits) ;
+//__________________________________________________________________
+void AliPHOSDigitizer::Print(Option_t* option)const {
+  // Print Digitizer's parameters
+  if( strcmp(GetName(), "") != 0 ){
     
-    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 ;
-      }
+    cout << "------------------- "<< GetName() << " -------------" << endl ;
+    cout << "Digitizing sDigits from file(s): " <<endl ;
+    
+     TCollection * folderslist = ((TFolder*)gROOT->FindObjectAny("YSAlice/WhiteBoard/SDigits/PHOS"))->GetListOfFolders() ; 
+    TIter next(folderslist) ; 
+    TFolder * folder = 0 ; 
     
+    while ( (folder = (TFolder*)next()) ) {
+      if ( folder->FindObject(GetName())  ) 
+       cout << "Adding SDigits " << GetName() << " from " << folder->GetName() << endl ; 
+    }
+    cout << endl ;
+    cout << "Writing digits to " << GetTitle() << 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 ;
   }
+  else
+    cout << "AliPHOSDigitizer not initialized " << endl ;
   
+}
+//__________________________________________________________________
+void AliPHOSDigitizer::PrintDigits(Option_t * option){
+  // Print a table of digits
 
-  return kTRUE ;
+  AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ; 
+  TClonesArray * digits = gime->Digits() ; 
 
+  cout << "AliPHOSDigitiser: event " << gAlice->GetEvNumber() << endl ;
+  cout << "       Number of entries in Digits list " << digits->GetEntriesFast() << endl ;
+  cout << endl ;
+  if(strstr(option,"all")){
+    
+    //loop over digits
+    AliPHOSDigit * digit;
+    cout << "Digit Id " << " Amplitude " <<  " Index "  <<  " Nprim " << " Primaries list " <<  endl;      
+    Int_t index ;
+    for (index = 0 ; index < digits->GetEntries() ; index++) {
+      digit = (AliPHOSDigit * )  digits->At(index) ;
+      cout << setw(8)  <<  digit->GetId() << " "  <<   setw(3)  <<  digit->GetAmp() <<   "  "  
+          << setw(6)  <<  digit->GetIndexInList() << "  "   
+          << setw(5)  <<  digit->GetNprimary() <<"  ";
+      
+      Int_t iprimary;
+      for (iprimary=0; iprimary<digit->GetNprimary(); iprimary++)
+       cout << setw(5)  <<  digit->GetPrimary(iprimary+1) << " ";
+      cout << endl;     
+    }
+    
+  }
 }
+
 //__________________________________________________________________
-void AliPHOSDigitizer::MixWith(char* HeaderFile,Int_t isOutFile, char* SDigitsFile){
-//
+void AliPHOSDigitizer::SetSDigitsBranch(const char* title)
+{
+  // we set title (comment) of the SDigits branch in the first! header file
+  if( strcmp(GetName(), "") == 0 )
+    Init() ;
 
-  if(!fInitialized)
-    if(isOutFile)
-      Init(0) ;     //Do not read gAlice from Background file
-    else
-      Init(1) ;     //read gAlice from background file
+  AliPHOSGetter::GetInstance()->SDigits()->SetName(title) ; 
+}
 
-  if(HeaderFile == 0){
-    cout << "Specify at least header file to merge"<< endl ;
-    return ;
-  }
+//__________________________________________________________________
+Bool_t AliPHOSDigitizer::ReadSDigits(Int_t event)
+{
+  // Reads summable digits from the opened files for the particular set of events given by fIevent
+
+  AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ; 
   
-  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 ;
-       }
+  // loop over all opened files and read their SDigits to the White Board
+  TCollection * folderslist = ((TFolder*)gROOT->FindObjectAny("YSAlice/WhiteBoard/SDigits/PHOS"))->GetListOfFolders() ; 
+  TIter next(folderslist) ; 
+  TFolder * folder = 0 ; 
+  TClonesArray * sdigits = 0 ; 
+  while ( (folder = (TFolder*)next()) ) {
+    TFile * file = (TFile*)gROOT->GetFile(folder->GetName()); 
+    file->cd() ;
+
+    // Get SDigits Tree header from file
+    TString treeName("TreeS") ;
+    treeName += event ; 
+    TTree * treeS = (TTree*)file->Get(treeName.Data());
+    
+    if(treeS==0){
+      cerr << "ERROR: AliPHOSDigitizer::ReadSDigits There is no SDigit Tree" << endl;
+      return kFALSE;
+    }
+    //set address of the SDigits and SDigitizer
+    TBranch   * sdigitsBranch    = 0;
+    TBranch   * sdigitizerBranch = 0;
+    TBranch   * branch           = 0 ;  
+    TObjArray * lob = (TObjArray*)treeS->GetListOfBranches() ;
+    TIter next(lob) ; 
+    Bool_t phosfound = kFALSE, sdigitizerfound = kFALSE ; 
+    
+    while ( (branch = (TBranch*)next()) && (!phosfound || !sdigitizerfound) ) {
+      if ( (strcmp(branch->GetName(), "PHOS")==0) && (strcmp(branch->GetTitle(), GetName())==0) ) {
+       phosfound = kTRUE ;
+       sdigitsBranch = branch ; 
       }
-      else
-       if(((TObjString*)fSDigitsFiles->At(inputs))->GetString().CompareTo(SDigitsFile) == 0){
-       cout << "Entry already exists, do not add" << endl ;
-       return;
+      
+      else if ( (strcmp(branch->GetName(), "AliPHOSSDigitizer")==0) && (strcmp(branch->GetTitle(), GetName())==0) ) {
+       sdigitizerfound = kTRUE ; 
+       sdigitizerBranch = branch ;
       }
-    }  
-  }  
-  
-  fHeaderFiles->Expand(fNinputs+1) ;
-  new((*fHeaderFiles)[fNinputs]) TObjString(HeaderFile) ;
+    }
+    if ( !phosfound || !sdigitizerfound ) {
+      cerr << "WARNING: AliPHOSDigitizer::ReadSDigits -> Digits and/or Digitizer branch with name " << GetName() 
+          << " not found" << endl ;
+      return kFALSE ; 
+    }   
+    
+    
+    if ( (sdigits = (TClonesArray*)folder->FindObject(GetName()) ) ) {
+      sdigitsBranch->SetAddress(&sdigits) ;
+      sdigits->Clear();
+      
+      AliPHOSSDigitizer * sdigitizer = gime->SDigitizer() ; 
+      sdigitizerBranch->SetAddress(&sdigitizer) ;
+      
+      sdigitsBranch->GetEntry(0) ;
+      sdigitizerBranch->GetEntry(0) ;
+      
+      fPedestal = sdigitizer->GetPedestalParameter() ;
+      fSlope    = sdigitizer->GetCalibrationParameter() ;
+    }
+  }    
 
-  
-  TFile * file ;
-  if(isOutFile)
-    file = new TFile(((TObjString *) fHeaderFiles->At(fNinputs))->GetString(),"update") ;  
-  else
-    file = new TFile(((TObjString *) fHeaderFiles->At(fNinputs))->GetString()) ;  
+  // After SDigits have been read from all files, return to the first one
 
+  next.Reset();
+  folder = (TFolder*)next();
+  TFile * file = (TFile*)gROOT->GetFile(folder->GetName()); 
   file->cd() ;
 
-  fSDigitsFiles->Expand(fNinputs+1) ;
-  new((*fSDigitsFiles)[fNinputs]) TObjString(SDigitsFile) ;
+  return kTRUE ;
+
+}
 
-  fSDigits->Expand(fNinputs+1) ;
-  new((*fSDigits)[fNinputs]) TClonesArray("AliPHOSDigit",1000) ;
+//____________________________________________________________________________
+void AliPHOSDigitizer::Reset() 
+{ 
+  // sets current event number to the first simulated event
 
-  fIevent->Set(fNinputs+1) ;
-  fIevent->AddAt(-1, fNinputs) ;
+  if( strcmp(GetName(), "") == 0 )
+    Init() ;
 
-  fIeventMax->Set(fNinputs+1) ;  
+ //  Int_t inputs ;
+//   for(inputs = 0; inputs < fNinputs ;inputs++)
+//       fIevent->AddAt(-1, inputs ) ;
+  
+}
 
-  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 );
-  }
+//____________________________________________________________________________
+void AliPHOSDigitizer::WriteDigits(Int_t event)
+{
 
-  fNinputs++ ;
+  // Makes TreeD in the output file. 
+  // Check if branch already exists: 
+  //   if yes, exit without writing: ROOT TTree does not support overwriting/updating of 
+  //      already existing branches. 
+  //   else creates branch with Digits, named "PHOS", title "...",
+  //      and branch "AliPHOSDigitizer", with the same title to keep all the parameters
+  //      and names of files, from which digits are made.
 
-}
-//__________________________________________________________________
-void AliPHOSDigitizer::Print(Option_t* option){
+  AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ; 
+  TClonesArray * digits = gime->Digits() ; 
 
-  if(!fInitialized)    Init(1) ;
+  if(gAlice->TreeD()==0)
+    gAlice->MakeTree("D") ;  
+
+  // create new branches
+  // -- generate file name if necessary
+  char * file =0;
+  if(gSystem->Getenv("CONFIG_SPLIT_FILE")){ //generating file name
+    file = new char[strlen(gAlice->GetBaseFile())+20] ;
+    sprintf(file,"%s/PHOS.Digits.root",gAlice->GetBaseFile()) ;
+  }
 
-  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 ;
+  TDirectory *cwd = gDirectory;
+  // -- create Digits branch
+  Int_t bufferSize = 32000 ;    
+  TBranch * digitsBranch = gAlice->TreeD()->Branch("PHOS",&digits,bufferSize);
+  digitsBranch->SetTitle(GetName());
+  if (file) {
+    digitsBranch->SetFile(file);
+    TIter next( digitsBranch->GetListOfBranches());
+    TBranch * sbr ;
+    while ((sbr=(TBranch*)next())) {
+      sbr->SetFile(file);
+    }   
+    cwd->cd();
+  } 
+    
+  // -- Create Digitizer branch
+  Int_t splitlevel = 0 ;
+  AliPHOSDigitizer * d = gime->Digitizer(GetName()) ;
+  TBranch * digitizerBranch = gAlice->TreeD()->Branch("AliPHOSDigitizer", "AliPHOSDigitizer", &d,bufferSize,splitlevel); 
+  digitizerBranch->SetTitle(GetName());
+  if (file) {
+    digitizerBranch->SetFile(file);
+    TIter next( digitizerBranch->GetListOfBranches());
+    TBranch * sbr;
+    while ((sbr=(TBranch*)next())) {
+      sbr->SetFile(file);
+    }   
+    cwd->cd();
   }
-  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 ;
 
+  digitsBranch->Fill() ;      
+  digitizerBranch->Fill() ;
+
+  gAlice->TreeD()->Write(0,kOverwrite) ;  
 
 }