fToUnfold(kFALSE),
fNumberOfECAClusters(0),fCalibData(0),fCaloPed(0),
fADCchannelECA(0.),fADCpedestalECA(0.),fECAClusteringThreshold(0.),fECALocMaxCut(0.),
- fECAW0(0.),fTimeCut(1.),fMinECut(0.)
+ fECAW0(0.),fTimeCut(1.),fTimeMin(-1.),fTimeMax(1.),fMinECut(0.)
{
// ctor with the indication of the file where header Tree and digits Tree are stored
fToUnfold(kFALSE),
fNumberOfECAClusters(0),fCalibData(0), fCaloPed(0),
fADCchannelECA(0.),fADCpedestalECA(0.),fECAClusteringThreshold(0.),fECALocMaxCut(0.),
- fECAW0(0.),fTimeCut(1.),fMinECut(0.)
+ fECAW0(0.),fTimeCut(1.),fTimeMin(-1.),fTimeMax(1.),fMinECut(0.)
{
// ctor with the indication of the file where header Tree and digits Tree are stored
// use this contructor to avoid usage of Init() which uses runloader
fToUnfold(kFALSE),
fNumberOfECAClusters(0),fCalibData(calib), fCaloPed(caloped),
fADCchannelECA(0.),fADCpedestalECA(0.),fECAClusteringThreshold(0.),fECALocMaxCut(0.),
-fECAW0(0.),fTimeCut(1.),fMinECut(0.)
+fECAW0(0.),fTimeCut(1.),fTimeMin(-1.),fTimeMax(1.),fMinECut(0.)
{
// ctor, geometry and calibration are initialized elsewhere.
}
//____________________________________________________________________________
-Float_t AliEMCALClusterizerv1::Calibrate(Int_t amp, Int_t absId)
+Float_t AliEMCALClusterizerv1::Calibrate(const Float_t amp, const Float_t time, const Int_t absId)
{
// Convert digitized amplitude into energy.
AliFatal("Did not get geometry from EMCALLoader") ;
Int_t iSupMod = -1;
- Int_t nModule = -1;
+ Int_t nModule = -1;
Int_t nIphi = -1;
Int_t nIeta = -1;
Int_t iphi = -1;
AliDebug(2,Form("Tower from SM %d, ieta %d, iphi %d is BAD : status %d !!!",iSupMod,ieta,iphi, channelStatus));
return 0;
}
+ //Check if time is too large or too small, indication of a noisy channel, remove in this case
+ if(time > fTimeMax || time < fTimeMin) return 0;
fADCchannelECA = fCalibData->GetADCchannel (iSupMod,ieta,iphi);
fADCpedestalECA = fCalibData->GetADCpedestal(iSupMod,ieta,iphi);
fToUnfold = recParam->GetUnfold();
if(fToUnfold) AliWarning("Cluster Unfolding ON. Implementing only for eta=0 case!!!");
fECALocMaxCut = recParam->GetLocMaxCut();
- fTimeCut = recParam->GetTimeCut();// Originally 300 ns time cut, in data time found to be between 350 ns and 1500 ns, relax the cut for the moment, 1s.
+ fTimeCut = recParam->GetTimeCut();
+ fTimeMin = recParam->GetTimeMin();
+ fTimeMax = recParam->GetTimeMax();
- AliDebug(1,Form("Reconstruction parameters: fECAClusteringThreshold=%.3f, fECAW=%.3f, fMinECut=%.3f, fToUnfold=%d, fECALocMaxCut=%.3f, fTimeCut=%f",
- fECAClusteringThreshold,fECAW0,fMinECut,fToUnfold,fECALocMaxCut,fTimeCut));
+ AliDebug(1,Form("Reconstruction parameters: fECAClusteringThreshold=%.3f GeV, fECAW=%.3f, fMinECut=%.3f GeV, fToUnfold=%d, fECALocMaxCut=%.3f GeV, fTimeCut=%e s,fTimeMin=%e s,fTimeMax=%e s",
+ fECAClusteringThreshold,fECAW0,fMinECut,fToUnfold,fECALocMaxCut,fTimeCut, fTimeMin, fTimeMax));
}
}
fGeom->GetCellIndex(d1->GetId(), nSupMod1,nModule1,nIphi1,nIeta1);
fGeom->GetCellIndex(d2->GetId(), nSupMod2,nModule2,nIphi2,nIeta2);
- if(nSupMod1 != nSupMod2) return 2; // different SM
+ // Do not aggregate cells in different SM
+ if(nSupMod1 != nSupMod2 ) return 2;
+
fGeom->GetCellPhiEtaIndexInSModule(nSupMod1,nModule1,nIphi1,nIeta1, iphi1,ieta1);
fGeom->GetCellPhiEtaIndexInSModule(nSupMod2,nModule2,nIphi2,nIeta2, iphi2,ieta2);
-
+
rowdiff = TMath::Abs(iphi1 - iphi2);
coldiff = TMath::Abs(ieta1 - ieta2) ;
- // neighbours with at least commom side; May 11, 2007
- if ((coldiff==0 && abs(rowdiff)==1) || (rowdiff==0 && abs(coldiff)==1)) rv = 1;
-
+ // neighbours in same SM with at least common side; May 11, 2007
+ if ((coldiff==0 && TMath::Abs(rowdiff)==1) || (rowdiff==0 && TMath::Abs(coldiff)==1)) rv = 1;
+
+ //Diagonal?
+ //if ((coldiff==0 && TMath::Abs(rowdiff==1)) || (rowdiff==0 && TMath::Abs(coldiff==1)) || (TMath::Abs(rowdiff)==1 && TMath::Abs(coldiff==1))) rv = 1;
+
if (gDebug == 2 && rv==1)
- printf("AreNeighbours: neighbours=%d, id1=%d, relid1=%d,%d \n id2=%d, relid2=%d,%d \n",
- rv, d1->GetId(), iphi1,ieta1, d2->GetId(), iphi2,ieta2);
+ printf("AreNeighbours: id1=%d, (%d,%d) \n id2=%d, (%d,%d) \n",d1->GetId(), iphi1,ieta1, d2->GetId(), iphi2,ieta2);
return rv ;
}
double e = 0.0, ehs = 0.0;
TIter nextdigitC(digitsC);
while ( (digit = dynamic_cast<AliEMCALDigit *>(nextdigitC())) ) { // clean up digits
- e = Calibrate(digit->GetAmp(), digit->GetId());
- if ( e < fMinECut || digit->GetTimeR() > fTimeCut )
+ e = Calibrate(digit->GetAmplitude(), digit->GetTime(),digit->GetId());//Time or TimeR?
+ if ( e < fMinECut) //|| digit->GetTimeR() > fTimeCut ) // time window of cell checked in calibrate
digitsC->Remove(digit);
else
ehs += e;
while ( (digit = dynamic_cast<AliEMCALDigit *>(nextdigitC())) ) { // scan over the list of digitsC
TArrayI clusterECAdigitslist(fDigitsArr->GetEntries());
- if(fGeom->CheckAbsCellId(digit->GetId()) && (Calibrate(digit->GetAmp(), digit->GetId()) > fECAClusteringThreshold ) ){
+ if(fGeom->CheckAbsCellId(digit->GetId()) && (Calibrate(digit->GetAmplitude(), digit->GetTime(),digit->GetId()) > fECAClusteringThreshold ) ){
// start a new Tower RecPoint
if(fNumberOfECAClusters >= fRecPoints->GetSize()) fRecPoints->Expand(2*fNumberOfECAClusters+1) ;
recPoint->SetClusterType(AliESDCaloCluster::kEMCALClusterv1);
- recPoint->AddDigit(*digit, Calibrate(digit->GetAmp(), digit->GetId())) ;
+ recPoint->AddDigit(*digit, Calibrate(digit->GetAmplitude(), digit->GetTime(),digit->GetId())) ; //Time or TimeR?
TObjArray clusterDigits;
clusterDigits.AddLast(digit);
digitsC->Remove(digit) ;
AliDebug(1,Form("MakeClusters: OK id = %d, ene = %f , cell.th. = %f \n", digit->GetId(),
- Calibrate(digit->GetAmp(),digit->GetId()), fECAClusteringThreshold));
-
+ Calibrate(digit->GetAmplitude(),digit->GetTime(),digit->GetId()), fECAClusteringThreshold)); //Time or TimeR?
+ Float_t time = digit->GetTime();//Time or TimeR?
// Grow cluster by finding neighbours
TIter nextClusterDigit(&clusterDigits);
while ( (digit = dynamic_cast<AliEMCALDigit*>(nextClusterDigit())) ) { // scan over digits in cluster
- TIter nextdigitN(digitsC);
+ TIter nextdigitN(digitsC);
AliEMCALDigit *digitN = 0; // digi neighbor
while ( (digitN = (AliEMCALDigit *)nextdigitN()) ) { // scan over all digits to look for neighbours
- if (AreNeighbours(digit, digitN)==1) { // call (digit,digitN) in THAT oder !!!!!
- recPoint->AddDigit(*digitN, Calibrate(digitN->GetAmp(),digitN->GetId()) ) ;
- clusterDigits.AddLast(digitN) ;
- digitsC->Remove(digitN) ;
- } // if(ineb==1)
- } // scan over digits
+
+ //Do not add digits with too different time
+ if(TMath::Abs(time - digitN->GetTime()) > fTimeCut ) continue; //Time or TimeR?
+
+ if (AreNeighbours(digit, digitN)==1) { // call (digit,digitN) in THAT oder !!!!!
+
+ recPoint->AddDigit(*digitN, Calibrate(digitN->GetAmplitude(), digitN->GetTime(), digitN->GetId()) ) ;//Time or TimeR?
+ clusterDigits.AddLast(digitN) ;
+ digitsC->Remove(digitN) ;
+ } // if(ineb==1)
+ } // scan over digits
} // scan over digits already in cluster
if(recPoint)
AliDebug(2,Form("MakeClusters: %d digitd, energy %f \n", clusterDigits.GetEntries(), recPoint->GetEnergy()));
virtual Int_t AreNeighbours(AliEMCALDigit * d1, AliEMCALDigit * d2)const ;
// Checks if digits are in neighbour cells
- virtual Float_t Calibrate(Int_t amp, Int_t cellId) ; // Tranforms Amp to energy
+ virtual Float_t Calibrate(const Float_t amp, const Float_t time, const Int_t cellId) ; // Tranforms Amp to energy
virtual void GetNumberOfClustersFound(int numb )const{ numb = fNumberOfECAClusters ;}
virtual Float_t GetECAClusteringThreshold()const{ return fECAClusteringThreshold;}
virtual Float_t GetMinECut()const { return fMinECut;}
virtual Float_t GetTimeCut() const { return fTimeCut ; }
+ virtual Float_t GetTimeMin() const { return fTimeMin ; }
+ virtual Float_t GetTimeMax() const { return fTimeMax ; }
virtual void Digits2Clusters(Option_t *option); // Does the job
virtual void SetMinECut(Float_t mine) { fMinECut = mine; }
virtual void SetECALocalMaxCut(Float_t cut) { fECALocMaxCut = cut ; }
virtual void SetECALogWeight(Float_t w) { fECAW0 = w ; }
- virtual void SetTimeCut(Float_t gate) { fTimeCut = gate ;}
+ virtual void SetTimeCut(Float_t t) { fTimeCut = t ;}
+ virtual void SetTimeMin(Float_t t) { fTimeMin = t ;}
+ virtual void SetTimeMax(Float_t t) { fTimeMax = t ;}
+
virtual void SetUnfolding(Bool_t toUnfold = kTRUE ) {fToUnfold = toUnfold ;}
static Double_t ShowerShape(Double_t x, Double_t y) ; // Shape of EM shower used in unfolding;
//class member function (not object member function)
Float_t fECAClusteringThreshold ; // minimum energy to seed a EC digit in a cluster
Float_t fECALocMaxCut ; // minimum energy difference to distinguish local maxima in a cluster
Float_t fECAW0 ; // logarithmic weight for the cluster center of gravity calculation
- Float_t fTimeCut ; // Maximum time difference between the digits in ont EMC cluster
+ Float_t fTimeCut ; // Maximum time difference between the digits inside EMC cluster
+ Float_t fTimeMin ; // Minimum time of physical signal in a cell/digiy
+ Float_t fTimeMax ; // Maximum time of physical signal in a cell/digit
Float_t fMinECut; // Minimum energy for a digit to be a member of a cluster
- ClassDef(AliEMCALClusterizerv1,8) // Clusterizer implementation version 1
+ ClassDef(AliEMCALClusterizerv1,9) // Clusterizer implementation version 1
};
//____________________________________________________________________________
AliEMCALDigit::AliEMCALDigit() :
- AliDigitNew(),
+AliDigitNew(),
+ fAmpFloat(0.),
+ fNSamples(0),
+ fSamples(0x0),
+ fNSamplesHG(0),
+ fSamplesHG(0x0),
fNprimary(0),
fNMaxPrimary(5),
fPrimary(0x0),
fDEParent(0x0),
fMaxIter(0),
fTime(0.),
- fTimeR(0.)
+ fTimeR(0.),
+ fChi2(0.),
+ fNDF(0),
+ fTriggerDigit(kFALSE)
{
// default ctor
}
//____________________________________________________________________________
-AliEMCALDigit::AliEMCALDigit(Int_t primary, Int_t iparent, Int_t id, Int_t DigEnergy, Float_t time, Int_t index, Float_t dE)
+AliEMCALDigit::AliEMCALDigit(Int_t primary, Int_t iparent, Int_t id, Float_t digEnergy, Float_t time, Bool_t trigger, Int_t index, Float_t dE)
: AliDigitNew(),
+ fAmpFloat(digEnergy),
+ fNSamples(0),
+ fSamples(0x0),
+ fNSamplesHG(0),
+ fSamplesHG(0x0),
fNprimary(0),
fNMaxPrimary(25),
fPrimary(0x0),
fDEParent(0x0),
fMaxIter(5),
fTime(time),
- fTimeR(time)
+ fTimeR(time),
+ fChi2(0.),
+ fNDF(0),
+ fTriggerDigit(trigger)
{
// ctor with all data
// data memebrs of the base class (AliNewDigit)
- fAmp = DigEnergy ;
+ fAmp = 0;
fId = id ;
fIndexInList = index ;
- // data members
+ // data member
fPrimary = new Int_t[fNMaxPrimary] ;
fDEPrimary = new Float_t[fNMaxPrimary] ;
fIparent = new Int_t[fNMaxiparent] ;
//____________________________________________________________________________
AliEMCALDigit::AliEMCALDigit(const AliEMCALDigit & digit)
: AliDigitNew(digit),
+ fAmpFloat(digit.fAmpFloat),
+ fNSamples(digit.fNSamples),
+ fSamples(0x0),
+ fNSamplesHG(digit.fNSamplesHG),
+ fSamplesHG(0x0),
fNprimary(digit.fNprimary),
fNMaxPrimary(digit.fNMaxPrimary),
fPrimary(0x0),
fDEParent(0x0),
fMaxIter(digit.fMaxIter),
fTime(digit.fTime),
- fTimeR(digit.fTimeR)
+ fTimeR(digit.fTimeR),
+ fChi2(digit.fChi2),
+ fNDF(digit.fNDF),
+ fTriggerDigit(digit.fTriggerDigit)
{
// copy ctor
fId = digit.fId;
fIndexInList = digit.fIndexInList ;
- // data members
+ // data members
+ fSamples = new Int_t[fNSamples];
+ for (Int_t i=0; i < digit.fNSamples; i++) fSamples[i] = digit.fSamples[i];
+ fSamplesHG = new Int_t[fNSamplesHG];
+ for (Int_t i=0; i < digit.fNSamplesHG; i++) fSamplesHG[i] = digit.fSamplesHG[i];
+
fPrimary = new Int_t[fNMaxPrimary] ;
fDEPrimary = new Float_t[fNMaxPrimary] ;
fIparent = new Int_t[fNMaxiparent] ;
delete [] fDEPrimary ;
delete [] fIparent ;
delete [] fDEParent ;
+ delete [] fSamples;
+ delete [] fSamplesHG;
+
}
//____________________________________________________________________________
return phi ;
}
+//____________________________________________________________________________
+Bool_t AliEMCALDigit::GetFALTROSample(const Int_t iSample, Int_t& timeBin, Int_t& amp) const
+{
+ //Get FALTRO sample in time bin iSample
+ if (iSample >= fNSamples || iSample < 0 || !fTriggerDigit) return kFALSE;
+
+ amp = fSamples[iSample] & 0xFFF;
+ timeBin = (fSamples[iSample] >> 12) & 0xFF;
+
+ return kTRUE;
+}
+//____________________________________________________________________________
+Bool_t AliEMCALDigit::GetALTROSampleLG(const Int_t iSample, Int_t& timeBin, Int_t& amp) const
+{
+ //Get Low Gain ALTRO sample in time bin iSample
+ if (iSample >= fNSamples || iSample < 0 || fTriggerDigit) return kFALSE;
+
+ amp = fSamples[iSample] & 0xFFF;
+ timeBin = (fSamples[iSample] >> 12) & 0xFF;
+
+ return kTRUE;
+}
+
+//____________________________________________________________________________
+void AliEMCALDigit::SetALTROSamplesLG(const Int_t nSamples, Int_t *samples)
+{
+ //Set array of ALTRO samples, Low Gain or FALTRO
+ fNSamples = nSamples;
+ fSamples = new Int_t[fNSamples];
+ for (Int_t i=0; i < fNSamples; i++) fSamples[i] = samples[i];
+}
+
+//____________________________________________________________________________
+void AliEMCALDigit::SetALTROSamplesHG(const Int_t nSamples, Int_t *samples)
+{
+ //Set array of ALTRO samples, High Gain.
+ fNSamplesHG = nSamples;
+ fSamplesHG = new Int_t[fNSamplesHG];
+ for (Int_t i=0; i < fNSamplesHG; i++) fSamplesHG[i] = samples[i];
+}
+
+
+//____________________________________________________________________________
+Bool_t AliEMCALDigit::GetALTROSampleHG(const Int_t iSample, Int_t& timeBin, Int_t& amp) const
+{
+ //Get High Gain ALTRO sample in time bin iSample
+ if (iSample >= fNSamplesHG || iSample < 0 || fTriggerDigit) return kFALSE;
+
+ amp = fSamplesHG[iSample] & 0xFFF;
+ timeBin = (fSamplesHG[iSample] >> 12) & 0xFF;
+
+ return kTRUE;
+}
+
+
//____________________________________________________________________________
Int_t AliEMCALDigit::GetPrimary(Int_t index) const
{
// Adds the amplitude of digits and completes the list of primary particles
// if amplitude is larger than
- fAmp += digit.fAmp ;
+ fAmpFloat += digit.fAmpFloat ;
+ for (Int_t i=0; i < fNSamples ; i++) fSamples[i] += digit.fSamples[i];
+ for (Int_t i=0; i < fNSamplesHG; i++) fSamplesHG[i] += digit.fSamplesHG[i];
+
+ fAmp += digit.fAmp ;
if(fTime > digit.fTime)
fTime = digit.fTime ;
if (digit.fTimeR < fTimeR)
{
// Multiplies the amplitude by a factor
- Float_t tempo = static_cast<Float_t>(fAmp) ;
- tempo *= factor ;
- fAmp = static_cast<Int_t>(TMath::Ceil(tempo)) ;
+ //Float_t tempo = static_cast<Float_t>(fAmp) ;
+ //tempo *= factor ;
+ //fAmp = static_cast<Int_t>(TMath::Floor(tempo)) ;
+
+ fAmpFloat *= factor;
+ for (Int_t i=0; i < fNSamples ; i++) fSamples[i] = Int_t(factor*fSamples[i]);
+ for (Int_t i=0; i < fNSamplesHG; i++) fSamplesHG[i] = Int_t(factor*fSamplesHG[i]);
+
for(Int_t i=0; i < fNprimary; i++)
fDEPrimary[i] *= factor;
for(Int_t i=0; i < fNiparent; i++)
return out ;
}
+//____________________________________________________________________________
+void AliEMCALDigit::Print(const Option_t* /*opt*/) const
+{
+ //Print
+ printf("===\nDigit id: %4d / Energy %2.3f ; Time %e ; Time samples %d ; Chi2 %2.3f, NDF %d, Trigger? %d \n",
+ fId, fAmpFloat,fTime, fNSamples, fChi2, fNDF, fTriggerDigit);
+ if(fTriggerDigit){
+ printf("FALTRO: ");
+ for (Int_t i=0; i < GetNFALTROSamples(); i++)
+ {
+ Int_t timeBin, amp;
+ GetFALTROSample(i, timeBin, amp);
+ printf(" (%d,%d) ",timeBin,amp);
+ }
+ printf("\n");
+ }//trigger
+ else{
+ printf("ALTRO, Low Gain: ");
+ for (Int_t i=0; i < GetNALTROSamplesLG(); i++)
+ {
+ Int_t timeBin, amp;
+ GetALTROSampleLG(i, timeBin, amp);
+ printf(" (%d,%d) ",timeBin,amp);
+ }
+ printf("\n");
+ printf("ALTRO, High Gain: ");
+ for (Int_t i=0; i < GetNALTROSamplesHG(); i++)
+ {
+ Int_t timeBin, amp;
+ GetALTROSampleHG(i, timeBin, amp);
+ printf(" (%d,%d) ",timeBin,amp);
+ }
+ printf("\n");
+ }//trigger
+
+}
+
+
public:
AliEMCALDigit() ;
- AliEMCALDigit(Int_t primary, Int_t iparent, Int_t id, Int_t DigEnergy, Float_t Time, Int_t index = -1, Float_t dE = 0) ;
+ AliEMCALDigit(Int_t primary, Int_t iparent, Int_t id, Float_t digEnergy, Float_t time, Bool_t trigger,Int_t index = -1, Float_t dE = 0) ;
AliEMCALDigit(const AliEMCALDigit & digit) ;
virtual ~AliEMCALDigit() ;
AliEMCALDigit operator*(Float_t factor) ;
const AliEMCALDigit& operator = (const AliEMCALDigit &) {return *this;}
- Int_t Compare(const TObject * obj) const ;
- Float_t GetEta() const ;
- Int_t GetNprimary() const { return fNprimary ; }
- Int_t GetPrimary(Int_t index) const ;
+ 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 ;}
- Bool_t IsSortable() const { return kTRUE ; }
- void SetAmp(Int_t amp) { fAmp= amp ; }
- void SetId(Int_t id) {fId = id ;}
- void SetTime(Float_t time) {fTime = time ;}
- void SetTimeR(Float_t time) {fTimeR = time ;}
+ 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 ;}
+ Bool_t IsTriggerDigit() const { return fTriggerDigit ;}
+
+ void SetAmp(Int_t amp) { fAmp = amp ;} //old
+ void SetAmplitude(Float_t amp) { fAmpFloat = amp ;}
+ void SetId(Int_t id) { fId = id ;}
+ 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 SetTriggerDigit(Bool_t b) { fTriggerDigit = b ;}
void ShiftPrimary(Int_t shift); // shift to separate different TreeK in merging
-
- private:
+
+ //Raw time sample
+ //ALTRO
+ Int_t GetNALTROSamplesLG() const {if(!fTriggerDigit)return fNSamples; else return 0;}
+ Bool_t GetALTROSampleLG(const Int_t iSample, Int_t& timeBin, Int_t& amp) const;
+ Int_t GetNALTROSamplesHG() const {if(!fTriggerDigit) 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(fTriggerDigit) 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(fTriggerDigit) SetALTROSamplesLG(nSamples, samples);}
+ 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
+
Int_t fNprimary ; // Number of primaries
Int_t fNMaxPrimary ; // Max Number of primaries
Int_t *fPrimary ; //[fNMaxPrimary] Array of primaries
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
-
- ClassDef(AliEMCALDigit,3) // Digit in EMCAL
+ //Fit quality parameters
+ Float_t fChi2; // Fit Chi aquare
+ Int_t fNDF; // Fit Number of Degrees of Freedom
+
+ Bool_t fTriggerDigit; // This is a trigger digit or not
+
+ ClassDef(AliEMCALDigit,4) // Digit in EMCAL
} ;
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() ); // absID-1->absID
+ new((*digits)[absID]) AliEMCALDigit( -1, -1, absID, 0., TimeOfNoise(),kFALSE); // absID-1->absID
//look if we have to add signal?
digit = dynamic_cast<AliEMCALDigit *>(digits->At(absID)); // absID-1->absID
//Follow PHOS and comment out this timing model til a better one
//can be developed - JLK 28-Apr-2008
- //Float_t a = digit->GetAmp() ;
+ //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);
// Calculate time as time of the largest digit
Float_t time = digit->GetTime() ;
- Float_t aTime= digit->GetAmp() ;
+ Float_t aTime= digit->GetAmplitude() ;
// loop over input
for(i = 0; i< fInput ; i++){ //loop over (possible) merge sources
curSDigit->ShiftPrimary(primaryoffset) ;
//Remove old timing model - JLK 28-April-2008
- //a = curSDigit->GetAmp() ;
+ //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->GetAmp()>aTime) {
- aTime = curSDigit->GetAmp();
+ if(curSDigit->GetAmplitude()>aTime) {
+ aTime = curSDigit->GetAmplitude();
time = curSDigit->GetTime();
}
}
}
//Here we convert the summed amplitude to an energy in GeV
- energy = sDigitizer->Calibrate(digit->GetAmp()) ; // 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) ;
//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->SetAmp(sDigitizer->Digitize(energy)) ;
+ digit->SetAmplitude(sDigitizer->Digitize(energy)) ;
AliDebug(10,Form(" absID %5i energy %f nextSig %5i\n",
absID, energy, nextSig));
} // for(absID = 0; absID < nEMC; absID++)
for(i = 0 ; i < nEMC ; i++){
digit = dynamic_cast<AliEMCALDigit*>( digits->At(i) ) ;
//First get the energy in GeV units.
- energy = sDigitizer->Calibrate(digit->GetAmp()) ;
+ energy = sDigitizer->Calibrate(digit->GetAmplitude()) ;
//Then digitize using the calibration constants of the ocdb
- Int_t ampADC = DigitizeEnergy(energy, digit->GetId()) ;
- //if(ampADC>2)printf("Digit energy %f, amp %d, amp cal %d, threshold %d\n",energy,digit->GetAmp(),ampADC,fDigitThreshold);
+ 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
for (i = 0 ; i < ndigits ; i++) {
digit = dynamic_cast<AliEMCALDigit *>( digits->At(i) ) ;
digit->SetIndexInList(i) ;
- energy = sDigitizer->Calibrate(digit->GetAmp()) ;
- digit->SetAmp(DigitizeEnergy(energy, digit->GetId()) ) ;
+ energy = sDigitizer->Calibrate(digit->GetAmplitude()) ;
+ digit->SetAmplitude(DigitizeEnergy(energy, digit->GetId()) ) ;
+ // printf("digit amplitude set at end: i %d, amp %f\n",i,digit->GetAmplitude());
}
}
// //_____________________________________________________________________
-Int_t AliEMCALDigitizer::DigitizeEnergy(Float_t energy, Int_t AbsId)
+Float_t AliEMCALDigitizer::DigitizeEnergy(Float_t energy, Int_t AbsId)
{
// JLK 26-June-2008
// Returns digitized value of the energy in a cell absId
Int_t nIeta = -1;
Int_t iphi = -1;
Int_t ieta = -1;
- Int_t channel = -999;
+ Float_t channel = -999;
Bool_t bCell = geom->GetCellIndex(AbsId, iSupMod, nModule, nIphi, nIeta) ;
if(!bCell)
fADCchannelEC = fCalibData->GetADCchannel(iSupMod,ieta,iphi);
}
- channel = static_cast<Int_t> (TMath::Floor( (energy + fADCpedestalEC)/fADCchannelEC )) ;
-
+ //channel = static_cast<Int_t> (TMath::Floor( (energy + fADCpedestalEC)/fADCchannelEC )) ;
+ channel = (energy + fADCpedestalEC)/fADCchannelEC ;
+
if(channel > fNADCEC )
channel = fNADCEC ;
return channel ;
Int_t index ;
for (index = 0 ; index < digits->GetEntries() ; index++) {
digit = dynamic_cast<AliEMCALDigit *>(digits->At(index)) ;
- printf("\n%6d %8d %6.5e %4d %2d : ",
- digit->GetId(), digit->GetAmp(), digit->GetTime(), digit->GetIndexInList(), digit->GetNprimary()) ;
+ printf("\n%6d %8f %6.5e %4d %2d : ",
+ digit->GetId(), digit->GetAmplitude(), digit->GetTime(), digit->GetIndexInList(), digit->GetNprimary()) ;
Int_t iprimary;
for (iprimary=0; iprimary<digit->GetNprimary(); iprimary++) {
printf("%d ",digit->GetPrimary(iprimary+1) ) ;
//Calculate the time of crossing of the threshold by front edge
//Float_t FrontEdgeTime(TClonesArray * ticks) ;
- Int_t DigitizeEnergy(Float_t energy, Int_t AbsId) ;
+ 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);
TIter next(fDigitsArray) ;
AliEMCALDigit * digit ;
while ( (digit = dynamic_cast<AliEMCALDigit *>(next())) ) {
- GetDigitsData(0)->Fill( digit->GetAmp()) ;
+ GetDigitsData(0)->Fill( digit->GetAmplitude()) ;
}
}
// loop over digits (assume ordered digits)
for (Int_t iDigit = 0; iDigit < digits->GetEntries(); iDigit++) {
AliEMCALDigit* digit = dynamic_cast<AliEMCALDigit *>(digits->At(iDigit)) ;
- if (digit->GetAmp() < fgThreshold)
+ if (digit->GetAmplitude() < fgThreshold)
continue;
//get cell indices
// out of time range signal (?)
if (digit->GetTimeR() > GetRawFormatTimeMax() ) {
AliInfo("Signal is out of time range.\n");
- buffers[iDDL]->FillBuffer((Int_t)digit->GetAmp());
+ buffers[iDDL]->FillBuffer((Int_t)digit->GetAmplitude());
buffers[iDDL]->FillBuffer(GetRawFormatTimeBins() ); // time bin
buffers[iDDL]->FillBuffer(3); // bunch length
buffers[iDDL]->WriteTrailer(3, ieta, iphi, nSM); // trailer
// calculate the time response function
} else {
- Bool_t lowgain = RawSampledResponse(digit->GetTimeR(), digit->GetAmp(), adcValuesHigh.GetArray(), adcValuesLow.GetArray()) ;
+ Bool_t lowgain = RawSampledResponse(digit->GetTimeR(), digit->GetAmplitude(), adcValuesHigh.GetArray(), adcValuesLow.GetArray()) ;
if (lowgain)
buffers[iDDL]->WriteChannel(ieta, iphi, 0, GetRawFormatTimeBins(), adcValuesLow.GetArray(), fgThreshold);
else
fRawAnalyzer->SetIsZeroSuppressed(true); // TMP - should use stream->IsZeroSuppressed(), or altro cfg registers later
// channel info parameters
- Int_t lowGain = 0;
+ Int_t lowGain = 0;
Int_t caloFlag = 0; // low, high gain, or TRU, or LED ref.
// start loop over input stream
if ( caloFlag < 2 ){ // ALTRO
Float_t time = 0;
- Float_t amp = 0;
- short timeEstimate = 0;
+ Float_t amp = 0;
+ short timeEstimate = 0;
Float_t ampEstimate = 0;
Bool_t fitDone = kFALSE;
// all functionality to determine amp and time etc is encapsulated inside the Evaluate call for these methods
AliCaloFitResults fitResults = fRawAnalyzer->Evaluate( bunchlist, in.GetAltroCFG1(), in.GetAltroCFG2());
- amp = fitResults.GetAmp();
- time = fitResults.GetTime();
+ amp = fitResults.GetAmp();
+ time = fitResults.GetTime();
timeEstimate = fitResults.GetMaxTimebin();
- ampEstimate = fitResults.GetMaxSig();
+ ampEstimate = fitResults.GetMaxSig();
if (fitResults.GetStatus() == AliCaloFitResults::kFitPar) {
fitDone = kTRUE;
}
// AliDebug(2,Form("Fit results amp %f time %f not consistent with expectations amp %f time %d", amp, time, ampEstimate, timeEstimate));
// for now just overwrite the fit results with the simple/initial estimate
- amp = ampEstimate;
- time = timeEstimate;
+ amp = ampEstimate;
+ time = timeEstimate;
fitDone = kFALSE;
}
} // fitDone
amp += (0.5 - gRandom->Rndm()); // Rndm generates a number in ]0,1]
}
- Int_t id = fGeom->GetAbsCellIdFromCellIndexes(in.GetModule(), in.GetRow(), in.GetColumn()) ;
- lowGain = in.IsLowGain();
+ Int_t id = fGeom->GetAbsCellIdFromCellIndexes(in.GetModule(), in.GetRow(), in.GetColumn()) ;
+ lowGain = in.IsLowGain();
// go from time-bin units to physical time fgtimetrigger
time = time * GetRawFormatTimeBinWidth(); // skip subtraction of fgTimeTrigger?
AliDebug(2,Form("id %d lowGain %d amp %g", id, lowGain, amp));
// printf("Added tower: SM %d, row %d, column %d, amp %3.2f\n",in.GetModule(), in.GetRow(), in.GetColumn(),amp);
- // round off amplitude value to nearest integer
- AddDigit(digitsArr, id, lowGain, TMath::Nint(amp), time);
+ AddDigit(digitsArr, id, lowGain, amp, time);
}
}//ALTRO
}
//____________________________________________________________________________
-void AliEMCALRawUtils::AddDigit(TClonesArray *digitsArr, Int_t id, Int_t lowGain, Int_t amp, Float_t time) {
+void AliEMCALRawUtils::AddDigit(TClonesArray *digitsArr, Int_t id, Int_t lowGain, Float_t amp, Float_t time) {
//
// Add a new digit.
// This routine checks whether a digit exists already for this tower
if (!digit) { // no digit existed for this tower; create one
if (lowGain && amp > fgkOverflowCut)
- amp = Int_t(fHighLowGainFactor * amp);
+ amp *= fHighLowGainFactor;
Int_t idigit = digitsArr->GetEntries();
- new((*digitsArr)[idigit]) AliEMCALDigit( -1, -1, id, amp, time, idigit) ;
+ new((*digitsArr)[idigit]) AliEMCALDigit( -1, -1, id, amp, time, kFALSE, idigit) ;
}
else { // a digit already exists, check range
// (use high gain if signal < cut value, otherwise low gain)
if (lowGain) { // new digit is low gain
- if (digit->GetAmp() > fgkOverflowCut) { // use if stored digit is out of range
- digit->SetAmp(Int_t(fHighLowGainFactor * amp));
+ if (digit->GetAmplitude() > fgkOverflowCut) { // use if stored digit is out of range
+ digit->SetAmplitude(fHighLowGainFactor * amp);
digit->SetTime(time);
}
}
else if (amp < fgkOverflowCut) { // new digit is high gain; use if not out of range
- digit->SetAmp(amp);
+ digit->SetAmplitude(amp);
digit->SetTime(time);
}
}
try {
gSig->Fit(signalF, "QROW"); // Note option 'W': equal errors on all points
// assign fit results
- amp = signalF->GetParameter(0);
+ amp = signalF->GetParameter(0);
time = signalF->GetParameter(1);
// cross-check with ParabolaFit to see if the results make sense
return lowGain ;
}
+//__________________________________________________________________
void AliEMCALRawUtils::CalculateChi2(const Double_t* t, const Double_t* y, const Int_t nPoints,
const Double_t sig, const Double_t tau, const Double_t amp, const Double_t t0, Double_t &chi2)
{
void Raw2Digits(AliRawReader *reader, TClonesArray *digitsArr, const AliCaloCalibPedestal* pedbadmap,
TClonesArray *digitsTRG=0x0);
- void AddDigit(TClonesArray *digitsArr, Int_t id, Int_t lowGain, Int_t amp, Float_t time);
+ void AddDigit(TClonesArray *digitsArr, Int_t id, Int_t lowGain, Float_t amp, Float_t time);
void AddDigit(TClonesArray *digitsArr, Int_t id, Int_t timeSamples[], Int_t nSamples);
// Signal shape parameters
Double_t GetRawFormatHighLowGainFactor() const { return fHighLowGainFactor ;}
- Int_t GetRawFormatOrder() const { return fOrder ; }
+ Int_t GetRawFormatOrder() const { return fOrder ; }
Double_t GetRawFormatTau() const { return fTau ; }
- Int_t GetNoiseThreshold() const { return fNoiseThreshold; }
- Int_t GetNPedSamples() const { return fNPedSamples; }
+ Int_t GetNoiseThreshold() const { return fNoiseThreshold; }
+ Int_t GetNPedSamples() const { return fNPedSamples; }
// get methods for fast fit simulation
- Int_t GetPedestalValue() const {return fgPedestalValue;}
- Double_t GetFEENoise() const {return fgFEENoise;}
+ Int_t GetPedestalValue() const {return fgPedestalValue;}
+ Double_t GetFEENoise() const {return fgFEENoise;}
- Bool_t GetRemoveBadChannels() const {return fRemoveBadChannels;}
- Int_t GetFittingAlgorithm() const {return fFittingAlgorithm; }
- Bool_t UseFALTRO() const {return fUseFALTRO; }
+ Bool_t GetRemoveBadChannels() const {return fRemoveBadChannels;}
+ Int_t GetFittingAlgorithm() const {return fFittingAlgorithm; }
+ Bool_t UseFALTRO() const {return fUseFALTRO; }
void SetRawFormatHighLowGainFactor(Double_t val) {fHighLowGainFactor=val;}
void SetRawFormatOrder(Int_t val) {fOrder=val; }
// set methods for fast fit simulation
void SetFEENoise(Double_t val) {fgFEENoise = val;}
void SetRawFormatTimeBins(Int_t val) {fgTimeBins = val;}
- void SetPedestalValue(Int_t val) {fgPedestalValue = val;}
+ void SetPedestalValue(Int_t val) {fgPedestalValue = val;}
- static Int_t GetRawFormatTimeBins() { return fgTimeBins ; }
- static Double_t GetRawFormatTimeMax() { return fgTimeBins*fgTimeBinWidth; }
+ static Int_t GetRawFormatTimeBins() { return fgTimeBins ; }
+ static Double_t GetRawFormatTimeMax() { return fgTimeBins*fgTimeBinWidth; }
static Double_t GetRawFormatTimeBinWidth() { return fgTimeBinWidth; }
static Double_t GetRawFormatTimeBin()
{ return GetRawFormatTimeMax() / GetRawFormatTimeBins(); }
- Double_t GetRawFormatTimeTrigger() const { return fgTimeTrigger ; }
- Int_t GetRawFormatThreshold() const { return fgThreshold ; }
+ Double_t GetRawFormatTimeTrigger() const { return fgTimeTrigger ; }
+ Int_t GetRawFormatThreshold() const { return fgThreshold ; }
Int_t GetRawFormatDDLPerSuperModule() const { return fgDDLPerSuperModule ; }
- AliCaloRawAnalyzer *GetRawAnalyzer() const { return fRawAnalyzer;}
+ AliCaloRawAnalyzer *GetRawAnalyzer() const { return fRawAnalyzer;}
virtual Option_t* GetOption() const { return fOption.Data(); }
void SetOption(const Option_t* opt) { fOption = opt; }
fMinECut(0.45),
fUnfold(kFALSE),
fLocMaxCut(0.03),
- fTimeCut(1.),// high value, accept all//clustering
+ fTimeCut(1.),// high value, accept all
+ fTimeMin(-1.),// small value, accept all
+ fTimeMax(1.),// high value, accept all//clustering
fTrkCutX(6.0),
fTrkCutY(6.0),
fTrkCutZ(6.0),
fMinECut(rp.fMinECut),
fUnfold(rp.fUnfold),
fLocMaxCut(rp.fLocMaxCut),
- fTimeCut(rp.fTimeCut),//clustering
+ fTimeCut(rp.fTimeCut),
+ fTimeMin(rp.fTimeMin),
+ fTimeMax(rp.fTimeMax),//clustering
fTrkCutX(rp.fTrkCutX),
fTrkCutY(rp.fTrkCutY),
fTrkCutZ(rp.fTrkCutZ),
fMinECut = rp.fMinECut;
fUnfold = rp.fUnfold;
fLocMaxCut = rp.fLocMaxCut;
- fTimeCut = rp.fTimeCut;//clustering
+ fTimeCut = rp.fTimeCut;
+ fTimeMax = rp.fTimeMax;
+ fTimeMin = rp.fTimeMin;//clustering
fTrkCutX = rp.fTrkCutX;
fTrkCutY = rp.fTrkCutY;
fTrkCutZ = rp.fTrkCutZ;
// if nothing is specified print all, if "reco" just clusterization/track matching
// if "pid", just PID parameters, if "raw", just raw utils parameters.
if(!strcmp("",opt) || !strcmp("reco",opt)){
- AliInfo(Form("Clusterization parameters :\n fClusteringThreshold=%.3f,\n fW0=%.3f,\n fMinECut=%.3f,\n fUnfold=%d,\n fLocMaxCut=%.3f,\n fTimeCut=%f \n",
- fClusteringThreshold,fW0,fMinECut,fUnfold,fLocMaxCut,fTimeCut));
+ AliInfo(Form("Clusterization parameters :\n fClusteringThreshold=%.3f,\n fW0=%.3f,\n fMinECut=%.3f,\n fUnfold=%d,\n fLocMaxCut=%.3f,\n fTimeCut=%f \n fTimeMin=%f \n fTimeMax=%f \n",
+ fClusteringThreshold,fW0,fMinECut,fUnfold,fLocMaxCut,fTimeCut,fTimeMin,fTimeMax));
AliInfo(Form("Track-matching cuts :\n x %f, y %f, z %f, R %f \n alphaMin %f, alphaMax %f, Angle %f, NITS %f, NTPC %\n", fTrkCutX, fTrkCutY, fTrkCutZ, fTrkCutR,fTrkCutAlphaMin,fTrkCutAlphaMax, fTrkCutAngle,fTrkCutNITS,fTrkCutNTPC));
}
Float_t GetMinECut () const {return fMinECut ;}
Float_t GetLocMaxCut () const {return fLocMaxCut ;}
Float_t GetTimeCut () const {return fTimeCut ;}
+ Float_t GetTimeMin () const {return fTimeMin ;}
+ Float_t GetTimeMax () const {return fTimeMax ;}
Bool_t GetUnfold () const {return fUnfold ;}
+
void SetClusteringThreshold(Float_t thrsh) {fClusteringThreshold = thrsh;}
- void SetW0 (Float_t w0) {fW0 = w0 ;}
- void SetMinECut (Float_t minEcut) {fMinECut = minEcut ;}
+ void SetW0 (Float_t w0) {fW0 = w0 ;}
+ void SetMinECut (Float_t ecut) {fMinECut = ecut ;}
void SetLocMaxCut (Float_t locMaxCut) {fLocMaxCut = locMaxCut ;}
- void SetTimeCut (Float_t timeCut) {fTimeCut = timeCut ;}
+ void SetTimeCut (Float_t t) {fTimeCut = t ;}
+ void SetTimeMin (Float_t t) {fTimeMin = t ;}
+ void SetTimeMax (Float_t t) {fTimeMax = t ;}
void SetUnfold (Bool_t unfold) {fUnfold = unfold ; if(fUnfold) AliWarning("Cluster Unfolding ON. Implementing only for eta=0 case!!!");}
//PID (Guenole)
Float_t fMinECut; // Minimum energy for a digit to be a member of a cluster
Bool_t fUnfold; // Flag to perform cluster unfolding
Float_t fLocMaxCut; // Minimum energy difference to consider local maxima in a cluster
- Float_t fTimeCut ; // Maximum time of digits in EMC cluster
+ Float_t fTimeCut ; // Maximum time of digits with respect to EMC cluster max.
+ Float_t fTimeMin ; // Minimum time of digits
+ Float_t fTimeMax ; // Maximum time of digits
//PID (Guenole)
Double_t fGamma[6][6]; // Parameter to Compute PID for photons
static TObjArray* fgkMaps; // ALTRO mappings for RCU0..RCUX
- ClassDef(AliEMCALRecParam,10) // Reconstruction parameters
+ ClassDef(AliEMCALRecParam,11) // Reconstruction parameters
} ;
Float_t energy = 0;
for (Int_t idig = 0 ; idig < nDigits ; idig++) {
const AliEMCALDigit * dig = (const AliEMCALDigit*)digits->At(idig);
- if(dig->GetAmp() > 0 ){
- energy = (static_cast<AliEMCALClusterizerv1*> (fgClusterizer))->Calibrate(dig->GetAmp(),dig->GetId());
+ if(dig->GetAmplitude() > 0 ){
+ energy = (static_cast<AliEMCALClusterizerv1*> (fgClusterizer))->Calibrate(dig->GetAmplitude(),dig->GetTime(),dig->GetId()); //TimeR or Time?
if(energy > 0){ //Digits tagged as bad (dead, hot, not alive) are set to 0 in calibrate, remove them
emcCells.SetCell(idignew,dig->GetId(),energy, dig->GetTime());
idignew++;
// Assign primary number only if deposited energy is significant
curSDigit = new AliEMCALDigit( hit->GetPrimary(),
hit->GetIparent(), hit->GetId(),
- Digitize(energy), hit->GetTime(),
+ Digitize(energy), hit->GetTime(),kFALSE,
-1, energy ) ;
else
- curSDigit = new AliEMCALDigit( -1 ,
- -1 ,
+ curSDigit = new AliEMCALDigit( -1,
+ -1,
hit->GetId(),
- Digitize(energy), hit->GetTime(),
+ Digitize(energy), hit->GetTime(),kFALSE,
-1, energy ) ;
} else {
Warning("Exec"," abs id %i is bad \n", hit->GetId());
}
//__________________________________________________________________
-Int_t AliEMCALSDigitizer::Digitize(Float_t energy)const {
+Float_t AliEMCALSDigitizer::Digitize(Float_t energy)const {
// Digitize the energy
//
//JLK 26-Jun-2008 EXPLANATION LONG OVERDUE:
AliWarning(Form("Too big or too small energy %f",aSignal));
aSignal = TMath::Sign((Double_t)2147483647,aSignal);
}
- return (Int_t ) aSignal;
+
+ return (Float_t ) aSignal;
}
//__________________________________________________________________
-Float_t AliEMCALSDigitizer::Calibrate(Int_t amp)const {
+Float_t AliEMCALSDigitizer::Calibrate(Float_t amp)const {
//
// Convert the amplitude back to energy in GeV
//
//loop over digits
AliEMCALDigit * digit;
printf("\n Id Amplitude Time Index Nprim: Primaries list \n") ;
- Int_t index, isum=0;
+ Int_t index = 0;
+ Float_t isum = 0.;
char * tempo = new char[8192];
for (index = 0 ; index < sdigits->GetEntries() ; index++) {
digit = dynamic_cast<AliEMCALDigit *>( sdigits->At(index) ) ;
- sprintf(tempo, "\n%6d %8d %6.5e %4d %2d :",
- digit->GetId(), digit->GetAmp(), digit->GetTime(), digit->GetIndexInList(), digit->GetNprimary()) ;
+ sprintf(tempo, "\n%6d %8f %6.5e %4d %2d :",
+ digit->GetId(), digit->GetAmplitude(), digit->GetTime(), digit->GetIndexInList(), digit->GetNprimary()) ;
printf("%s",tempo);
- isum += digit->GetAmp();
+ isum += digit->GetAmplitude();
Int_t iprimary;
for (iprimary=0; iprimary<digit->GetNprimary(); iprimary++) {
}
}
delete tempo ;
- printf("\n** Sum %i : %10.3f GeV/c **\n ", isum, Calibrate(isum));
+ printf("\n** Sum %2.3f : %10.3f GeV/c **\n ", isum, Calibrate(isum));
} else printf("\n");
}
AliEMCALSDigitizer(const AliEMCALSDigitizer & sd) ;
virtual ~AliEMCALSDigitizer(); // dtor
- Int_t Digitize(Float_t energy)const; //convert energy in GeV to int amplitude
- Float_t Calibrate(Int_t amp)const; //opposite of Digitize()
+ Float_t Digitize(Float_t energy)const; //convert energy in GeV to int amplitude
+ Float_t Calibrate(Float_t amp)const; //opposite of Digitize()
virtual void Exec(Option_t *option);
Int_t GetSDigitsInRun() const {return fSDigitsInRun ;}
for(Int_t idig = 0 ; idig < digits->GetEntriesFast() ; idig++){
dig = dynamic_cast<AliEMCALDigit *>(digits->At(idig)) ;
- amp = Float_t(dig->GetAmp()); // Energy of the digit (arbitrary units)
+ amp = Float_t(dig->GetAmplitude()); // Energy of the digit (arbitrary units)
id = dig->GetId() ; // Id label of the cell
timeR = dig->GetTimeR() ; // Earliest time of the digit
if(amp<=0.0) AliDebug(1,Form(" id %i amp %f \n", id, amp));
params->SetMinECut(0.45);
params->SetUnfold(kFALSE);
params->SetLocMaxCut(0.03);
-
+ params->SetTimeCut(100e-9);//100 ns
+ //Simulation
+ params->SetTimeMin(5e-9);//100 ns
+ params->SetTimeMax(50e-9);//100 ns
+ //Real Data
+ //params->SetTimeMin(550e-9);//100 ns
+ //params->SetTimeMax(750e-9);//100 ns
+
//Track matching
params->SetTrkCutX(6.0);
params->SetTrkCutY(6.0);
if(dig != 0){
id = dig->GetId() ; //cell (digit) label
- amp = dig->GetAmp(); //amplitude in cell (digit)
+ amp = dig->GetAmplitude(); //amplitude in cell (digit)
time = dig->GetTime();//time of creation of digit after collision
cout<<"Cell ID "<<id<<" Amp "<<amp<<endl;//" time "<<time<<endl;