ALTRO samples are added to AliPHOSDigit for per-sample event merging.
authorkharlov <kharlov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 31 Jan 2010 20:19:37 +0000 (20:19 +0000)
committerkharlov <kharlov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 31 Jan 2010 20:19:37 +0000 (20:19 +0000)
PHOS/AliPHOSDigit.cxx
PHOS/AliPHOSDigit.h
PHOS/AliPHOSDigitizer.cxx
PHOS/AliPHOSDigitizer.h
PHOS/AliPHOSPulseGenerator.cxx
PHOS/AliPHOSRawDigiProducer.cxx
PHOS/AliPHOSRawDigiProducer.h

index 193c61e..1dc94df 100644 (file)
@@ -60,8 +60,11 @@ AliPHOSDigit::AliPHOSDigit() :
   fPrimary(0x0),
   fEnergy(0.),
   fTime(0.),
-  fTimeR(0.) 
-  
+  fTimeR(0.),
+  fNSamplesHG(0),
+  fNSamplesLG(0),
+  fSamplesHG(0),
+  fSamplesLG(0)
 {
   // default ctor 
 }
@@ -72,7 +75,11 @@ AliPHOSDigit::AliPHOSDigit(Int_t primary, Int_t id, Int_t digEnergy, Float_t tim
   fPrimary(0),
   fEnergy(0.f),
   fTime(0.f),
-  fTimeR(0.f)
+  fTimeR(0.f),
+  fNSamplesHG(0),
+  fNSamplesLG(0),
+  fSamplesHG(0),
+  fSamplesLG(0)
 {  
   // ctor with all data 
 
@@ -99,7 +106,11 @@ AliPHOSDigit::AliPHOSDigit(Int_t primary, Int_t id, Float_t energy, Float_t time
   fPrimary(0),
   fEnergy(0.f),
   fTime(0.f),
-  fTimeR(0.f)
+  fTimeR(0.f),
+  fNSamplesHG(0),
+  fNSamplesLG(0),
+  fSamplesHG(0),
+  fSamplesLG(0)
 {  
   // ctor with all data 
 
@@ -127,8 +138,11 @@ AliPHOSDigit::AliPHOSDigit(const AliPHOSDigit & digit) :
   fPrimary(0),
   fEnergy(digit.fEnergy),
   fTime(digit.fTime),
-  fTimeR(digit.fTimeR)
-
+  fTimeR(digit.fTimeR),
+  fNSamplesHG(0),
+  fNSamplesLG(0),
+  fSamplesHG(0),
+  fSamplesLG(0)
 {
   // copy ctor
   if(fNprimary){
@@ -146,9 +160,11 @@ AliPHOSDigit::AliPHOSDigit(const AliPHOSDigit & digit) :
 //____________________________________________________________________________
 AliPHOSDigit::~AliPHOSDigit() 
 {
-  // Delete array of primiries if any
-  if(fPrimary)
-    delete [] fPrimary ;
+  // Delete array of primaries if any
+  if (fPrimary)   delete [] fPrimary  ;
+  // Delete arrays of ALTRO samples if any
+  if (fSamplesHG) delete [] fSamplesHG;
+  if (fSamplesLG) delete [] fSamplesLG;
 }
 
 //____________________________________________________________________________
@@ -186,14 +202,45 @@ Int_t AliPHOSDigit::GetPrimary(Int_t index) const
   return rv ; 
   
 }
+
+//____________________________________________________________________________
+void AliPHOSDigit::SetALTROSamplesHG(Int_t nSamplesHG, Int_t *samplesHG)
+{
+  fNSamplesHG = nSamplesHG;
+  fSamplesHG = new UShort_t[fNSamplesHG];
+  UShort_t i;
+  for (i=0; i<fNSamplesHG; i++) {
+    fSamplesHG[i] = samplesHG[i];
+  }
+}
+//____________________________________________________________________________
+void AliPHOSDigit::SetALTROSamplesLG(Int_t nSamplesLG, Int_t *samplesLG)
+{
+  fNSamplesLG = nSamplesLG;
+  fSamplesLG = new UShort_t[fNSamplesLG];
+  UShort_t i;
+  for (i=0; i<fNSamplesLG; i++) {
+    fSamplesLG[i] = samplesLG[i];
+  }
+}
 //____________________________________________________________________________
 void AliPHOSDigit::Print(const Option_t *) const
 {
   // Print the digit together with list of primaries
-  printf("PHOS digit: Amp=%d/E=%.3f, Id=%d, Time=%.3e, TimeR=%.3e, NPrim=%d ",fAmp,fEnergy,fId,fTime,fTimeR,fNprimary);
-  for(Int_t index = 0; index <fNprimary; index ++ )
+  printf("PHOS digit: E=%.3f, Id=%d, Time=%.3e, TimeR=%.3e, NPrim=%d, nHG=%d, nLG=%d \n",
+        fEnergy,fId,fTime,fTimeR,fNprimary,fNSamplesHG,fNSamplesLG);
+  printf("\tList of primaries: ");
+  for (Int_t index = 0; index <fNprimary; index ++ )
     printf(" %d ",fPrimary[index]); 
   printf("\n") ;
+  printf("\tHG samples: 0x%x: ",fSamplesHG);
+  for (Int_t i = 0; i <fNSamplesHG; i++)
+    printf(" %d ",fSamplesHG[i]); 
+  printf("\n") ;
+  printf("\tLG samples: 0x%x: ",fSamplesLG);
+  for (Int_t i = 0; i <fNSamplesLG; i++)
+    printf(" %d ",fSamplesLG[i]); 
+  printf("\n") ;
 }
 //____________________________________________________________________________
 void AliPHOSDigit::ShiftPrimary(Int_t shift)
@@ -243,6 +290,52 @@ AliPHOSDigit& AliPHOSDigit::operator+=(AliPHOSDigit const & digit)
    if(fTime > digit.fTime)
       fTime = digit.fTime ;
    fTimeR = fTime ; 
+
+   // Add high-gain ALTRO samples
+   UShort_t i;
+   if (digit.fNSamplesHG > fNSamplesHG) {
+     UShort_t newNSamplesHG = digit.fNSamplesHG;
+     UShort_t *newSamplesHG = new UShort_t[newNSamplesHG];
+     for (i=0; i<newNSamplesHG; i++) {
+       if (i<fNSamplesHG)
+        newSamplesHG[i] = TMath::Max(1023,fSamplesHG[i] + (digit.fSamplesHG)[i]);
+       else
+        newSamplesHG[i] = (digit.fSamplesHG)[i];
+     }
+     delete [] fSamplesHG;
+     fSamplesHG = new UShort_t[newNSamplesHG];
+     for (i=0; i<newNSamplesHG; i++) {
+       fSamplesHG[i] = newSamplesHG[i];
+     }
+     delete [] newSamplesHG;
+   }
+   else {
+     for (i=0; i<fNSamplesHG; i++)
+       fSamplesHG[i] = TMath::Max(1023,fSamplesHG[i] + (digit.fSamplesHG)[i]);
+   }
+
+   // Add low-gain ALTRO samples
+   if (digit.fNSamplesLG > fNSamplesLG) {
+     UShort_t newNSamplesLG = digit.fNSamplesLG;
+     UShort_t *newSamplesLG = new UShort_t[newNSamplesLG];
+     for (i=0; i<newNSamplesLG; i++) {
+       if (i<fNSamplesLG)
+        newSamplesLG[i] = TMath::Max(1023,fSamplesLG[i] + (digit.fSamplesLG)[i]);
+       else
+        newSamplesLG[i] = (digit.fSamplesLG)[i];
+     }
+     delete [] fSamplesLG;
+     fSamplesLG = new UShort_t[newNSamplesLG];
+     for (i=0; i<newNSamplesLG; i++) {
+       fSamplesLG[i] = newSamplesLG[i];
+     }
+     delete [] newSamplesLG;
+   }
+   else {
+     for (i=0; i<fNSamplesLG; i++)
+       fSamplesLG[i] = TMath::Max(1023,fSamplesLG[i] + (digit.fSamplesLG)[i]);
+   }
+
    return *this ;
 }
 //____________________________________________________________________________
index dff067f..63d97a5 100644 (file)
@@ -57,29 +57,39 @@ public:
 
   AliPHOSDigit& operator=(const AliPHOSDigit) {
     Fatal("operator = ", "not implemented") ; return *this ; } 
-  Int_t   Compare(const TObject * obj) const ;  
-  Int_t   GetNprimary()           const { return fNprimary ; }
-  Int_t   GetPrimary(Int_t index) const ; 
-  Float_t GetEnergy(void)         const {return fEnergy ;}
-  Float_t GetTime(void)           const {return fTime ;}
-  Float_t GetTimeR(void)          const {return fTimeR ;}
-  Bool_t  IsSortable()            const { return kTRUE ; }
-  void    Print(const Option_t * = "") const;
-  void    SetAmp(Int_t Amp)      {fAmp   = Amp  ;} 
-  void    SetEnergy(Float_t E)   {fEnergy= E    ;} 
-  void    SetTime(Float_t time)  {fTime  = time ;}
-  void    SetTimeR(Float_t time) {fTimeR = time ;}
-  void    ShiftPrimary(Int_t shift); // shift to separate different TreeK in merging
+  Int_t     Compare(const TObject * obj) const ;  
+  Int_t     GetNprimary()           const { return fNprimary ; }
+  Int_t     GetPrimary(Int_t index) const ; 
+  Float_t   GetEnergy(void)         const {return fEnergy ;}
+  Float_t   GetTime(void)           const {return fTime ;}
+  Float_t   GetTimeR(void)          const {return fTimeR ;}
+  Int_t     GetNSamplesHG()         const {return fNSamplesHG;}
+  Int_t     GetNSamplesLG()         const {return fNSamplesLG;}
+  UShort_t *GetSamplesHG()          const {return fSamplesHG;}
+  UShort_t *GetSamplesLG()          const {return fSamplesLG;}
+  Bool_t    IsSortable()            const { return kTRUE ; }
+  void      Print(const Option_t * = "") const;
+  void      SetAmp(Int_t Amp)      {fAmp   = Amp  ;} 
+  void      SetEnergy(Float_t E)   {fEnergy= E    ;} 
+  void      SetTime(Float_t time)  {fTime  = time ;}
+  void      SetTimeR(Float_t time) {fTimeR = time ;}
+  void      SetALTROSamplesHG(Int_t nSamplesHG, Int_t *samplesHG);
+  void      SetALTROSamplesLG(Int_t nSamplesLG, Int_t *samplesLG);
+  void      ShiftPrimary(Int_t shift); // shift to separate different TreeK in merging
 
  private:
 
-  Int_t   fNprimary ;      // Number of primaries
-  Int_t * fPrimary ;       //[fNprimary] Array of primaries      
-  Float_t fEnergy ;        // Deposited energy in ADC counts
-  Float_t fTime ;          // Calculcated time 
-  Float_t fTimeR ;         // Earliest time: to be used by Digits2Raw
-    
-  ClassDef(AliPHOSDigit,5) // Digit in PHOS 
+  Int_t       fNprimary ;  // Number of primaries
+  Int_t *     fPrimary ;   //[fNprimary] Array of primaries      
+  Float_t     fEnergy ;    // Deposited energy in ADC counts
+  Float_t     fTime ;      // Calculcated time 
+  Float_t     fTimeR ;     // Earliest time: to be used by Digits2Raw
+  Int_t       fNSamplesHG; // Number of high-gain ALTRO samples
+  Int_t       fNSamplesLG; // Number of low-gain  ALTRO samples
+  UShort_t   *fSamplesHG;  //[fNSamplesHG] Array of high-gain ALTRO samples
+  UShort_t   *fSamplesLG;  //[fNSamplesLG] Array of low-gain  ALTRO samples
+
+  ClassDef(AliPHOSDigit,6) // Digit in PHOS 
 
 } ;
 
index 88dabf0..732d999 100644 (file)
 #include "AliPHOSCalibData.h"
 #include "AliRunLoader.h"
 #include "AliPHOSLoader.h"
+#include "AliPHOSPulseGenerator.h"
 
 ClassImp(AliPHOSDigitizer)
 
@@ -158,7 +159,10 @@ AliPHOSDigitizer::AliPHOSDigitizer() :
   fFirstEvent(0),
   fLastEvent(0), 
   fcdb(0x0),
-  fEventCounter(0)
+  fEventCounter(0),
+  fPulse(0),
+  fADCValuesLG(0),
+  fADCValuesHG(0)
 {
   // ctor
   InitParameters() ; 
@@ -180,13 +184,16 @@ AliPHOSDigitizer::AliPHOSDigitizer(TString alirunFileName,
   fFirstEvent(0),
   fLastEvent(0), 
   fcdb(0x0),
-  fEventCounter(0)
+  fEventCounter(0),
+  fPulse(0),
+  fADCValuesLG(0),
+  fADCValuesHG(0)
 {
   // ctor
   InitParameters() ; 
   Init() ;
   fDefaultInit = kFALSE ; 
-  fManager = 0 ;                     // We work in the standalong mode
+  fManager = 0 ;                     // We work in the standalone mode
   fcdb = new AliPHOSCalibData(-1);
 }
 
@@ -204,7 +211,10 @@ AliPHOSDigitizer::AliPHOSDigitizer(const AliPHOSDigitizer & d) :
   fFirstEvent(d.fFirstEvent),
   fLastEvent(d.fLastEvent), 
   fcdb (0x0), 
-  fEventCounter(0)
+  fEventCounter(0),
+  fPulse(0),
+  fADCValuesLG(0),
+  fADCValuesHG(0)
 {
   // copyy ctor 
   SetName(d.GetName()) ; 
@@ -226,7 +236,10 @@ AliPHOSDigitizer::AliPHOSDigitizer(AliRunDigitizer * rd) :
   fFirstEvent(0),
   fLastEvent(0), 
   fcdb (0x0), 
-  fEventCounter(0)
+  fEventCounter(0),
+  fPulse(0),
+  fADCValuesLG(0),
+  fADCValuesHG(0)
 
 {
   // ctor Init() is called by RunDigitizer
@@ -250,6 +263,10 @@ AliPHOSDigitizer::AliPHOSDigitizer(AliRunDigitizer * rd) :
   delete [] fInputFileNames ; 
   delete [] fEventNames ; 
 
+  delete fPulse;
+  delete [] fADCValuesLG;
+  delete [] fADCValuesHG;
+
   if(fcdb){ delete fcdb ; fcdb=0;} 
 
 }
@@ -269,7 +286,7 @@ void AliPHOSDigitizer::Digitize(Int_t event)
 
   //First stream 
   AliRunLoader* rl = AliRunLoader::GetRunLoader(fEventFolderName) ;
-  AliPHOSLoader * phosLoader = dynamic_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));                                                                
+  AliPHOSLoader * phosLoader = dynamic_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
 
   Int_t readEvent = event ; 
   if (fManager) 
@@ -589,10 +606,22 @@ void AliPHOSDigitizer::Digitize(Int_t event)
       continue ;
     }
 
+    geom->AbsToRelNumbering(digit->GetId(),relId);
+
     digit->SetEnergy(TMath::Ceil(digit->GetEnergy())-0.9999) ;
 
     Float_t tres = TimeResolution(digit->GetEnergy()) ; 
     digit->SetTime(gRandom->Gaus(digit->GetTime(), tres) ) ;
+
+    fPulse->Reset();
+    fPulse->SetAmplitude(digit->GetEnergy()/
+                        fcdb->GetADCchannelEmc(relId[0],relId[3],relId[2]));
+    fPulse->SetTZero(digit->GetTimeR());
+    fPulse->MakeSamples();
+    fPulse->GetSamples(fADCValuesHG, fADCValuesLG) ; 
+    Int_t nSamples = fPulse->GetRawFormatTimeBins();
+    digit->SetALTROSamplesHG(nSamples,fADCValuesHG);
+    digit->SetALTROSamplesLG(nSamples,fADCValuesLG);
   }
 
   Float_t cpvDigitThreshold = AliPHOSSimParam::GetInstance()->GetCpvDigitsThreshold() ;
@@ -838,6 +867,9 @@ void AliPHOSDigitizer::InitParameters()
 
   fDigitsInRun  = 0 ; 
   SetEventRange(0,-1) ;
+  fPulse = new AliPHOSPulseGenerator();
+  fADCValuesLG = new Int_t[fPulse->GetRawFormatTimeBins()];
+  fADCValuesHG = new Int_t[fPulse->GetRawFormatTimeBins()];
     
 }
 
index 77d27d5..58e92b1 100644 (file)
@@ -44,6 +44,7 @@ class TClonesArray ;
 // --- AliRoot header files ---
 #include "AliDigitizer.h"
 #include "AliConfig.h"
+#include "AliPHOSPulseGenerator.h"
 class AliRunDigitizer ;
 class AliPHOSCalibData ; 
 
@@ -110,8 +111,12 @@ private:
   AliPHOSCalibData* fcdb;           //! Calibration parameters DB
 
   Int_t fEventCounter ;             //! counts the events processed
+
+  AliPHOSPulseGenerator *fPulse;    //! Pulse shape generator
+  Int_t *fADCValuesLG;              //! Array og low-gain ALTRO samples
+  Int_t *fADCValuesHG;              //! Array og high-gain ALTRO samples
   
-  ClassDef(AliPHOSDigitizer,4)  // description 
+  ClassDef(AliPHOSDigitizer,5)  // description 
 
 };
 
index 4fdb076..8be79d0 100644 (file)
@@ -171,8 +171,8 @@ void AliPHOSPulseGenerator::Digitize()
 {
   // Emulates ADC: rounds up to nearest integer value all amplitudes
   for (Int_t i=0; i<fkTimeBins; i++) {
-    fDataHG[i] = TMath::Ceil(fDataHG[i]);
-    fDataLG[i] = TMath::Ceil(fDataLG[i]);
+    fDataHG[i] = (Int_t)(fDataHG[i]);
+    fDataLG[i] = (Int_t)(fDataLG[i]);
   }
 }
 
index ae906a6..d21da2c 100644 (file)
@@ -57,7 +57,9 @@ AliPHOSRawDigiProducer::AliPHOSRawDigiProducer():
   fGeom(0),
   fPulseGenerator(0),
   fRawReader(0),
-  fRawStream(0)
+  fRawStream(0),
+  fADCValuesLG(0),
+  fADCValuesHG(0)
 {
   // Default constructor
 
@@ -81,7 +83,9 @@ AliPHOSRawDigiProducer::AliPHOSRawDigiProducer(AliRawReader *rawReader,
   fGeom(0),
   fPulseGenerator(0),
   fRawReader(rawReader),
-  fRawStream(0)
+  fRawStream(0),
+  fADCValuesLG(0),
+  fADCValuesHG(0)
 {
   // Default constructor
 
@@ -106,7 +110,10 @@ AliPHOSRawDigiProducer::AliPHOSRawDigiProducer(const AliPHOSRawDigiProducer &dp)
   fGeom(0),
   fPulseGenerator(0),
   fRawReader(0),
-  fRawStream(0)
+  fRawStream(0),
+  fADCValuesLG(0),
+  fADCValuesHG(0)
+
 {                                                          
   // Copy constructor
 
@@ -142,6 +149,8 @@ AliPHOSRawDigiProducer::~AliPHOSRawDigiProducer()
   if(fPulseGenerator) delete fPulseGenerator ;
   fPulseGenerator=0 ;
   delete fRawStream;
+  delete [] fADCValuesLG;
+  delete [] fADCValuesHG;
 }
 //--------------------------------------------------------------------------------------
 void AliPHOSRawDigiProducer::MakeDigits(TClonesArray *digits, AliPHOSRawFitterv0* fitter) 
@@ -198,11 +207,25 @@ void AliPHOSRawDigiProducer::MakeDigits(TClonesArray *digits, AliPHOSRawFitterv0
       fGeom->RelToAbsNumbering(relId, absId);
       
       fitter->SetNBunches(0);
+      Int_t sigStart  ;
+      Int_t sigLength ;
       while (fRawStream->NextBunch()) { //Take first in time banch
        const UShort_t *sig = fRawStream->GetSignals();
-       Int_t sigStart  = fRawStream->GetStartTimeBin();
-       Int_t sigLength = fRawStream->GetBunchLength();
+       sigStart  = fRawStream->GetStartTimeBin();
+       sigLength = fRawStream->GetBunchLength();
        fitter->Eval(sig,sigStart,sigLength);
+       if      (caloFlag == AliCaloRawStreamV3::kLowGain) {
+         delete [] fADCValuesLG;
+         fADCValuesLG = new Int_t[sigLength];
+         for (Int_t i=0; i<sigLength; i++)
+           fADCValuesLG[sigLength-i-1] = sig[i];
+       }
+       else if (caloFlag == AliCaloRawStreamV3::kHighGain) {
+         delete [] fADCValuesHG;
+         fADCValuesHG = new Int_t[sigLength];
+         for (Int_t i=0; i<sigLength; i++)
+           fADCValuesHG[sigLength-i-1] = sig[i];
+       }
       } // End of NextBunch()
 
       
@@ -231,6 +254,7 @@ void AliPHOSRawDigiProducer::MakeDigits(TClonesArray *digits, AliPHOSRawFitterv0
       
       if (caloFlag == AliCaloRawStreamV3::kLowGain) {
        new(tmpLG[ilgDigit]) AliPHOSDigit(-1,absId,(Float_t)energy,(Float_t)time);
+       dynamic_cast<AliPHOSDigit*>(tmpLG.At(ilgDigit))->SetALTROSamplesHG(sigLength,fADCValuesLG);
        ilgDigit++ ; 
       }
       else if (caloFlag == AliCaloRawStreamV3::kHighGain) {
@@ -239,6 +263,7 @@ void AliPHOSRawDigiProducer::MakeDigits(TClonesArray *digits, AliPHOSRawFitterv0
          new((*digits)[iDigit]) AliPHOSDigit(-1,absId,-1.f,(Float_t)time);
        else
          new((*digits)[iDigit]) AliPHOSDigit(-1,absId,(Float_t)energy,(Float_t)time);
+       dynamic_cast<AliPHOSDigit*>(digits->At(iDigit))->SetALTROSamplesHG(sigLength,fADCValuesLG);
        iDigit++;
       }
     } // End of NextChannel()
index 06dc6c3..d65070e 100644 (file)
@@ -58,8 +58,10 @@ private:
   AliPHOSPulseGenerator   * fPulseGenerator ; //! Class with pulse shape parameters
   AliRawReader            * fRawReader;       //! Raw data reader
   AliCaloRawStreamV3      * fRawStream;       //! Calorimeter decoder of ALTRO format
+  Int_t *fADCValuesLG;               //! Array og low-gain ALTRO samples
+  Int_t *fADCValuesHG;               //! Array og high-gain ALTRO samples
 
-  ClassDef(AliPHOSRawDigiProducer,6)
+  ClassDef(AliPHOSRawDigiProducer,7)
 };
 
 #endif