#include "AliPHOSDigit.h"
#include "AliPHOSRecoParam.h"
#include "AliPHOSCalibData.h"
+#include "AliPHOSPulseGenerator.h"
#include "AliLog.h"
ClassImp(AliPHOSRawDigiProducer)
AliPHOSCalibData * AliPHOSRawDigiProducer::fgCalibData = 0 ;
//--------------------------------------------------------------------------------------
-AliPHOSRawDigiProducer::AliPHOSRawDigiProducer():TObject(),
- fEmcMinE(0.),fCpvMinE(0.),fEmcCrystals(0),fGeom(0){
-
+AliPHOSRawDigiProducer::AliPHOSRawDigiProducer():
+ TObject(),
+ fEmcMinE(0.),
+ fCpvMinE(0.),
+ fSampleQualityCut(1.),
+ fEmcCrystals(0),
+ fGeom(0),
+ fPulseGenerator(0)
+{
+ // Default constructor
}
//--------------------------------------------------------------------------------------
-AliPHOSRawDigiProducer::AliPHOSRawDigiProducer(const AliPHOSRecoParam* parEmc, const AliPHOSRecoParam* parCpv):TObject(),
- fEmcMinE(0.),fCpvMinE(0.),fEmcCrystals(0),fGeom(0){
+AliPHOSRawDigiProducer::AliPHOSRawDigiProducer(const AliPHOSRecoParam* recoParam):
+ TObject(),
+ fEmcMinE(0.),
+ fCpvMinE(0.),
+ fSampleQualityCut(1.),
+ fEmcCrystals(0),
+ fGeom(0),
+ fPulseGenerator(0)
+{
+ // Constructor takes paramerters from recoParam
+
+ if(!recoParam) AliFatal("Reconstruction parameters are not set!");
- if(!parEmc) AliFatal("Reconstruction parameters for EMC not set!");
- if(!parCpv) AliFatal("Reconstruction parameters for CPV not set!");
+ fEmcMinE = recoParam->GetEMCMinE();
+ fCpvMinE = recoParam->GetCPVMinE();
- fEmcMinE = parEmc->GetMinE();
- fCpvMinE = parCpv->GetMinE();
+ fSampleQualityCut = recoParam->GetEMCSampleQualityCut() ;
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){
+AliPHOSRawDigiProducer::AliPHOSRawDigiProducer(const AliPHOSRawDigiProducer &dp):
+ TObject(),
+ fEmcMinE(0.),
+ fCpvMinE(0.),
+ fSampleQualityCut(1.),
+ fEmcCrystals(0),
+ fGeom(0),
+ fPulseGenerator(0)
+{
+ // Copy constructor
fEmcMinE = dp.fEmcMinE ;
fCpvMinE = dp.fCpvMinE ;
fEmcCrystals = dp.fEmcCrystals ;
+ fPulseGenerator = new AliPHOSPulseGenerator();
fGeom = dp.fGeom ;
}
//--------------------------------------------------------------------------------------
-AliPHOSRawDigiProducer& AliPHOSRawDigiProducer::operator= (const AliPHOSRawDigiProducer &dp){
+AliPHOSRawDigiProducer& AliPHOSRawDigiProducer::operator= (const AliPHOSRawDigiProducer &dp)
+{
+ // Assign operator
+
if(&dp == this) return *this;
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()
+{
+ // Desctructor
+ if(fPulseGenerator) delete fPulseGenerator ;
+ fPulseGenerator=0 ;
+}
//--------------------------------------------------------------------------------------
void AliPHOSRawDigiProducer::MakeDigits(TClonesArray *digits, AliPHOSRawDecoder* decoder)
{
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) ;
if(energy<=baseLine) //in ADC channels
continue ;
+ //remove digits with bad 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();
continue;
if(lowGainFlag){
- new(tmpLG[ilgDigit]) AliPHOSDigit(-1,absId,(Float_t)energy,(Float_t)time);
+ new(tmpLG[ilgDigit]) AliPHOSDigit(-1,absId,(Float_t)energy,(Float_t)time);
ilgDigit++ ;
}
else{
if(decoder->IsOverflow()) //Keep this digit to replace it by Low Gain later.
//If there is no LogGain it wil be removed by cut on Min E
- new((*digits)[iDigit]) AliPHOSDigit(-1,absId,-1.f,(Float_t)time);
+ new((*digits)[iDigit]) AliPHOSDigit(-1,absId,-1.f,(Float_t)time);
else
- new((*digits)[iDigit]) AliPHOSDigit(-1,absId,(Float_t)energy,(Float_t)time);
- iDigit++;
+ new((*digits)[iDigit]) AliPHOSDigit(-1,absId,(Float_t)energy,(Float_t)time);
+ iDigit++;
}
}
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)) ;
}
- if(digHG->GetId() == digLG->GetId()){ //we found pair
+ 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()) ;
+ 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) ;
}
}
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];
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) ;
}
}