Run type changed: PHYSICS only

[u/mrichter/AliRoot.git] / PHOS / AliPHOSRawDigiProducer.cxx

diff --git a/PHOS/AliPHOSRawDigiProducer.cxx b/PHOS/AliPHOSRawDigiProducer.cxx
index 89242afe7697a3f80f510afdbd79081231dd45ba..89116f07784a2674bc4cca1085585a59b712ee8d 100644 (file)
--- a/PHOS/AliPHOSRawDigiProducer.cxx
+++ b/PHOS/AliPHOSRawDigiProducer.cxx
@@ -39,6 +39,7 @@
 #include "AliPHOSDigit.h"
 #include "AliPHOSRecoParam.h"
 #include "AliPHOSCalibData.h"
+#include "AliPHOSPulseGenerator.h"
 #include "AliLog.h"
 
 ClassImp(AliPHOSRawDigiProducer)
@@ -47,12 +48,13 @@ AliPHOSCalibData * AliPHOSRawDigiProducer::fgCalibData  = 0 ;
 
 //--------------------------------------------------------------------------------------
 AliPHOSRawDigiProducer::AliPHOSRawDigiProducer():TObject(),
-  fEmcMinE(0.),fCpvMinE(0.),fEmcCrystals(0),fGeom(0){
+  fEmcMinE(0.),fCpvMinE(0.),fSampleQualityCut(1.),
+  fEmcCrystals(0),fGeom(0),fPulseGenerator(0){
 
 }
 //--------------------------------------------------------------------------------------
 AliPHOSRawDigiProducer::AliPHOSRawDigiProducer(const AliPHOSRecoParam* parEmc, const AliPHOSRecoParam* parCpv):TObject(),
-  fEmcMinE(0.),fCpvMinE(0.),fEmcCrystals(0),fGeom(0){
+  fEmcMinE(0.),fCpvMinE(0.),fSampleQualityCut(1.),fEmcCrystals(0),fGeom(0),fPulseGenerator(0){
 
   if(!parEmc) AliFatal("Reconstruction parameters for EMC not set!");
   if(!parCpv) AliFatal("Reconstruction parameters for CPV not set!");
@@ -60,20 +62,25 @@ AliPHOSRawDigiProducer::AliPHOSRawDigiProducer(const AliPHOSRecoParam* parEmc, c
   fEmcMinE = parEmc->GetMinE();
   fCpvMinE = parCpv->GetMinE();
 
+  fSampleQualityCut = parEmc->GetSampleQualityCut() ;
+
   fGeom=AliPHOSGeometry::GetInstance() ;
   if(!fGeom) fGeom = AliPHOSGeometry::GetInstance("IHEP");
 
   fEmcCrystals=fGeom->GetNCristalsInModule()*fGeom->GetNModules() ;
 
+  fPulseGenerator = new AliPHOSPulseGenerator();
+
   GetCalibrationParameters() ; 
 }
 //--------------------------------------------------------------------------------------                       
 AliPHOSRawDigiProducer::AliPHOSRawDigiProducer(const AliPHOSRawDigiProducer &dp):TObject(),
-  fEmcMinE(0.),fCpvMinE(0.),fEmcCrystals(0),fGeom(0){                                                          
+  fEmcMinE(0.),fCpvMinE(0.),fSampleQualityCut(1.),fEmcCrystals(0),fGeom(0),fPulseGenerator(0){                                                          
 
   fEmcMinE = dp.fEmcMinE ;
   fCpvMinE = dp.fCpvMinE ;
   fEmcCrystals = dp.fEmcCrystals ;
+  fPulseGenerator = new AliPHOSPulseGenerator();
   fGeom = dp.fGeom ;
 }
 //--------------------------------------------------------------------------------------
@@ -82,11 +89,18 @@ AliPHOSRawDigiProducer& AliPHOSRawDigiProducer::operator= (const AliPHOSRawDigiP
 
   fEmcMinE = dp.fEmcMinE ;
   fCpvMinE = dp.fCpvMinE ;
+  fSampleQualityCut = dp.fSampleQualityCut ;
   fEmcCrystals = dp.fEmcCrystals ;
   fGeom = dp.fGeom ;
+  if(fPulseGenerator) delete fPulseGenerator ;
+  fPulseGenerator = new AliPHOSPulseGenerator();
   return  *this;
 } 
- 
+//--------------------------------------------------------------------------------------                                                   
+AliPHOSRawDigiProducer::~AliPHOSRawDigiProducer(){
+ if(fPulseGenerator) delete fPulseGenerator ;
+ fPulseGenerator=0 ;
+}
 //--------------------------------------------------------------------------------------
 void AliPHOSRawDigiProducer::MakeDigits(TClonesArray *digits, AliPHOSRawDecoder* decoder) 
 {
@@ -99,7 +113,7 @@ void AliPHOSRawDigiProducer::MakeDigits(TClonesArray *digits, AliPHOSRawDecoder*
   Int_t relId[4], absId =0;
 
   const Double_t baseLine=1. ; //Minimal energy of digit in ADC ch. 
-  const Double_t highLowDiff=2. ; //Maximal difference between High and Low channels in LG adc channels 
+  const Double_t highLowDiff=2.; //Maximal difference between High and Low channels in LG adc channels 
 
   //Temporary array for LowGain digits
   TClonesArray tmpLG("AliPHOSDigit",10000) ;
@@ -111,6 +125,14 @@ void AliPHOSRawDigiProducer::MakeDigits(TClonesArray *digits, AliPHOSRawDecoder*
     if(energy<=baseLine) //in ADC channels
       continue ;
 
+    //remove digits with bas shape. Decoder should calculate quality so that 
+    //in default case quality [0,1], while larger values of quality mean somehow 
+    //corrupted samples, 999 means obviously corrupted sample.
+    //It is difficult to fit samples with overflow (even setting cut on overflow values)
+    //because too few points are left to fit. So we do not evaluate samples with overflow
+    if(decoder->GetSampleQuality() > fSampleQualityCut && !(decoder->IsOverflow()))
+       continue ;
+
     Bool_t lowGainFlag = decoder->IsLowGain();
 
     relId[0] = decoder->GetModule();
@@ -148,34 +170,36 @@ void AliPHOSRawDigiProducer::MakeDigits(TClonesArray *digits, AliPHOSRawDecoder*
   tmpLG.Sort() ;
   Int_t iLG = 0;
   Int_t nLG1 = tmpLG.GetEntriesFast()-1 ;
+
   for(Int_t iDig=0 ; iDig < digits->GetEntriesFast() ; iDig++) { 
     AliPHOSDigit * digHG = dynamic_cast<AliPHOSDigit*>(digits->At(iDig)) ;
     if (!digHG) continue;
     AliPHOSDigit * digLG = dynamic_cast<AliPHOSDigit*>(tmpLG.At(iLG)) ;
-    while(iLG<nLG1 && digHG->GetId()> digLG->GetId()){
+    while(digLG && iLG<nLG1 && digHG->GetId()> digLG->GetId()){
       iLG++ ;
       digLG = dynamic_cast<AliPHOSDigit*>(tmpLG.At(iLG)) ;
     }
+    absId=digHG->GetId() ;                                                                                                         
+    fGeom->AbsToRelNumbering(absId,relId) ;                                                                                              
+ 
     if(digLG && digHG->GetId() == digLG->GetId()){ //we found pair
       if(digHG->GetEnergy()<0.){ //This is overflow in HG
         digHG->SetTime(digLG->GetTime()) ;
         digHG->SetEnergy(digLG->GetEnergy()) ;
       } 
       else{ //Make approximate comparison of HG and LG energies
-        Double_t de = (digHG->GetEnergy()-digLG->GetEnergy())/16./0.005 ; //aproximate difference in LG ADC ch. 
-        if(TMath::Abs(de)>highLowDiff){ //too strong difference, remove digit
+        Double_t de = (digHG->GetEnergy()-digLG->GetEnergy()) ; 
+        if(TMath::Abs(de)>CalibrateE(double(highLowDiff),relId,1)){ //too strong difference, remove digit
           digits->RemoveAt(iDig) ;
         }
       }
     }
     else{ //no pair - remove
       // temporary fix for dead LG channels
-      Int_t absId=digHG->GetId() ;
-      Int_t relId[4] ;
-      fGeom->AbsToRelNumbering(absId,relId) ;
       if(relId[2]%2==1 && relId[3]%16==4) 
         continue ;
-      digits->RemoveAt(iDig) ;                                                                                                            
+      if(digHG->GetEnergy()>CalibrateE(double(5.),relId,1)) //One can not always find LG with Amp<5 ADC ch.
+        digits->RemoveAt(iDig) ;                                                                                                            
     }
   }
 
@@ -206,6 +230,7 @@ Double_t AliPHOSRawDigiProducer::CalibrateE(Double_t amp, Int_t* relId, Bool_t i
 Double_t AliPHOSRawDigiProducer::CalibrateT(Double_t time, Int_t * relId, Bool_t /* isLowGain */)
 {
   //Calibrate time
+  time*=fPulseGenerator->GetRawFormatTimeTrigger() ;
   if(fgCalibData){
     Int_t   module = relId[0];
     Int_t   column = relId[3];
@@ -243,7 +268,7 @@ void AliPHOSRawDigiProducer::CleanDigits(TClonesArray * digits)
     if(isBadMap){ //check bad map now
       Int_t relid[4] ;
       fGeom->AbsToRelNumbering(digit->GetId(), relid) ; 
-      if(fgCalibData->IsBadChannelEmc(relid[0],relid[2],relid[3])){
+      if(fgCalibData->IsBadChannelEmc(relid[0],relid[3],relid[2])){
        digits->RemoveAt(i) ;
       }
     }