First implementation of embedding
authorgconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 23 Jul 2011 11:12:13 +0000 (11:12 +0000)
committergconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 23 Jul 2011 11:12:13 +0000 (11:12 +0000)
AliEMCAL: Method to transform raw data into sdigits added
AliEMCALDigit: flag for embedded digits added
AliEMCALLoader: Methods to recover OCDB reco param and bad map
AliEMCALDigitizer:
- In case of embedding, handle the merging differently, not add noise, not smear the real sdigits, add the sdigits later,
- Possibility to calibrate time and decalibrate time and energy added

Some example macros for embedding added

13 files changed:
EMCAL/AliEMCAL.cxx
EMCAL/AliEMCAL.h
EMCAL/AliEMCALDigit.h
EMCAL/AliEMCALDigitizer.cxx
EMCAL/AliEMCALDigitizer.h
EMCAL/AliEMCALLoader.cxx
EMCAL/AliEMCALLoader.h
EMCAL/CMakelibEMCALbase.pkg
EMCAL/CMakelibEMCALsim.pkg
EMCAL/EMCALbaseLinkDef.h
EMCAL/EMCALsimLinkDef.h
EMCAL/macros/embedding/raw2sdigits.C [new file with mode: 0644]
EMCAL/macros/embedding/simmerge.C [new file with mode: 0644]

index 9eebc52..4a51301 100644 (file)
@@ -51,9 +51,17 @@ class TFile;
 #include "AliEMCALRawUtils.h"
 #include "AliCDBManager.h"
 #include "AliCDBEntry.h"
+#include "AliEMCALRawUtils.h"
+#include "AliRawReader.h"
+#include "AliEMCALTriggerData.h"
+#include "AliEMCALRecParam.h"
+#include "AliRawEventHeaderBase.h"
 
 ClassImp(AliEMCAL)
 
+//for embedding
+AliEMCALRawUtils*        AliEMCAL::fgRawUtils   = 0;   // EMCAL raw utilities class
+
 //____________________________________________________________________________
 AliEMCAL::AliEMCAL()
   : AliDetector(),
@@ -61,12 +69,13 @@ AliEMCAL::AliEMCAL()
     fBirkC1(0.),
     fBirkC2(0.),
     fGeometry(0), 
-    fCheckRunNumberAndGeoVersion(kTRUE)
+    fCheckRunNumberAndGeoVersion(kTRUE),
+    fTriggerData(0x0)
 {
   // Default ctor 
   fName = "EMCAL" ;
   InitConstants();
-
+  
   // Should call  AliEMCALGeometry::GetInstance(EMCAL->GetTitle(),"") for getting EMCAL geometry
 }
 
@@ -77,16 +86,26 @@ AliEMCAL::AliEMCAL(const char* name, const char* title)
     fBirkC1(0.),
     fBirkC2(0.),
     fGeometry(0), 
-    fCheckRunNumberAndGeoVersion(kTRUE)
+    fCheckRunNumberAndGeoVersion(kTRUE),
+    fTriggerData(0x0)
 {
   //   ctor : title is used to identify the layout
   InitConstants();
+  
 }
 
 //____________________________________________________________________________
 AliEMCAL::~AliEMCAL()
 {
   //dtor
+  delete fgRawUtils;
+  delete fTriggerData;
+    
+  AliLoader *emcalLoader=0;
+  if ((emcalLoader = AliRunLoader::Instance()->GetDetectorLoader("EMCAL")))
+    emcalLoader->CleanSDigitizer();
+  
+
 }
 
 //____________________________________________________________________________
@@ -298,6 +317,107 @@ void AliEMCAL::Hits2SDigits()
   emcalDigitizer.ExecuteTask() ;
 }
 
+//______________________________________________________________________
+Bool_t AliEMCAL::Raw2SDigits(AliRawReader* rawReader){
+  
+  // Conversion from raw data to EMCAL sdigits. 
+  // Does the same as AliEMCALReconstructor::ConvertDigits()
+  // Needed to embed real data and simulation
+  // Works on a single-event basis
+  
+  rawReader->Reset() ; 
+  
+  //Get/create the sdigits tree and array
+       AliRunLoader *rl = AliRunLoader::Instance();
+       AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));    
+  emcalLoader->GetEvent();
+  emcalLoader->LoadSDigits("UPDATE");
+
+  TTree * treeS = emcalLoader->TreeS();
+  if ( !treeS ) { 
+    emcalLoader->MakeSDigitsContainer();
+    treeS = emcalLoader->TreeS();
+  }
+  
+  if(!emcalLoader->SDigits()) {
+    AliFatal("No sdigits array available\n");
+    return kFALSE;
+  }
+  
+  TClonesArray * sdigits = emcalLoader->SDigits();
+  sdigits->Clear("C");  
+  
+  //Trigger sdigits
+  if(!fTriggerData)fTriggerData = new AliEMCALTriggerData();
+  fTriggerData->SetMode(1);    
+  TClonesArray *digitsTrg = new TClonesArray("AliEMCALTriggerRawDigit", 32 * 96);    
+  Int_t bufsize = 32000;
+  treeS->Branch("EMTRG", &digitsTrg, bufsize);
+  
+  
+  //Only physics events
+  if (rawReader->GetType()== AliRawEventHeaderBase::kPhysicsEvent) {
+
+    if(!fgRawUtils)  fgRawUtils   = new AliEMCALRawUtils;
+    //must be done here because, in constructor, option is not yet known
+    fgRawUtils->SetOption(GetOption());
+    
+    // Set parameters from OCDB to raw utils
+    AliEMCALRecParam* recpar = emcalLoader->ReconstructionParameters(0);
+    // fgRawUtils->SetRawFormatHighLowGainFactor(recpar->GetHighLowGainFactor());
+    // fgRawUtils->SetRawFormatOrder(recpar->GetOrderParameter());
+    // fgRawUtils->SetRawFormatTau(recpar->GetTau());
+    fgRawUtils->SetNoiseThreshold(recpar->GetNoiseThreshold());
+    fgRawUtils->SetNPedSamples(recpar->GetNPedSamples());
+    fgRawUtils->SetRemoveBadChannels(recpar->GetRemoveBadChannels());
+    fgRawUtils->SetFittingAlgorithm(recpar->GetFittingAlgorithm());
+    fgRawUtils->SetFALTROUsage(recpar->UseFALTRO());
+    // fgRawUtils->SetTimeMin(recpar->GetTimeMin());
+    // fgRawUtils->SetTimeMax(recpar->GetTimeMax());
+
+    //Fit
+    fgRawUtils->Raw2Digits(rawReader,sdigits,emcalLoader->PedestalData(),digitsTrg,fTriggerData);
+    
+  }//skip calibration event
+  else{
+    AliDebug(1," Calibration Event, skip!");
+  }
+  
+  //Final arrangements of the array, set all sdigits as embedded
+  sdigits->Sort() ;
+  for (Int_t iSDigit = 0 ; iSDigit < sdigits->GetEntriesFast() ; iSDigit++) { 
+    AliEMCALDigit * sdigit = dynamic_cast<AliEMCALDigit *>(sdigits->At(iSDigit)) ;
+    if(sdigit){
+      sdigit->SetIndexInList(iSDigit) ;
+      sdigit->SetType(AliEMCALDigit::kEmbedded);
+    }
+    else {
+      AliFatal("sdigit is NULL!");
+    }
+  }    
+  
+  AliDebug(1,Form("Embedded sdigits entries %d \n",sdigits->GetEntriesFast()));
+  
+  //Write array, clean arrays, unload ..
+  
+  Int_t bufferSize = 32000 ;    
+  TBranch * sdigitsBranch = treeS->GetBranch("EMCAL");
+  if (sdigitsBranch)
+    sdigitsBranch->SetAddress(&sdigits);
+  else
+    treeS->Branch("EMCAL",&sdigits,bufferSize);
+  
+  treeS->Fill();
+  emcalLoader->WriteSDigits("OVERWRITE");
+  emcalLoader->UnloadSDigits();
+
+  digitsTrg->Delete();
+  delete digitsTrg;
+    
+  return kTRUE;
+  
+}
+
 //____________________________________________________________________________
 
 AliLoader* AliEMCAL::MakeLoader(const char* topfoldername)
index 130481b..4e2ea5a 100644 (file)
@@ -42,6 +42,9 @@ class AliRawReader;
 #include "AliDetector.h"
 #include "AliEMCALGeometry.h" 
 #include "AliEMCALTrigger.h" 
+class AliEMCALRawUtils;
+#include "AliReconstructor.h"
+class AliEMCALTriggerData;
 
 class AliEMCAL : public AliDetector {
 
@@ -74,6 +77,7 @@ class AliEMCAL : public AliDetector {
 
   virtual void  SetCheckRunNumberAndGeoVersion(Bool_t check) { fCheckRunNumberAndGeoVersion = check ; }
 
+  Bool_t Raw2SDigits(AliRawReader* rawReader);
   
 protected:
   void InitConstants();  //initializes some params
@@ -85,11 +89,15 @@ protected:
   AliEMCALGeometry* fGeometry;              //!
   Bool_t   fCheckRunNumberAndGeoVersion;    // Check if run number corresponds to the requested geometry and V1 is used
   
+  //For embedding
+  static AliEMCALRawUtils    * fgRawUtils;        // raw utilities class, for embedding 
+  AliEMCALTriggerData        * fTriggerData;      // Trigger parameters data container
+
 private:
   AliEMCAL(const AliEMCAL& emcal);
   AliEMCAL & operator = (const AliEMCAL & /*rvalue*/);
 
-  ClassDef(AliEMCAL,11) // Electromagnetic calorimeter (base class)
+  ClassDef(AliEMCAL,12) // Electromagnetic calorimeter (base class)
     
 } ;
 
index e672f8b..0d022b7 100644 (file)
@@ -39,82 +39,82 @@ class AliEMCALDigit : public AliDigitNew {
   AliEMCALDigit operator+(const AliEMCALDigit &rValue) ;
   AliEMCALDigit operator*(Float_t factor) ; 
   const AliEMCALDigit& operator = (const AliEMCALDigit &) {return *this;}
-  enum digitType{kUnknown=-1, kHG=0, kLG=1, kLGnoHG=2, kTrigger=3};
-
-  void    Clear(const Option_t*) ;     
-  Int_t   Compare(const TObject * obj) const ;
-  Float_t GetAmplitude()   const { if(!fAmp)return fAmpFloat ; else return fAmp ;}//Keep backward compatibility.
-  Float_t GetEta()         const ; 
-  Int_t   GetNprimary()    const { return fNprimary ;}
-  Int_t   GetPrimary(Int_t index)   const ; 
-  Float_t GetDEPrimary(Int_t index) const ; 
-  Int_t   GetNiparent()    const { return fNiparent ;}
-  Int_t   GetIparent(Int_t index)   const ;
-  Float_t GetDEParent(Int_t index)  const ; 
-  Float_t GetPhi()         const ;
-  Float_t GetTime(void)    const { return fTime  ;}
-  Float_t GetTimeR(void)   const { return fTimeR ;}
-  Float_t GetChi2(void)    const { return fChi2  ;}
-  Int_t   GetNDF(void)     const { return fNDF   ;}
-  Bool_t  IsSortable()     const { return kTRUE  ;}
-  Int_t   GetType()        const { return fDigitType ;}
+  enum  digitType{kUnknown=-1, kHG=0, kLG=1, kLGnoHG=2, kTrigger=3, kEmbedded = 4};
+
+  void     Clear(const Option_t*) ;    
+  Int_t    Compare(const TObject * obj) const ;
+  Float_t  GetAmplitude()   const { if(!fAmp)return fAmpFloat ; else return fAmp ;}//Keep backward compatibility.
+  Float_t  GetEta()         const ; 
+  Int_t    GetNprimary()    const { return fNprimary ;}
+  Int_t    GetPrimary(Int_t index)   const ; 
+  Float_t  GetDEPrimary(Int_t index) const ; 
+  Int_t    GetNiparent()    const { return fNiparent ;}
+  Int_t    GetIparent(Int_t index)   const ;
+  Float_t  GetDEParent(Int_t index)  const ; 
+  Float_t  GetPhi()         const ;
+  Float_t  GetTime(void)    const { return fTime  ;}
+  Float_t  GetTimeR(void)   const { return fTimeR ;}
+  Float_t  GetChi2(void)    const { return fChi2  ;}
+  Int_t    GetNDF(void)     const { return fNDF   ;}
+  Bool_t   IsSortable()     const { return kTRUE  ;}
+  Int_t    GetType()        const { return fDigitType ;}
        
-  void    SetAmp(Int_t amp)         { fAmp       = amp  ;} //old
-  void    SetAmplitude(Float_t amp) { fAmpFloat  = amp  ;}
-  void    SetId(Int_t idt)          { fId        = idt  ;}
-  void    SetTime(Float_t time)     { fTime      = time ;}
-  void    SetTimeR(Float_t time)    { fTimeR     = time ;}
-  void    SetChi2(Float_t chi)      { fChi2      = chi  ;}
-  void    SetNDF(Int_t ndf)         { fNDF       = ndf  ;}
-  void    SetType(Int_t t)          { fDigitType = t    ;}
-  void    ShiftPrimary(Int_t shift); // shift to separate different TreeK in merging
+  void     SetAmp(Int_t amp)         { fAmp       = amp  ; } //old
+  void     SetAmplitude(Float_t amp) { fAmpFloat  = amp  ; }
+  void     SetId(Int_t idt)          { fId        = idt  ; }
+  void     SetTime(Float_t time)     { fTime      = time ; }
+  void     SetTimeR(Float_t time)    { fTimeR     = time ; }
+  void     SetChi2(Float_t chi)      { fChi2      = chi  ; }
+  void     SetNDF(Int_t ndf)         { fNDF       = ndf  ; }
+  void     SetType(Int_t t)          { fDigitType = t    ; }
+  void     ShiftPrimary(Int_t shift); // shift to separate different TreeK in merging
 
   //Raw time sample
   //ALTRO
-  Int_t   GetNALTROSamplesLG() const {if(fDigitType==kLG)return fNSamples; else return 0;}
-  Bool_t  GetALTROSampleLG(const Int_t iSample, Int_t& timeBin, Int_t& amp) const;
-  Int_t   GetNALTROSamplesHG() const {if(fDigitType==kHG) return fNSamplesHG; else return 0;}
-  Bool_t  GetALTROSampleHG(const Int_t iSample, Int_t& timeBin, Int_t& amp) const;
+  Int_t    GetNALTROSamplesLG() const {if(fDigitType==kLG)      return fNSamples;   else return 0 ; }
+  Bool_t   GetALTROSampleLG(const Int_t iSample, Int_t& timeBin, Int_t& amp) const;
+  Int_t    GetNALTROSamplesHG() const {if(fDigitType==kHG)      return fNSamplesHG; else return 0 ; }
+  Bool_t   GetALTROSampleHG(const Int_t iSample, Int_t& timeBin, Int_t& amp) const;
   //FALTRO, trigger. Same data members as Low Gain     
-  Int_t   GetNFALTROSamples() const 
-       {if(fDigitType==kTrigger) return fNSamples; else return 0;}
-  Bool_t  GetFALTROSample(const Int_t iSample, Int_t& timeBin, Int_t& amp) const ;
+  Int_t    GetNFALTROSamples()  const {if(fDigitType==kTrigger) return fNSamples;   else return 0 ; }
+  Bool_t   GetFALTROSample(const Int_t iSample, Int_t& timeBin, Int_t& amp)  const ;
        
-  void SetALTROSamplesHG (const Int_t nSamplesHG, Int_t *samplesHG);
-  void SetALTROSamplesLG (const Int_t nSamplesLG, Int_t *samplesLG);
-  void SetFALTROSamples  (const Int_t nSamples,   Int_t *samples) { if(fDigitType==kTrigger) SetALTROSamplesLG(nSamples, samples);} 
+  void     SetALTROSamplesHG (const Int_t nSamplesHG, Int_t *samplesHG);
+  void     SetALTROSamplesLG (const Int_t nSamplesLG, Int_t *samplesLG);
+  void     SetFALTROSamples  (const Int_t nSamples,   Int_t *samples) 
+  { if(fDigitType==kTrigger) SetALTROSamplesLG(nSamples, samples) ; } 
 
-  void    SetCalibAmp(Float_t amp)  { fAmpCalib = amp; }
-  Double_t GetCalibAmp()   const    { return fAmpCalib; }
+  void     SetCalibAmp(Float_t amp) { fAmpCalib = amp  ; }
+  Double_t GetCalibAmp()   const    { return fAmpCalib ; }
 
-  void Print(const Option_t* /*opt*/) const;
+  void     Print(const Option_t* /*opt*/) const;
        
  private: 
        
-  Float_t fAmpFloat;    // Cell amplitude, float
-  Int_t   fNSamples;    // Number of time samples, Low Gain for ALTRO, used also for FALTRO 
-  Int_t*  fSamples;        //[fNSamples], list of time bin constents, Low Gain for ALTRO, used also for FALTRO 
-  Int_t   fNSamplesHG;  // Number of time samples, High Gain for ALTRO
-  Int_t*  fSamplesHG;  //[fNSamples], list of time bin constents, High Gain for ALTRO, used also for FALTRO 
+  Float_t  fAmpFloat;     // Cell amplitude, float
+  Int_t    fNSamples;     // Number of time samples, Low Gain for ALTRO, used also for FALTRO 
+  Int_t   *fSamples;       //[fNSamples], list of time bin constents, Low Gain for ALTRO, used also for FALTRO 
+  Int_t    fNSamplesHG;   // Number of time samples, High Gain for ALTRO
+  Int_t   *fSamplesHG;   //[fNSamples], list of time bin constents, High Gain for ALTRO, used also for FALTRO 
        
-  Int_t fNprimary ;     // Number of primaries
-  Int_t fNMaxPrimary ;  // Max Number of primaries
-  Int_t *fPrimary ;     //[fNMaxPrimary]  Array of primaries       
-  Float_t *fDEPrimary;  //[fNMaxPrimary]  Array of primary energy contributions
+  Int_t    fNprimary ;    // Number of primaries
+  Int_t    fNMaxPrimary ; // Max Number of primaries
+  Int_t   *fPrimary ;     //[fNMaxPrimary]  Array of primaries       
+  Float_t *fDEPrimary ;   //[fNMaxPrimary]  Array of primary energy contributions
     
-  Int_t fNiparent ;     // Number of initial parents 
-  Int_t fNMaxiparent ;  // Max Number of parents 
-  Int_t *fIparent ;     //[fNMaxiparent] Array of parents       
-  Float_t *fDEParent;   //[fNMaxiparent]  Array of parent energy contributions
-  Int_t fMaxIter  ;     // Number to Increment Maxiparent, and MaxPrimary if default is not sufficient
-  Float_t fTime ;       // Calculated time  
-  Float_t fTimeR ;      // Earliest time: to be used by Digits2Raw
+  Int_t    fNiparent ;    // Number of initial parents 
+  Int_t    fNMaxiparent ; // Max Number of parents 
+  Int_t   *fIparent ;     //[fNMaxiparent] Array of parents       
+  Float_t *fDEParent;     //[fNMaxiparent]  Array of parent energy contributions
+  Int_t    fMaxIter  ;    // Number to Increment Maxiparent, and MaxPrimary if default is not sufficient
+  Float_t  fTime ;        // Calculated time  
+  Float_t  fTimeR ;       // Earliest time: to be used by Digits2Raw
   //Fit quality parameters
-  Float_t fChi2;        // Fit Chi aquare      
-  Int_t   fNDF;         // Fit Number of Degrees of Freedom
+  Float_t  fChi2;         // Fit Chi aquare    
+  Int_t    fNDF;          // Fit Number of Degrees of Freedom
        
-  Int_t fDigitType;     // This is a trigger digit(0), HG (1) or LG (3)
-  Float_t fAmpCalib;    //!Calibrated energy
+  Int_t    fDigitType;    // This is a trigger digit(0), HG (1) or LG (3)
+  Float_t  fAmpCalib;     //!Calibrated energy
 
   ClassDef(AliEMCALDigit,6)   // Digit in EMCAL 
 } ;
index e8bae02..33894e8 100644 (file)
@@ -20,7 +20,7 @@
 //////////////////////////////////////////////////////////////////////////////
 // Class performs digitization of Summable digits from simulated data
 //  
-// In addition it performs mixing of summable digits from different events.
+// In addition it performs mixing/embedding of summable digits from different events.
 //
 // For each event two branches are created in TreeD:
 //   "EMCAL" - list of digits
 // Note, that one cset title for new digits branch, and repeat digitization with
 // another set of parameters.
 //
-// Examples of use:
-// root[0] AliEMCALDigitizer * d = new AliEMCALDigitizer() ;
-// root[1] d->ExecuteTask()             
-// Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
-//                       //Digitizes SDigitis in all events found in file galice.root 
-//
-// root[2] AliEMCALDigitizer * d1 = new AliEMCALDigitizer("galice1.root") ;  
-//                       // Will read sdigits from galice1.root
-// root[3] d1->MixWith("galice2.root")       
-// Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
-//                       // Reads another portion of sdigits from galice2.root
-// root[3] d1->MixWith("galice3.root")       
-//                       // Reads another portion 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
 ////////////////////////////////////////////////////////////////////////////////////
 //
 //*-- Author: Sahal Yacoob (LBL)
 // based on : AliEMCALDigitizer
 // Modif: 
 //  August 2002 Yves Schutz: clone PHOS as closely as possible and intoduction
-//                           of new  IO (à la PHOS)
+//                           of new IO (a la PHOS)
 //  November 2003 Aleksei Pavlinov : adopted for Shish-Kebab geometry 
 //_________________________________________________________________________________
 
@@ -139,11 +120,15 @@ AliEMCALDigitizer::AliEMCALDigitizer()
     fDigitThreshold(0),
     fMeanPhotonElectron(0),
     fPinNoise(0),
+    fTimeNoise(0),
     fTimeDelay(0),
     fTimeResolutionPar0(0),
     fTimeResolutionPar1(0),
     fADCchannelEC(0),
     fADCpedestalEC(0),
+    fADCchannelECDecal(0),
+    fTimeChannel(0),
+    fTimeChannelDecal(0),
     fNADCEC(0),
     fEventFolderName(""),
     fFirstEvent(0),
@@ -167,11 +152,15 @@ AliEMCALDigitizer::AliEMCALDigitizer(TString alirunFileName, TString eventFolder
     fDigitThreshold(0),
     fMeanPhotonElectron(0),
     fPinNoise(0),
+    fTimeNoise(0),
     fTimeDelay(0),
     fTimeResolutionPar0(0),
     fTimeResolutionPar1(0),
     fADCchannelEC(0),
     fADCpedestalEC(0),
+    fADCchannelECDecal(0),
+    fTimeChannel(0),
+    fTimeChannelDecal(0),
     fNADCEC(0),
     fEventFolderName(eventFolderName),
     fFirstEvent(0),
@@ -196,11 +185,14 @@ AliEMCALDigitizer::AliEMCALDigitizer(const AliEMCALDigitizer & d)
     fDigitThreshold(d.fDigitThreshold),
     fMeanPhotonElectron(d.fMeanPhotonElectron),
     fPinNoise(d.fPinNoise),
+    fTimeNoise(d.fTimeNoise),
     fTimeDelay(d.fTimeDelay),
     fTimeResolutionPar0(d.fTimeResolutionPar0),
     fTimeResolutionPar1(d.fTimeResolutionPar1),
     fADCchannelEC(d.fADCchannelEC),
     fADCpedestalEC(d.fADCpedestalEC),
+    fADCchannelECDecal(d.fADCchannelECDecal),
+    fTimeChannel(d.fTimeChannel), fTimeChannelDecal(d.fTimeChannelDecal),
     fNADCEC(d.fNADCEC),
     fEventFolderName(d.fEventFolderName),
     fFirstEvent(d.fFirstEvent),
@@ -222,11 +214,15 @@ AliEMCALDigitizer::AliEMCALDigitizer(AliRunDigitizer * rd)
     fDigitThreshold(0),
     fMeanPhotonElectron(0),
     fPinNoise(0.),
+    fTimeNoise(0.),
     fTimeDelay(0.),
     fTimeResolutionPar0(0.),
     fTimeResolutionPar1(0.),
     fADCchannelEC(0),
     fADCpedestalEC(0),
+    fADCchannelECDecal(0),
+    fTimeChannel(0),
+    fTimeChannelDecal(0),    
     fNADCEC(0),
     fEventFolderName(0),
     fFirstEvent(0),
@@ -273,291 +269,357 @@ void AliEMCALDigitizer::Digitize(Int_t event)
   // back to an energy in GeV before adding it to the Digit
   //
   static int nEMC=0; //max number of digits possible
-  
   AliRunLoader *rl = AliRunLoader::Instance();
   AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
   
   if(emcalLoader){
-  Int_t readEvent = event ; 
-  // fManager is data member from AliDigitizer
-  if (fManager) 
-    readEvent = dynamic_cast<AliStream*>(fManager->GetInputStream(0))->GetCurrentEventNumber() ; 
-  AliDebug(1,Form("Adding event %d from input stream 0 %s %s", 
-                  readEvent, GetTitle(), fEventFolderName.Data())) ; 
-  rl->GetEvent(readEvent);
+    Int_t readEvent = event ; 
+    // fManager is data member from AliDigitizer
+    if (fManager) 
+      readEvent = dynamic_cast<AliStream*>(fManager->GetInputStream(0))->GetCurrentEventNumber() ; 
+    AliDebug(1,Form("Adding event %d from input stream 0 %s %s", 
+                    readEvent, GetTitle(), fEventFolderName.Data())) ; 
+    rl->GetEvent(readEvent);
     
-  TClonesArray * digits = emcalLoader->Digits() ; 
-  digits->Delete() ;  //correct way to clear array when memory is
-  //allocated by objects stored in array
-  
-  // Load Geometry
-  AliEMCALGeometry *geom = 0;
-  if (!rl->GetAliRun()) {
-    AliFatal("Could not get AliRun from runLoader");
-  }
-  else{
-    AliEMCAL * emcal  = (AliEMCAL*)rl->GetAliRun()->GetDetector("EMCAL");
-    geom = emcal->GetGeometry();
-    nEMC = geom->GetNCells();
-    AliDebug(1,Form("nEMC %i (number cells in EMCAL) | %s \n", nEMC, geom->GetName()));
-  }
-  
-  Int_t absID = -1 ;
-  
-  digits->Expand(nEMC) ;
-  
-  // get first the sdigitizer from the tasks list (must have same name as the digitizer)
-  if ( !emcalLoader->SDigitizer() ) 
-    emcalLoader->LoadSDigitizer();
-  AliEMCALSDigitizer * sDigitizer = dynamic_cast<AliEMCALSDigitizer*>(emcalLoader->SDigitizer()); 
-  
-  if (!sDigitizer )
-  {
-    Fatal("Digitize", "SDigitizer with name %s %s not found", fEventFolderName.Data(), GetTitle() ) ; 
-  }
-  else
-  {
-    //take all the inputs to add together and load the SDigits
-    TObjArray * sdigArray = new TObjArray(fInput) ;
-    sdigArray->AddAt(emcalLoader->SDigits(), 0) ;
+    TClonesArray * digits = emcalLoader->Digits() ; 
+    digits->Delete() ;  //correct way to clear array when memory is
+    //allocated by objects stored in array
     
-    Int_t i ;
-    for(i = 1 ; i < fInput ; i++){
-      TString tempo(fEventNames[i]) ; 
-      tempo += i ;
-      
-      AliRunLoader *  rl2 = AliRunLoader::GetRunLoader(tempo) ; 
-      
-      if (rl2==0) 
-        rl2 = AliRunLoader::Open(fInputFileNames[i], tempo) ; 
-      
-      if (fManager) 
-        readEvent = dynamic_cast<AliStream*>(fManager->GetInputStream(i))->GetCurrentEventNumber() ; 
-      Info("Digitize", "Adding event %d from input stream %d %s %s", readEvent, i, fInputFileNames[i].Data(), tempo.Data()) ; 
-      rl2->LoadSDigits();
-      rl2->GetEvent(readEvent);
-      if(rl2->GetDetectorLoader("EMCAL"))
-      {
-        AliEMCALLoader *emcalLoader2 = dynamic_cast<AliEMCALLoader*>(rl2->GetDetectorLoader("EMCAL"));
-        if(emcalLoader2) sdigArray->AddAt(emcalLoader2->SDigits(), i) ;
-        else             AliFatal("EMCAL Loader of second event not available!");
-      }
-      else Fatal("Digitize", "Loader of second input not found");
+    // Load Geometry
+    AliEMCALGeometry *geom = 0;
+    if (!rl->GetAliRun()) {
+      AliFatal("Could not get AliRun from runLoader");
     }
+    else{
+      AliEMCAL * emcal  = (AliEMCAL*)rl->GetAliRun()->GetDetector("EMCAL");
+      geom = emcal->GetGeometry();
+      nEMC = geom->GetNCells();
+      AliDebug(1,Form("nEMC %i (number cells in EMCAL) | %s \n", nEMC, geom->GetName()));
+    }
+    
+    Int_t absID = -1 ;
+    
+    digits->Expand(nEMC) ;
     
-    //Find the first tower with signal
-    Int_t nextSig = nEMC + 1 ; 
-    TClonesArray * sdigits ;  
-    for(i = 0 ; i < fInput ; i++){
+    // get first the sdigitizer from the tasks list (must have same name as the digitizer)
+    if ( !emcalLoader->SDigitizer() ) 
+      emcalLoader->LoadSDigitizer();
+    AliEMCALSDigitizer * sDigitizer = dynamic_cast<AliEMCALSDigitizer*>(emcalLoader->SDigitizer()); 
+    
+    if (!sDigitizer )
+    {
+      Fatal("Digitize", "SDigitizer with name %s %s not found", fEventFolderName.Data(), GetTitle() ) ; 
+    }
+    else
+    {
       
-      sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
-      if(sdigits){
-        if (sdigits->GetEntriesFast() ){
-          AliEMCALDigit *sd = dynamic_cast<AliEMCALDigit *>(sdigits->At(0));
-          if(sd){
-            Int_t curNext = sd->GetId() ;
-            if(curNext < nextSig) 
-              nextSig = curNext ;
-            AliDebug(1,Form("input %i : #sdigits %i \n",
-                            i, sdigits->GetEntriesFast()));
+      //take all the inputs to add together and load the SDigits
+      TObjArray * sdigArray = new TObjArray(fInput) ;
+      sdigArray->AddAt(emcalLoader->SDigits(), 0) ;
+      Int_t i ;
+      Int_t embed = kFALSE;
+      for(i = 1 ; i < fInput ; i++){
+        TString tempo(fEventNames[i]) ; 
+        tempo += i ;
+        
+        AliRunLoader *  rl2 = AliRunLoader::GetRunLoader(tempo) ; 
+        
+        if (rl2==0) 
+          rl2 = AliRunLoader::Open(fInputFileNames[i], tempo) ; 
+        
+        if (fManager) 
+          readEvent = dynamic_cast<AliStream*>(fManager->GetInputStream(i))->GetCurrentEventNumber() ; 
+        Info("Digitize", "Adding event %d from input stream %d %s %s", readEvent, i, fInputFileNames[i].Data(), tempo.Data()) ; 
+        rl2->LoadSDigits();
+        //     rl2->LoadDigits();
+        rl2->GetEvent(readEvent);
+        if(rl2->GetDetectorLoader("EMCAL"))
+        {
+          AliEMCALLoader *emcalLoader2 = dynamic_cast<AliEMCALLoader*>(rl2->GetDetectorLoader("EMCAL"));
+          if(emcalLoader2) {
+            //Merge 2 simulated sdigits
+            if(emcalLoader2->SDigits()){
+              TClonesArray* sdigits2 = emcalLoader2->SDigits();
+              sdigArray->AddAt(sdigits2, i) ;
+              //Check if first sdigit is of embedded type, if so, handle the sdigits differently:
+              // do not smear energy of embedded, do not add noise to any sdigits
+              if(sdigits2->GetEntriesFast()>0){
+                 //printf("Merged digit type: %d\n",dynamic_cast<AliEMCALDigit*> (sdigits2->At(0))->GetType());
+                 if(dynamic_cast<AliEMCALDigit*> (sdigits2->At(0))->GetType()==AliEMCALDigit::kEmbedded){
+                   embed = kTRUE;
+                 }
+              }
+            }
             
-          }//First entry is not NULL
+          }//loader2
+          else  AliFatal("EMCAL Loader of second event not available!");
+          
+        }
+        else Fatal("Digitize", "Loader of second input not found");
+      }// input loop
+      
+      //Find the first tower with signal
+      Int_t nextSig = nEMC + 1 ; 
+      TClonesArray * sdigits ;  
+      for(i = 0 ; i < fInput ; i++){
+        if(i > 0 && embed) continue;
+        sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
+        if(sdigits){
+          if (sdigits->GetEntriesFast() ){
+            AliEMCALDigit *sd = dynamic_cast<AliEMCALDigit *>(sdigits->At(0));
+            if(sd){
+              Int_t curNext = sd->GetId() ;
+              if(curNext < nextSig) 
+                nextSig = curNext ;
+              AliDebug(1,Form("input %i : #sdigits %i \n",
+                              i, sdigits->GetEntriesFast()));
+              
+            }//First entry is not NULL
+            else {
+              Info("Digitize", "NULL sdigit pointer");
+              continue;
+            }
+          }//There is at least one entry
           else {
-            Info("Digitize", "NULL sdigit pointer");
+            Info("Digitize", "NULL sdigits array");
             continue;
           }
-        }//There is at least one entry
+        }// SDigits array exists
         else {
-          Info("Digitize", "NULL sdigits array");
+          Info("Digitizer","Null sdigit pointer");
           continue;
         }
-      }// SDigits array exists
-      else {
-        Info("Digitizer","Null sdigit pointer");
-        continue;
-      }
-    }// input loop
-    AliDebug(1,Form("FIRST tower with signal %i \n", nextSig));
-    
-    TArrayI index(fInput) ;
-    index.Reset() ;  //Set all indexes to zero
-    
-    AliEMCALDigit * digit ;
-    AliEMCALDigit * curSDigit ;
-    
-    //  TClonesArray * ticks = new TClonesArray("AliEMCALTick",1000) ;
-    
-    //Put Noise contribution
-    for(absID = 0; absID < nEMC; absID++){ // Nov 30, 2006 by PAI; was from 1 to nEMC
-      Float_t energy = 0 ;
-      // amplitude set to zero, noise will be added later
-      new((*digits)[absID]) AliEMCALDigit( -1, -1, absID, 0., TimeOfNoise(),kFALSE); // absID-1->absID
-      //look if we have to add signal?
+      }// input loop
+      AliDebug(1,Form("FIRST tower with signal %i \n", nextSig));
+      
+      TArrayI index(fInput) ;
+      index.Reset() ;  //Set all indexes to zero
+      
+      AliEMCALDigit * digit ;
+      AliEMCALDigit * curSDigit ;
       
-      digit = dynamic_cast<AliEMCALDigit *>(digits->At(absID)); // absID-1->absID
+      //  TClonesArray * ticks = new TClonesArray("AliEMCALTick",1000) ;
       
-      if (digit) {
+      //Put Noise contribution, smear time and energy     
+      Float_t timeResolution = 0;
+      for(absID = 0; absID < nEMC; absID++){ // Nov 30, 2006 by PAI; was from 1 to nEMC
+        Float_t energy = 0 ;    
         
-        if(absID==nextSig){
-          //Add SDigits from all inputs    
-          //      ticks->Clear() ;
-          //Int_t contrib = 0 ;
+        // amplitude set to zero, noise will be added later
+        Float_t noiseTime = 0.;
+        if(!embed) noiseTime = TimeOfNoise(); //No need for embedded events?
+        new((*digits)[absID]) AliEMCALDigit( -1, -1, absID, 0., noiseTime,kFALSE); // absID-1->absID
+        //look if we have to add signal?
+        digit = dynamic_cast<AliEMCALDigit *>(digits->At(absID)); // absID-1->absID
+        
+        if (digit) {
           
-          //Follow PHOS and comment out this timing model til a better one
-          //can be developed - JLK 28-Apr-2008
+          if(absID==nextSig){
+
+            // Calculate time as time of the largest digit
+            Float_t time = digit->GetTime() ;
+            Float_t aTime= digit->GetAmplitude() ;
+            
+            // loop over input
+            Int_t nInputs = fInput;
+            if(embed) nInputs = 1; // In case of embedding, merge later real digits, do not smear energy and time of data
+            for(i = 0; i< nInputs ; i++){  //loop over (possible) merge sources
+              TClonesArray* sdtclarr = dynamic_cast<TClonesArray *>(sdigArray->At(i));
+              if(sdtclarr) {
+                Int_t sDigitEntries = sdtclarr->GetEntriesFast();
+                
+                if(sDigitEntries > index[i] )
+                  curSDigit = dynamic_cast<AliEMCALDigit*>(sdtclarr->At(index[i])) ;   
+                else
+                  curSDigit = 0 ;
+                
+                //May be several digits will contribute from the same input
+                while(curSDigit && (curSDigit->GetId() == absID)){        
+                  //Shift primary to separate primaries belonging different inputs
+                  Int_t primaryoffset ;
+                  if(fManager)
+                    primaryoffset = fManager->GetMask(i) ; 
+                  else
+                    primaryoffset = i ;
+                  curSDigit->ShiftPrimary(primaryoffset) ;
+                  
+                  if(curSDigit->GetAmplitude()>aTime) {
+                    aTime = curSDigit->GetAmplitude();
+                    time  = curSDigit->GetTime();
+                  }
+                  
+                  *digit = *digit + *curSDigit ;  //adds amplitudes of each digit
+                  
+                  index[i]++ ;
+                  
+                  if( sDigitEntries > index[i] )
+                    curSDigit = dynamic_cast<AliEMCALDigit*>(sdtclarr->At(index[i])) ;
+                  else
+                    curSDigit = 0 ;
+                }// while
+              }// source exists
+            }// loop over merging sources
+            
+            
+            //Here we convert the summed amplitude to an energy in GeV only for simulation or mixing of simulations
+            energy = sDigitizer->Calibrate(digit->GetAmplitude()) ; // GeV
+            
+            // add fluctuations for photo-electron creation
+            energy *= static_cast<Float_t>(gRandom->Poisson(fMeanPhotonElectron)) / static_cast<Float_t>(fMeanPhotonElectron) ;
+            
+            //calculate and set time
+            //New timing model needed - JLK 28-April-2008
+            //Float_t time = FrontEdgeTime(ticks) ;
+            digit->SetTime(time) ;
+            
+            //Find next signal module
+            nextSig = nEMC + 1 ;
+            for(i = 0 ; i < nInputs ; i++){
+              sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
+              
+              if(sdigits){
+                Int_t curNext = nextSig ;
+                if(sdigits->GetEntriesFast() > index[i])
+                {
+                  AliEMCALDigit * tmpdigit = dynamic_cast<AliEMCALDigit *>(sdigits->At(index[i]));
+                  if(tmpdigit)
+                  {
+                    curNext = tmpdigit->GetId() ;        
+                  }
+                }
+                if(curNext < nextSig) nextSig = curNext ;
+              }// sdigits exist
+            } // input loop       
+            
+          }//absID==nextSig
           
-          //Float_t a = digit->GetAmplitude() ;
-          //Float_t b = TMath::Abs( a /fTimeSignalLength) ;
-          //Mark the beginning of the signal
-          //new((*ticks)[contrib++]) AliEMCALTick(digit->GetTime(),0, b);  
-          //Mark the end of the signal     
-          //new((*ticks)[contrib++]) AliEMCALTick(digit->GetTime()+fTimeSignalLength, -a, -b);
+          // add the noise now, no need for embedded events with real data
+          if(!embed)
+            energy += TMath::Abs(gRandom->Gaus(0., fPinNoise)) ;
           
-          // Calculate time as time of the largest digit
-          Float_t time = digit->GetTime() ;
-          Float_t aTime= digit->GetAmplitude() ;
+
+          // JLK 26-June-2008
+          //Now digitize the energy according to the sDigitizer method,
+          //which merely converts the energy to an integer.  Later we will
+          //check that the stored value matches our allowed dynamic ranges
+          digit->SetAmplitude(sDigitizer->Digitize(energy)) ; 
           
-          // loop over input
-          for(i = 0; i< fInput ; i++){  //loop over (possible) merge sources
-            TClonesArray* sdtclarr = dynamic_cast<TClonesArray *>(sdigArray->At(i));
-            if(sdtclarr) {
-              Int_t sDigitEntries = sdtclarr->GetEntriesFast();
-              
-              if(sDigitEntries > index[i] )
-                curSDigit = dynamic_cast<AliEMCALDigit*>(sdtclarr->At(index[i])) ;     
-              else
-                curSDigit = 0 ;
-              
-              //May be several digits will contribute from the same input
-              while(curSDigit && (curSDigit->GetId() == absID)){          
-                //Shift primary to separate primaries belonging different inputs
-                Int_t primaryoffset ;
-                if(fManager)
-                  primaryoffset = fManager->GetMask(i) ; 
-                else
-                  primaryoffset = i ;
-                curSDigit->ShiftPrimary(primaryoffset) ;
+          //Set time resolution with final energy
+          timeResolution = GetTimeResolution(energy);
+          digit->SetTime(gRandom->Gaus(digit->GetTime(),timeResolution) ) ;
+          AliDebug(10,Form(" absID %5i energy %f nextSig %5i\n",
+                           absID, energy, nextSig));
+          //Add delay to time
+          digit->SetTime(digit->GetTime()+fTimeDelay) ;
+          
+        }// Digit pointer exists
+        else{
+          Info("Digitizer","Digit pointer is null");
+        }
+      } // for(absID = 0; absID < nEMC; absID++)
+      
+      //ticks->Delete() ;
+      //delete ticks ;
+
+      //Embed simulated amplitude (and time?) to real data digits
+      if(embed){
+        for(Int_t input = 1; input<fInput; input++){
+          TClonesArray *realDigits = dynamic_cast<TClonesArray*> (sdigArray->At(input));
+          if(!realDigits){
+            AliDebug(1,"No sdigits to merge\n");
+            continue;
+          }
+          for(Int_t i2 = 0 ; i2 < realDigits->GetEntriesFast() ; i2++){
+            AliEMCALDigit * digit2 = dynamic_cast<AliEMCALDigit*>( realDigits->At(i2) ) ;
+            if(digit2){
+              digit = dynamic_cast<AliEMCALDigit*>( digits->At(digit2->GetId()) ) ;
+              if(digit){
                 
-                //Remove old timing model - JLK 28-April-2008
-                //a = curSDigit->GetAmplitude() ;
-                //b = a /fTimeSignalLength ;
-                //new((*ticks)[contrib++]) AliEMCALTick(curSDigit->GetTime(),0, b);  
-                //new((*ticks)[contrib++]) AliEMCALTick(curSDigit->GetTime()+fTimeSignalLength, -a, -b); 
-                if(curSDigit->GetAmplitude()>aTime) {
-                  aTime = curSDigit->GetAmplitude();
-                  time  = curSDigit->GetTime();
-                }
+                // Put the embedded cell energy in same units as simulated sdigits -> transform to energy units
+                // and multiply to get a big int.
+                Float_t time2 = digit2->GetTime(); 
+                Float_t e2    = digit2->GetAmplitude();
+                CalibrateADCTime(e2,time2,digit2->GetId());
+                Float_t amp2 = sDigitizer->Digitize(e2);
                 
-                *digit = *digit + *curSDigit ;  //adds amplitudes of each digit
+                Float_t e0    = digit ->GetAmplitude();
+                if(e0>0.01)
+                  AliDebug(1,Form("digit 1: Abs ID %d, amp %f, type %d, time %e; digit2: Abs ID %d, amp %f, type %d, time %e\n",
+                                  digit ->GetId(),digit ->GetAmplitude(), digit ->GetType(), digit->GetTime(),
+                                  digit2->GetId(),amp2,                   digit2->GetType(), time2           ));
                 
-                index[i]++ ;
-                if( sDigitEntries > index[i] )
-                  curSDigit = dynamic_cast<AliEMCALDigit*>(sdtclarr->At(index[i])) ;
-                else
-                  curSDigit = 0 ;
-              }// while
-            }// source exists
-          }// loop over merging sources
-          
-          //Here we convert the summed amplitude to an energy in GeV
-          energy = sDigitizer->Calibrate(digit->GetAmplitude()) ; // GeV
-          // add fluctuations for photo-electron creation
-          energy *= static_cast<Float_t>(gRandom->Poisson(fMeanPhotonElectron)) / static_cast<Float_t>(fMeanPhotonElectron) ;
-          
-          //calculate and set time
-          //New timing model needed - JLK 28-April-2008
-          //Float_t time = FrontEdgeTime(ticks) ;
-          digit->SetTime(time) ;
+                // Sum amplitudes, change digit amplitude
+                digit->SetAmplitude( digit->GetAmplitude() + amp2);
+                // Rough assumption, assign time of the largest of the 2 digits, 
+                // data or signal to the final digit.
+                if(amp2 > digit->GetAmplitude())  digit->SetTime(time2);
+                //Mark the new digit as embedded
+                digit->SetType(AliEMCALDigit::kEmbedded);
+                
+                if(digit2->GetAmplitude()>0.01 && e0> 0.01 )
+                  AliDebug(1,Form("Embedded digit: Abs ID %d, amp %f, type %d\n",
+                                  digit->GetId(), digit->GetAmplitude(), digit->GetType()));
+              }//digit2 
+            }//digit2
+          }//loop digit 2
+        }//input loop
+      }//embed
+      
+      //JLK is it better to call Clear() here?
+      delete sdigArray ; //We should not delete its contents
+      
+      //remove digits below thresholds
+      // until 10-02-2010 remove digits with energy smaller than fDigitThreshold 3*fPinNoise
+      // now, remove digits with Digitized ADC smaller than fDigitThreshold = 3,
+      // before merge in the same loop real data digits if available
+      Float_t energy = 0;
+      Float_t time   = 0;
+      for(i = 0 ; i < nEMC ; i++){
+        digit = dynamic_cast<AliEMCALDigit*>( digits->At(i) ) ;
+        if(digit){
           
-          //Find next signal module
-          nextSig = nEMC + 1 ;
-          for(i = 0 ; i < fInput ; i++){
-            sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
-            if(sdigits){
-              Int_t curNext = nextSig ;
-              if(sdigits->GetEntriesFast() > index[i]){
-                AliEMCALDigit * tmpdigit = dynamic_cast<AliEMCALDigit *>(sdigits->At(index[i]));
-                if (tmpdigit){
-                  curNext = tmpdigit->GetId() ;          
-                }
-              }
-              if(curNext < nextSig) nextSig = curNext ;
-            }// sdigits exist
-          } // input loop       
+          //Then get the energy in GeV units.
+          energy = sDigitizer->Calibrate(digit->GetAmplitude()) ;
+          //Then digitize using the calibration constants of the ocdb
+          Float_t ampADC = energy;
+          DigitizeEnergyTime(ampADC, time, digit->GetId())  ;    
+          if(ampADC < fDigitThreshold)
+            digits->RemoveAt(i) ;
           
-        }//absID==nextSig
-        
-        // add the noise now
-        energy += TMath::Abs(gRandom->Gaus(0., fPinNoise)) ;
-        // JLK 26-June-2008
-        //Now digitize the energy according to the sDigitizer method,
-        //which merely converts the energy to an integer.  Later we will
-        //check that the stored value matches our allowed dynamic ranges
-        digit->SetAmplitude(sDigitizer->Digitize(energy)) ;  
-        AliDebug(10,Form(" absID %5i energy %f nextSig %5i\n",
-                         absID, energy, nextSig));
-      }// Digit pointer exists
-      else{
-        Info("Digitizer","Digit pointer is null");
-      }
-    } // for(absID = 0; absID < nEMC; absID++)
-    
-    //ticks->Delete() ;
-    //delete ticks ;
-    
-    //JLK is it better to call Clear() here?
-    delete sdigArray ; //We should not delete its contents
-    
-    //remove digits below thresholds
-    // until 10-02-2010 remove digits with energy smaller than fDigitThreshold 3*fPinNoise
-    // now, remove digits with Digitized ADC smaller than fDigitThreshold = 3
-    Float_t energy=0;
-    Float_t timeResolution = 0;
-    for(i = 0 ; i < nEMC ; i++){
-      digit = dynamic_cast<AliEMCALDigit*>( digits->At(i) ) ;
-      if(digit){
-        //First get the energy in GeV units.
-        energy = sDigitizer->Calibrate(digit->GetAmplitude()) ;
-        //Then digitize using the calibration constants of the ocdb
-        Float_t ampADC = DigitizeEnergy(energy, digit->GetId())  ;       
-        //if(ampADC>2)printf("Digit energy %f, amp %d, amp cal %d, threshold %d\n",energy,digit->GetAmplitude(),ampADC,fDigitThreshold);
-        if(ampADC < fDigitThreshold)
-          digits->RemoveAt(i) ;
-        else {
-         timeResolution = GetTimeResolution(energy);
-          digit->SetTime(gRandom->Gaus(digit->GetTime(),timeResolution) ) ;
-       }
-      }// digit exists
-    } // digit loop
-    
-    digits->Compress() ;  
-    
-    Int_t ndigits = digits->GetEntriesFast() ; 
-    
-    //JLK 26-June-2008
-    //After we have done the summing and digitizing to create the
-    //digits, now we want to calibrate the resulting amplitude to match
-    //the dynamic range of our real data.  
-    for (i = 0 ; i < ndigits ; i++) { 
-      digit = dynamic_cast<AliEMCALDigit *>( digits->At(i) ) ; 
-      if(digit){
-        digit->SetIndexInList(i) ; 
-        energy = sDigitizer->Calibrate(digit->GetAmplitude()) ;
-        digit->SetAmplitude(DigitizeEnergy(energy, digit->GetId()) ) ;
-        //Add delay to time
-        digit->SetTime(digit->GetTime()+fTimeDelay) ;
-        // printf("digit amplitude set at end: i %d, amp %f\n",i,digit->GetAmplitude());
-      }// digit exists
-    }//Digit loop
-    
-  }//SDigitizer not null
+        }// digit exists
+      } // digit loop
+      
+      digits->Compress() ;  
+      
+      Int_t ndigits = digits->GetEntriesFast() ; 
+
+      //JLK 26-June-2008
+      //After we have done the summing and digitizing to create the
+      //digits, now we want to calibrate the resulting amplitude to match
+      //the dynamic range of our real data.  
+      for (i = 0 ; i < ndigits ; i++) { 
+        digit = dynamic_cast<AliEMCALDigit *>( digits->At(i) ) ; 
+        if(digit){
+          digit->SetIndexInList(i) ; 
+          energy = sDigitizer->Calibrate(digit->GetAmplitude()) ;
+          time   = digit->GetTime();
+          Float_t ampADC = energy;
+          DigitizeEnergyTime(ampADC, time, digit->GetId());
+          digit->SetAmplitude(ampADC) ;
+          digit->SetTime(time);
+          // printf("digit amplitude set at end: i %d, amp %f\n",i,digit->GetAmplitude());
+        }// digit exists
+      }//Digit loop
+      
+    }//SDigitizer not null
   }
   else AliFatal("EMCALLoader is NULL!") ;
-
+  
 }
 
-// //_____________________________________________________________________
-Float_t AliEMCALDigitizer::DigitizeEnergy(Float_t energy, Int_t AbsId)
+//_____________________________________________________________________
+void AliEMCALDigitizer::DigitizeEnergyTime(Float_t & energy, Float_t & time, const Int_t absId)
 { 
   // JLK 26-June-2008
   // Returns digitized value of the energy in a cell absId
@@ -568,40 +630,82 @@ Float_t AliEMCALDigitizer::DigitizeEnergy(Float_t energy, Int_t AbsId)
   //
   // Load Geometry
   const AliEMCALGeometry * geom = AliEMCALGeometry::GetInstance();
-
-  Float_t channel = -999; 
   
   if (geom==0){
     AliFatal("Did not get geometry from EMCALLoader");
+    return;
   }
-  else {
-    Int_t iSupMod = -1;
-    Int_t nModule  = -1;
-    Int_t nIphi   = -1;
-    Int_t nIeta   = -1;
-    Int_t iphi    = -1;
-    Int_t ieta    = -1;
-    Bool_t bCell = geom->GetCellIndex(AbsId, iSupMod, nModule, nIphi, nIeta) ;
-    if(!bCell)
-      Error("DigitizeEnergy","Wrong cell id number : AbsId %i ", AbsId) ;
-    geom->GetCellPhiEtaIndexInSModule(iSupMod,nModule,nIphi, nIeta,iphi,ieta);
   
-    if(fCalibData) {
-      fADCpedestalEC = fCalibData->GetADCpedestal(iSupMod,ieta,iphi);
-      fADCchannelEC = fCalibData->GetADCchannel(iSupMod,ieta,iphi);
-    }
+  Int_t iSupMod = -1;
+  Int_t nModule = -1;
+  Int_t nIphi   = -1;
+  Int_t nIeta   = -1;
+  Int_t iphi    = -1;
+  Int_t ieta    = -1;
+  Bool_t bCell = geom->GetCellIndex(absId, iSupMod, nModule, nIphi, nIeta) ;
+  if(!bCell)
+    Error("DigitizeEnergyTime","Wrong cell id number : absId %i ", absId) ;
+  geom->GetCellPhiEtaIndexInSModule(iSupMod,nModule,nIphi, nIeta,iphi,ieta);
   
-    //channel = static_cast<Int_t> (TMath::Floor( (energy + fADCpedestalEC)/fADCchannelEC ))  ;
-    channel = (energy + fADCpedestalEC)/fADCchannelEC   ;
+  if(fCalibData) {
+    fADCpedestalEC     = fCalibData->GetADCpedestal     (iSupMod,ieta,iphi);
+    fADCchannelEC      = fCalibData->GetADCchannel      (iSupMod,ieta,iphi);
+    fADCchannelECDecal = fCalibData->GetADCchannelDecal (iSupMod,ieta,iphi);
+    fTimeChannel       = fCalibData->GetTimeChannel     (iSupMod,ieta,iphi);
+    fTimeChannelDecal  = fCalibData->GetTimeChannelDecal(iSupMod,ieta,iphi);      
+  }
+  
+  //Apply calibration to get ADC counts and partial decalibration as especified in OCDB
+  energy = (energy + fADCpedestalEC)/fADCchannelEC/fADCchannelECDecal   ;
+  time  += fTimeChannel-fTimeChannelDecal;
+  
+  if(energy > fNADCEC ) 
+    energy =  fNADCEC ; 
+}
 
-    if(channel > fNADCEC ) 
-      channel =  fNADCEC ; 
-  }// geometry exists
+//_____________________________________________________________________
+void AliEMCALDigitizer::CalibrateADCTime(Float_t & adc, Float_t & time, const Int_t absId)
+{ 
+  // Returns the energy in a cell absId with a given adc value
+  // using the calibration constants stored in the OCDB. Time also corrected from parameter in OCDB
+  // Used in case of embedding, transform ADC counts from real event into energy
+  // so that we can add the energy of the simulated sdigits which are in energy
+  // units.
+  // Same as in AliEMCALClusterizer::Calibrate() but here we do not reject channels being marked as hot
+  // or with time out of window
+  
+  // Load Geometry
+  const AliEMCALGeometry * geom = AliEMCALGeometry::GetInstance();
+  
+  if (!geom){
+    AliFatal("Did not get geometry from EMCALLoader");
+    return;
+  }
+  
+  Int_t iSupMod = -1;
+  Int_t nModule = -1;
+  Int_t nIphi   = -1;
+  Int_t nIeta   = -1;
+  Int_t iphi    = -1;
+  Int_t ieta    = -1;
+  Bool_t bCell = geom->GetCellIndex(absId, iSupMod, nModule, nIphi, nIeta) ;
+  if(!bCell)
+    Error("CalibrateADCTime","Wrong cell id number : absId %i ", absId) ;
+  geom->GetCellPhiEtaIndexInSModule(iSupMod,nModule,nIphi, nIeta,iphi,ieta);
+  
+  if(fCalibData) {
+    fADCpedestalEC = fCalibData->GetADCpedestal(iSupMod,ieta,iphi);
+    fADCchannelEC  = fCalibData->GetADCchannel (iSupMod,ieta,iphi);
+    fTimeChannel   = fCalibData->GetTimeChannel(iSupMod,ieta,iphi);
+  }
+  
+  adc   = adc * fADCchannelEC - fADCpedestalEC;
+  time -= fTimeChannel;
   
-  return channel ;
   
 }
 
+
 //____________________________________________________________________________
 void AliEMCALDigitizer::Exec(Option_t *option) 
 { 
@@ -913,6 +1017,7 @@ void AliEMCALDigitizer::InitParameters()
   fPinNoise           = simParam->GetPinNoise();//0.012; // pin noise in GeV from analysis test beam data 
   if (fPinNoise < 0.0001 ) 
     Warning("InitParameters", "No noise added\n") ; 
+  fTimeNoise          = simParam->GetTimeNoise(); // 1.28E-5 s
   fDigitThreshold     = simParam->GetDigitThreshold(); //fPinNoise * 3; // 3 * sigma
   fTimeResolutionPar0 = simParam->GetTimeResolutionPar0(); 
   fTimeResolutionPar1 = simParam->GetTimeResolutionPar1(); 
@@ -921,89 +1026,28 @@ void AliEMCALDigitizer::InitParameters()
   // These defaults are normally not used. 
   // Values are read from calibration database instead
   fADCchannelEC       = 0.0153; // Update 24 Apr 2007: 250./16/1024 - width of one ADC channel in GeV
-  fADCpedestalEC      = 0.0 ;  // GeV
+  fADCpedestalEC      = 0.0 ;   // GeV
+  fADCchannelECDecal  = 1.0;    // No decalibration by default
+  fTimeChannel        = 0.0;    // No time calibration by default
+  fTimeChannelDecal   = 0.0;    // No time decalibration by default
 
-  fNADCEC          = simParam->GetNADCEC();//(Int_t) TMath::Power(2,16) ;  // number of channels in Tower ADC - 65536
+  fNADCEC             = simParam->GetNADCEC();//(Int_t) TMath::Power(2,16) ;  // number of channels in Tower ADC - 65536
 
-  AliDebug(2,Form("Mean Photon Electron %d, Noise %f, Digit Threshold %d,Time Resolution Par0 %g Par1 %g,NADCEC %d",
-               fMeanPhotonElectron,fPinNoise,fDigitThreshold,fTimeResolutionPar0,fTimeResolutionPar1,fNADCEC));
+  AliDebug(2,Form("Mean Photon Electron %d, Noise: APD %f, Time %f; Digit Threshold %d,Time Resolution Par0 %g Par1 %g,NADCEC %d",
+               fMeanPhotonElectron,fPinNoise,fTimeNoise, fDigitThreshold,fTimeResolutionPar0,fTimeResolutionPar1,fNADCEC));
 
-  // Not used anymore, remove?
-  // fTimeSignalLength   = 1.0e-9 ;
-  // fTimeThreshold      = 0.001*10000000 ; // Means 1 MeV in terms of SDigits amplitude ??
 
 }
 
 //__________________________________________________________________
-void AliEMCALDigitizer::MixWith(TString alirunFileName, TString eventFolderName)
-{
-  // Allows 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() ;
-  
-  if(fManager){
-    Error("MixWith", "Cannot use this method under AliRunDigitizer") ;
-    return ;
-  } 
-  // looking for file which contains AliRun
-  if (gSystem->AccessPathName(alirunFileName)) {// file does not exist
-    Error("MixWith", "File %s does not exist!", alirunFileName.Data()) ;
-    return ; 
-  }
-  // looking for the file which contains SDigits
-  AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
-  
-  if(!emcalLoader){
-    AliFatal("Did not get the  Loader");
-  }
-  else{
-    TString fileName( emcalLoader->GetSDigitsFileName() ) ; 
-    if ( eventFolderName != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name 
-      fileName = fileName.ReplaceAll(".root", "") + "_" + eventFolderName + ".root" ;
-    if ( (gSystem->AccessPathName(fileName)) ) { 
-      Error("MixWith", "The file %s does not exist!", fileName.Data()) ;
-      return ;
-    }
-    // need to increase the arrays
-    // MvL: This code only works when fInput == 1, I think.
-    TString tempo = fInputFileNames[fInput-1] ; 
-    delete [] fInputFileNames ; 
-    fInputFileNames = new TString[fInput+1] ; 
-    fInputFileNames[fInput-1] = tempo ; 
-    
-    tempo = fEventNames[fInput-1] ; 
-    delete [] fEventNames ; 
-    fEventNames = new TString[fInput+1] ; 
-    fEventNames[fInput-1] = tempo ; 
-    
-    fInputFileNames[fInput] = alirunFileName ; 
-    fEventNames[fInput]     = eventFolderName ;
-    fInput++ ;
-    
-  }// Loader exits
-  
-}  
-
-//__________________________________________________________________
 void AliEMCALDigitizer::Print1(Option_t * option)
-{ // 19-nov-04 - just for convinience
+{ // 19-nov-04 - just for convenience
   Print(); 
   PrintDigits(option);
 }
 
 //__________________________________________________________________
-void AliEMCALDigitizer::Print(Option_t*)const 
+void AliEMCALDigitizer::Print (Option_t * ) const
 {
   // Print Digitizer's parameters
   printf("Print: \n------------------- %s -------------", GetName() ) ; 
@@ -1039,8 +1083,7 @@ void AliEMCALDigitizer::Print(Option_t*)const
     else printf("\nNULL LOADER");
 
     printf("\nWith following parameters:\n") ;
-    
-    printf("    Electronics noise in EMC (fPinNoise) = %f\n", fPinNoise) ;
+    printf("    Electronics noise in EMC, APD (fPinNoise) = %f, Time = %f \n", fPinNoise, fTimeNoise) ;
     printf("    Threshold  in Tower  (fDigitThreshold) = %d\n", fDigitThreshold)  ;
     printf("---------------------------------------------------\n")  ;
   }
@@ -1088,8 +1131,8 @@ void AliEMCALDigitizer::PrintDigits(Option_t * option)
 Float_t AliEMCALDigitizer::TimeOfNoise(void)
 {  
   // Calculates the time signal generated by noise
-  //PH  Info("TimeOfNoise", "Change me") ; 
-  return gRandom->Rndm() * 1.28E-5;
+  //printf("Time noise %e\n",fTimeNoise);
+  return gRandom->Rndm() * fTimeNoise;
 }
 
 //__________________________________________________________________
@@ -1183,8 +1226,3 @@ void AliEMCALDigitizer::WriteDigits(TClonesArray* digits, const char* branchName
   else AliFatal("Loader not available");
 }
 
-//__________________________________________________________________
-void AliEMCALDigitizer::Browse(TBrowser* b)
-{
-  TTask::Browse(b);
-}
index a5dbfb8..53492c4 100644 (file)
@@ -40,79 +40,86 @@ class AliRunDigitizer ;
 class AliEMCALDigitizer: public AliDigitizer {
 
 public:
-  AliEMCALDigitizer() ;          // ctor
-  AliEMCALDigitizer(TString alirunFileNameFile, TString eventFolderName = AliConfig::GetDefaultEventFolderName()) ;  
+  AliEMCALDigitizer() ;            // ctor
+  AliEMCALDigitizer(TString alirunFileNameFile, 
+                    TString eventFolderName = AliConfig::GetDefaultEventFolderName()) ;  
   AliEMCALDigitizer(const AliEMCALDigitizer & dtizer) ;
   AliEMCALDigitizer(AliRunDigitizer * manager) ;
   virtual ~AliEMCALDigitizer() ;       
 
-  void    Digitize(Int_t event);          // Make Digits from SDigits stored in fSDigits
-  void    Exec(Option_t *option);               // Supervising method
+  void     Digitize(Int_t event);   // Make Digits from SDigits stored in fSDigits
+  void     Exec(Option_t *option);  // Supervising method
 
-  Int_t    GetDigitThreshold() const { return fDigitThreshold;}
-  Float_t  GetPinNoise()       const { return fPinNoise;}
-  Float_t GetTimeResolution(const Float_t energy) const;
+  Int_t    GetDigitThreshold()     const { return fDigitThreshold     ; }
+  Float_t  GetPinNoise()           const { return fPinNoise           ; }
+  Float_t  GetTimeNoise()          const { return fTimeNoise          ; }  
+  Float_t  GetTimeResolution(const Float_t energy) const;
   Double_t GetTimeResolutionPar0() const { return fTimeResolutionPar0 ; }
   Double_t GetTimeResolutionPar1() const { return fTimeResolutionPar1 ; }
-  Double_t GetTimeDelay()      const { return fTimeDelay ; }
-  Float_t  GetECAchannel()     const { return fADCchannelEC ; }
-  Float_t  GetECApedestal()    const { return fADCpedestalEC ; }
-  void     SetEventRange(Int_t first=0, Int_t last=-1) {fFirstEvent=first; fLastEvent=last; }
-  void     SetDigitThreshold(Int_t EMCThreshold)  {fDigitThreshold = EMCThreshold;}
-  void     SetPinNoise(Float_t PinNoise )         {fPinNoise = PinNoise;}
+  Double_t GetTimeDelay()          const { return fTimeDelay          ; }
+  Float_t  GetECAchannel()         const { return fADCchannelEC       ; }
+  Float_t  GetECApedestal()        const { return fADCpedestalEC      ; }
+  
+  void     SetEventRange(Int_t first=0, Int_t last=-1) { fFirstEvent     = first ; 
+                                                         fLastEvent      = last             ; }
+  void     SetDigitThreshold(Int_t EMCThreshold)       { fDigitThreshold = EMCThreshold     ; }
+  void     SetPinNoise(Float_t pinNoise )              { fPinNoise       = pinNoise         ; }
+  void     SetTimeNoise(Float_t timeNoise )            { fTimeNoise      = timeNoise        ; }
 
   //General
-  Int_t GetDigitsInRun()  const { return fDigitsInRun; } 
-  void  MixWith(TString alirunFileName, 
-               TString eventFolderName = AliConfig::GetDefaultEventFolderName()) ; // Add another one file to mix
-  void  Print(Option_t* option="") const ;
-  void  Print1(Option_t * option); // *MENU*
+  Int_t    GetDigitsInRun()  const { return fDigitsInRun; } 
+  void     Print (Option_t * option = "") const ;
+  void     Print1(Option_t * option)            ; // *MENU*
+                   
+
   AliEMCALDigitizer & operator = (const AliEMCALDigitizer & /*rvalue*/)  {
     // assignement operator requested by coding convention but not needed
    Fatal("operator =", "not implemented") ;  
    return *this ; 
   }
 
-  virtual void Browse(TBrowser* b);
-
 private:
 
-  Bool_t  Init();                   
-  void    InitParameters() ; 
-  void    PrintDigits(Option_t * option) ;
-  void    Unload() ; 
-  void    WriteDigits() ;         // Writes Digits the current event
-  void    WriteDigits(TClonesArray* digits, const char* branchName = "EMTRG"); //
-  Float_t TimeOfNoise(void) ;     // Calculate time signal generated by noise
+  Bool_t   Init();                   
+  void     InitParameters() ; 
+  void     PrintDigits(Option_t * option) ;
+  void     Unload() ; 
+  void     WriteDigits() ;         // Writes Digits the current event
+  void     WriteDigits(TClonesArray* digits, const char* branchName = "EMTRG"); //
+  Float_t  TimeOfNoise(void) ;     // Calculate time signal generated by noise
 
   //Calculate the time of crossing of the threshold by front edge
   //Float_t FrontEdgeTime(TClonesArray * ticks) ;
-       
-  Float_t DigitizeEnergy(Float_t energy, Int_t AbsId) ;
-  void    Digits2FastOR(TClonesArray*digitsTMP, TClonesArray* digitsTRG);
-  void    DigitalFastOR(Double_t time, Double_t dE, Int_t timeSamples[], Int_t nSamples);
-       
+  
+  void     CalibrateADCTime  (Float_t & adc ,   Float_t & time, const Int_t AbsId) ;
+  void     DigitizeEnergyTime(Float_t & energy, Float_t & time, const Int_t AbsId) ;
+
+  void     Digits2FastOR(TClonesArray*digitsTMP, TClonesArray* digitsTRG);
+  void     DigitalFastOR(Double_t time, Double_t dE, Int_t timeSamples[], Int_t nSamples);     
        
 private:
   
-  Bool_t  fDefaultInit;           //! Says if the task was created by defaut ctor (only parameters are initialized)
-  Int_t   fDigitsInRun ;          //! Total number of digits in one run
-  Bool_t  fInit ;                 //! To avoid overwriting existing files
+  Bool_t   fDefaultInit;         //! Says if the task was created by defaut ctor (only parameters are initialized)
+  Int_t    fDigitsInRun ;        //! Total number of digits in one run
+  Bool_t   fInit ;               //! To avoid overwriting existing files
 
-  Int_t   fInput ;                // Number of files to merge
-  TString * fInputFileNames ;     //[fInput] List of file names to merge 
-  TString * fEventNames ;         //[fInput] List of event names to merge
+  Int_t    fInput ;              // Number of files to merge
+  TString *fInputFileNames ;     //[fInput] List of file names to merge 
+  TString *fEventNames ;         //[fInput] List of event names to merge
 
   Int_t    fDigitThreshold  ;     // Threshold for storing digits in EMC, ACD units
   Int_t    fMeanPhotonElectron ;  // number of photon electrons per GeV deposited energy 
-  Float_t  fPinNoise ;            // Electronics noise in EMC
+  Float_t  fPinNoise ;            // Electronics noise in EMC, APD
+  Double_t fTimeNoise;            // Electronics noise in EMC, time
   Double_t fTimeDelay;            // Time delay to reproduce data delay
   Double_t fTimeResolutionPar0 ;  // Time resolution of FEE electronics
   Double_t fTimeResolutionPar1 ;  // Time resolution of FEE electronics
-  Float_t fADCchannelEC ;         // width of one ADC channel in EC section (GeV)
-  Float_t fADCpedestalEC ;        // pedestal for one ADC channel
-  Int_t   fNADCEC ;               // number of channels in EC section ADC
+  Float_t  fADCchannelEC ;        // calibration width of one ADC channel in EC section (GeV)
+  Float_t  fADCpedestalEC ;       // calibration pedestal for one ADC channel
+  Float_t  fADCchannelECDecal ;   // decalibration width of one ADC channel in EC section (GeV)
+  Float_t  fTimeChannel ;         // calibration time width for one channel  
+  Float_t  fTimeChannelDecal ;    // calibration time width for one channel  
+  Int_t    fNADCEC ;              // number of channels in EC section ADC
 
   TString  fEventFolderName;      // skowron: name of EFN to read data from in stand alone mode
   Int_t    fFirstEvent;           // first event to process
@@ -120,7 +127,7 @@ private:
        
   AliEMCALCalibData * fCalibData; //Calibration data pointer
 
-  ClassDef(AliEMCALDigitizer,10)  // description 
+  ClassDef(AliEMCALDigitizer,11)  // description 
 };
 
 
index 9c32e91..c44c075 100644 (file)
@@ -54,8 +54,9 @@ const TString         AliEMCALLoader::fgkECADigitsBranchName("DIGITS");//Name fo
 const TString         AliEMCALLoader::fgkECASDigitsBranchName("SDIGITS");//Name for branch with ECA SDigits
 
 AliEMCALCalibData*    AliEMCALLoader::fgCalibData = 0; //calibration data
-//AliCaloCalibPedestal* AliEMCALLoader::fgCaloPed   = 0; //dead map data
+AliCaloCalibPedestal* AliEMCALLoader::fgCaloPed   = 0; //dead map data
 AliEMCALSimParam*     AliEMCALLoader::fgSimParam  = 0; //simulation parameters
+AliEMCALRecParam*     AliEMCALLoader::fgRecParam  = 0; //reconstruction parameters
 
 //____________________________________________________________________________ 
 AliEMCALLoader::AliEMCALLoader()
@@ -123,24 +124,24 @@ AliEMCALCalibData* AliEMCALLoader::CalibData()
 }
 
 //____________________________________________________________________________ 
-//AliCaloCalibPedestal* AliEMCALLoader::PedestalData()
-//{ 
-//     // Check if the instance of AliCaloCalibPedestal exists, if not, create it if 
-//     // the OCDB is available, and finally return it.
-//     
-//     if(!fgCaloPed && (AliCDBManager::Instance()->IsDefaultStorageSet()))
-//    {
-//             AliCDBEntry *entry = (AliCDBEntry*) 
-//             AliCDBManager::Instance()->Get("EMCAL/Calib/Pedestals");
-//             if (entry) fgCaloPed =  (AliCaloCalibPedestal*) entry->GetObject();
-//    }
-//     
-//     if(!fgCaloPed)
-//             AliFatal("Pedestal info not found in CDB!");
-//     
-//     return fgCaloPed;
-//     
-//}
+AliCaloCalibPedestal* AliEMCALLoader::PedestalData()
+{ 
+       // Check if the instance of AliCaloCalibPedestal exists, if not, create it if 
+       // the OCDB is available, and finally return it.
+       
+       if(!fgCaloPed && (AliCDBManager::Instance()->IsDefaultStorageSet()))
+    {
+               AliCDBEntry *entry = (AliCDBEntry*) 
+               AliCDBManager::Instance()->Get("EMCAL/Calib/Pedestals");
+               if (entry) fgCaloPed =  (AliCaloCalibPedestal*) entry->GetObject();
+    }
+       
+       if(!fgCaloPed)
+               AliFatal("Pedestal info not found in CDB!");
+       
+       return fgCaloPed;
+       
+}
 
 //____________________________________________________________________________ 
 AliEMCALSimParam* AliEMCALLoader::SimulationParameters()
@@ -151,7 +152,7 @@ AliEMCALSimParam* AliEMCALLoader::SimulationParameters()
   if(!fgSimParam && (AliCDBManager::Instance()->IsDefaultStorageSet()))
     {
       AliCDBEntry *entry = (AliCDBEntry*) 
-       AliCDBManager::Instance()->Get("EMCAL/Calib/SimParam");
+      AliCDBManager::Instance()->Get("EMCAL/Calib/SimParam");
       if (entry) fgSimParam =  (AliEMCALSimParam*) entry->GetObject();
       
     }
@@ -163,13 +164,37 @@ AliEMCALSimParam* AliEMCALLoader::SimulationParameters()
   
 }
 
+
+//____________________________________________________________________________ 
+AliEMCALRecParam* AliEMCALLoader::ReconstructionParameters(Int_t eventType = 0)
+{ 
+  // Check if the instance of AliEMCALRecParam exists, if not, create it if 
+  // the OCDB is available, and finally return it. 
+  // The event type must be provided.
+  
+  if(!fgRecParam && (AliCDBManager::Instance()->IsDefaultStorageSet()))
+  {
+    AliCDBEntry *entry = (AliCDBEntry*) 
+    AliCDBManager::Instance()->Get("EMCAL/Calib/RecoParam");
+    if (entry) fgRecParam =  (AliEMCALRecParam*)((TObjArray *) entry->GetObject())->At(eventType);
+    
+  }
+  
+  if(!fgRecParam)
+    AliFatal("Reconstruction parameters not found in CDB!");
+  
+  return fgRecParam;
+  
+}
+
+
 //____________________________________________________________________________ 
 Int_t AliEMCALLoader::GetEvent() 
 {
   //Method to load all of the data
   //members of the EMCAL for a given
   //event from the Trees
-  
+
   AliLoader::GetEvent();  // First call AliLoader to do all the groundwork
   
   // *** Hits ***
index 3a9d2ec..2c98a04 100644 (file)
@@ -28,8 +28,9 @@ class TTask ;
 // --- AliRoot header files ---
 #include "AliLoader.h"
 #include "AliEMCALCalibData.h"
-//#include "AliCaloCalibPedestal.h"
+#include "AliCaloCalibPedestal.h"
 #include "AliEMCALSimParam.h"
+#include "AliEMCALRecParam.h"
 
 class AliLoader ;
 class AliEMCAL ; 
@@ -85,15 +86,17 @@ class AliEMCALLoader : public AliLoader {
   //OCDB access methods
   
   void  SetCalibData(AliEMCALCalibData* calibda)  { fgCalibData = calibda; }
-  AliEMCALCalibData * CalibData(); // to get the calibration CDB object
+  AliEMCALCalibData * CalibData();              // to get the calibration CDB object
   
-  //  void  SetPedestalData(AliCaloCalibPedestal* caloped)  { fgCaloPed = caloped; }
-  //  AliCaloCalibPedestal* PedestalData(); // to get the pedestal CDB object
+  void  SetPedestalData(AliCaloCalibPedestal* caloped)  { fgCaloPed = caloped; }
+  AliCaloCalibPedestal* PedestalData();         // to get the pedestal CDB object
   
   void  SetSimParam(AliEMCALSimParam* simparam)  { fgSimParam = simparam; }
-  AliEMCALSimParam* SimulationParameters(); // to get the simulation parameter CDB object
-  
+  AliEMCALSimParam* SimulationParameters();     // to get the simulation parameter CDB object
   
+  void  SetRecParam(AliEMCALRecParam* recparam)  { fgRecParam = recparam; }
+  AliEMCALRecParam* ReconstructionParameters(Int_t eventType); // to get the reconstruction parameter CDB object
+
  private:
   
   // assignement operator requested by coding convention, but not needed
@@ -107,9 +110,10 @@ class AliEMCALLoader : public AliLoader {
   Int_t  fDebug ;             // Debug level
        
   static AliEMCALCalibData    * fgCalibData;  //  calibration data 
-  //  static AliCaloCalibPedestal * fgCaloPed;    //  dead map
+  static AliCaloCalibPedestal * fgCaloPed;    //  dead map
   static AliEMCALSimParam     * fgSimParam;   //  sim param 
-  
+  static AliEMCALRecParam     * fgRecParam;   //  rec param 
+
   ClassDef(AliEMCALLoader,7)  // Algorithm class that provides methods to retrieve objects from a list knowing the index 
     
 };
index 7698203..35019e9 100644 (file)
@@ -61,6 +61,7 @@ set ( SRCS
     AliEMCALTriggerDCSConfigDB.cxx 
     AliEMCALTriggerRawDigitMaker.cxx 
     AliEMCALTriggerRawDigit.cxx 
+    AliEMCALTriggerData.cxx
     )
 
 string (REPLACE ".cxx" ".h" HDRS "${SRCS}")
index feb0625..d049749 100644 (file)
@@ -35,8 +35,7 @@ set ( SRCS
     AliEMCALTriggerBoard.cxx 
     AliEMCALTriggerPatch.cxx 
     AliEMCALTriggerSTU.cxx 
-    AliEMCALTriggerTRU.cxx 
-    AliEMCALTriggerData.cxx 
+    AliEMCALTriggerTRU.cxx  
     AliEMCALTriggerElectronics.cxx 
     )
 
index b84b858..11d0a02 100644 (file)
@@ -46,6 +46,7 @@
 #pragma link C++ class AliEMCALTriggerDCSConfigDB+;
 #pragma link C++ class AliEMCALTriggerRawDigitMaker+;
 #pragma link C++ class AliEMCALTriggerRawDigit+;
+#pragma link C++ class AliEMCALTriggerData+;
 
 #endif
 
index 54e0669..f3144ab 100644 (file)
@@ -13,7 +13,6 @@
 #pragma link C++ class AliEMCALTriggerPatch+;
 #pragma link C++ class AliEMCALTriggerSTU+;
 #pragma link C++ class AliEMCALTriggerTRU+;
-#pragma link C++ class AliEMCALTriggerData+;
 #pragma link C++ class AliEMCALTriggerElectronics+;
 
 #endif
diff --git a/EMCAL/macros/embedding/raw2sdigits.C b/EMCAL/macros/embedding/raw2sdigits.C
new file mode 100644 (file)
index 0000000..2d35e3c
--- /dev/null
@@ -0,0 +1,22 @@
+
+// Transform raw data into digits
+// Input: run number, raw data file and ESD file from this data
+
+// After executing this, generate simulation and merge with it using
+// the macro simmerge.C
+
+// Full exercise can be done automatically with other alice systems
+// in the examples in $ALICE_ROOT/test/embedding
+
+// Author: GCB (from example in $ALICE_ROOT/test/embedding)
+
+void raw2sdigits(Int_t runNumber) 
+{
+  AliSimulation sim;
+  AliCDBManager *cdbm = AliCDBManager::Instance();
+  cdbm->SetRun(runNumber);
+  cdbm->SetDefaultStorage("local://$ALICE_ROOT/OCDB");     
+  cdbm->SetSpecificStorage("GRP/GRP/Data",Form("local://%s",gSystem->pwd()));
+  sim.SetMakeSDigits("EMCAL");  
+  sim.ConvertRaw2SDigits("raw/raw.root","raw/AliESDs.root");
+}
diff --git a/EMCAL/macros/embedding/simmerge.C b/EMCAL/macros/embedding/simmerge.C
new file mode 100644 (file)
index 0000000..037da52
--- /dev/null
@@ -0,0 +1,30 @@
+// Simulate events and merge with other events (simulated or real)
+// at the level of sdigits.
+// Input: sdigits of background file
+
+// Full exercise can be done automatically with other alice systems
+// in the examples in $ALICE_ROOT/test/merge
+
+// Author: GCB (from example in $ALICE_ROOT/test/merge)
+
+void simmerge() 
+{
+  
+  AliSimulation sim;
+  sim.SetRunSimulation(kTRUE);
+  sim.SetMakeSDigits("EMCAL");
+  sim.SetMakeDigits("EMCAL");
+  sim.MergeWith("bkg/galice.root",1);
+
+  sim.SetDefaultStorage("local://$ALICE_ROOT/OCDB");
+  sim.SetSpecificStorage("GRP/GRP/Data",
+                              Form("local://%s",gSystem->pwd()));
+  sim.SetRunQA(":") ; 
+  AliQA::SetQARefStorage("local://$ALICE_ROOT/OCDB") ;
+  
+  for (Int_t det = 0 ; det < AliQA::kNDET ; det++) {
+    sim.SetQACycles(det, 1) ;
+  }
+
+  sim.Run(10);
+}