ClassImp(AliEMCALRawUtils)
// Signal shape parameters
-Int_t AliEMCALRawUtils::fgOrder = 2 ; // Order of gamma function
Double_t AliEMCALRawUtils::fgTimeBinWidth = 100E-9 ; // each sample is 100 ns
-Double_t AliEMCALRawUtils::fgTau = 235E-9 ; // 235 ns (from CERN testbeam; not very accurate)
Double_t AliEMCALRawUtils::fgTimeTrigger = 1.5E-6 ; // 15 time bins ~ 1.5 musec
// some digitization constants
Int_t AliEMCALRawUtils::fgDDLPerSuperModule = 2; // 2 ddls per SuperModule
AliEMCALRawUtils::AliEMCALRawUtils()
- : fHighLowGainFactor(0.), fGeom(0),
- fOption("")
+ : fHighLowGainFactor(0.), fOrder(0), fTau(0.), fNoiseThreshold(0),
+ fNPedSamples(0), fGeom(0), fOption("")
{
+
+ //These are default parameters.
+ //Can be re-set from without with setter functions
fHighLowGainFactor = 16. ; // adjusted for a low gain range of 82 GeV (10 bits)
+ fOrder = 2; // order of gamma fn
+ fTau = 2.35; // in units of timebin, from CERN 2007 testbeam
+ fNoiseThreshold = 3;
+ fNPedSamples = 5;
//Get Mapping RCU files from the AliEMCALRecParam
const TObjArray* maps = AliEMCALRecParam::GetMappings();
fMapping[i] = (AliAltroMapping*)maps->At(i);
}
-
fGeom = AliEMCALGeometry::GetInstance();
if(!fGeom) {
fGeom = AliEMCALGeometry::GetInstance("","");
AliEMCALRawUtils::AliEMCALRawUtils(const AliEMCALRawUtils& rawU)
: TObject(),
fHighLowGainFactor(rawU.fHighLowGainFactor),
+ fOrder(rawU.fOrder),
+ fTau(rawU.fTau),
+ fNoiseThreshold(rawU.fNoiseThreshold),
+ fNPedSamples(rawU.fNPedSamples),
fGeom(rawU.fGeom),
fOption(rawU.fOption)
{
if(this != &rawU) {
fHighLowGainFactor = rawU.fHighLowGainFactor;
+ fOrder = rawU.fOrder;
+ fTau = rawU.fTau;
+ fNoiseThreshold = rawU.fNoiseThreshold;
+ fNPedSamples = rawU.fNPedSamples;
fGeom = rawU.fGeom;
fOption = rawU.fOption;
fMapping[0] = rawU.fMapping[0];
//given raw signal being fit
TF1 * signalF = new TF1("signal", RawResponseFunction, 0, GetRawFormatTimeBins(), 5);
- signalF->SetParameters(10.,0.,2.35,2.,5.); //set all defaults once, just to be safe
+ signalF->SetParameters(10.,0.,fTau,fOrder,5.); //set all defaults once, just to be safe
signalF->SetParNames("amp","t0","tau","N","ped");
- signalF->SetParameter(2,2.35); // tau in units of time bin
+ signalF->SetParameter(2,fTau); // tau in units of time bin
signalF->SetParLimits(2,2,-1);
- signalF->SetParameter(3,2); // order
+ signalF->SetParameter(3,fOrder); // order
signalF->SetParLimits(3,2,-1);
Int_t id = -1;
gSig->SetPoint(index, index, 0) ;
}
// Reset starting parameters for fit function
- signalF->SetParameters(10.,0.,2.35,2.,5.); //reset all defaults just to be safe
+ signalF->SetParameters(10.,0.,fTau,fOrder,5.); //reset all defaults just to be safe
}; // EMCAL entries loop
new((*digitsArr)[idigit]) AliEMCALDigit( -1, -1, id, amp, time, idigit) ;
}
else { // a digit already exists, check range
- // (use high gain if signal < 800, otherwise low gain)
+ // (use high gain if signal < cut value, otherwise low gain)
if (lowGain) { // new digit is low gain
- if (digit->GetAmp() > 800) { // use if stored digit is out of range
+ if (digit->GetAmp() > fgkOverflowCut) { // use if stored digit is out of range
digit->SetAmp(Int_t(fHighLowGainFactor * amp));
digit->SetTime(time);
}
}
- else if (amp < 800) { // new digit is high gain; use if not out of range
+ else if (amp < fgkOverflowCut) { // new digit is high gain; use if not out of range
digit->SetAmp(amp);
digit->SetTime(time);
}
{
// Fits the raw signal time distribution; from AliEMCALGetter
- const Int_t kNoiseThreshold = 5;
- const Int_t kNPedSamples = 5;
amp = time = 0. ;
Double_t ped = 0;
Int_t nPed = 0;
- for (Int_t index = 0; index < kNPedSamples; index++) {
+ for (Int_t index = 0; index < fNPedSamples; index++) {
Double_t ttime, signal;
gSig->GetPoint(index, ttime, signal) ;
if (signal > 0) {
Int_t tmin_after_sig = gSig->GetN();
Int_t n_ped_after_sig = 0;
- for (Int_t i=kNPedSamples; i < gSig->GetN(); i++) {
+ for (Int_t i=fNPedSamples; i < gSig->GetN(); i++) {
Double_t ttime, signal;
gSig->GetPoint(i, ttime, signal) ;
if (!max_found && signal > max) {
i_max = i;
max = signal;
}
- else if ( max > ped + kNoiseThreshold ) {
+ else if ( max > ped + fNoiseThreshold ) {
max_found = 1;
min_after_sig = signal;
tmin_after_sig = i;
max_fit = tmin_after_sig;
break;
}
- if ( signal < ped + kNoiseThreshold)
+ if ( signal < ped + fNoiseThreshold)
n_ped_after_sig++;
if (n_ped_after_sig >= 5) { // include 5 pedestal bins after peak
max_fit = i;
}
}
- if ( max - ped > kNoiseThreshold ) { // else its noise
+ if ( max - ped > fNoiseThreshold ) { // else its noise
AliDebug(2,Form("Fitting max %d ped %d", max, ped));
signalF->SetRange(0,max_fit);
// for a start time dtime and an amplitude damp given by digit,
// calculates the raw sampled response AliEMCAL::RawResponseFunction
- const Int_t kRawSignalOverflow = 0x3FF ;
const Int_t pedVal = 32;
Bool_t lowGain = kFALSE ;
TF1 signalF("signal", RawResponseFunction, 0, GetRawFormatTimeMax(), 5);
signalF.SetParameter(0, damp) ;
signalF.SetParameter(1, dtime + fgTimeTrigger) ;
- signalF.SetParameter(2, fgTau) ;
- signalF.SetParameter(3, fgOrder);
+ signalF.SetParameter(2, fTau) ;
+ signalF.SetParameter(3, fOrder);
signalF.SetParameter(4, pedVal);
for (Int_t iTime = 0; iTime < GetRawFormatTimeBins(); iTime++) {
Double_t time = iTime * GetRawFormatTimeBinWidth() ;
Double_t signal = signalF.Eval(time) ;
adcH[iTime] = static_cast<Int_t>(signal + 0.5) ;
- if ( adcH[iTime] > kRawSignalOverflow ){ // larger than 10 bits
- adcH[iTime] = kRawSignalOverflow ;
+ if ( adcH[iTime] > fgkRawSignalOverflow ){ // larger than 10 bits
+ adcH[iTime] = fgkRawSignalOverflow ;
lowGain = kTRUE ;
}
signal /= fHighLowGainFactor;
adcL[iTime] = static_cast<Int_t>(signal + 0.5) ;
- if ( adcL[iTime] > kRawSignalOverflow) // larger than 10 bits
- adcL[iTime] = kRawSignalOverflow ;
+ if ( adcL[iTime] > fgkRawSignalOverflow) // larger than 10 bits
+ adcL[iTime] = fgkRawSignalOverflow ;
}
return lowGain ;
}
void AddDigit(TClonesArray *digitsArr, Int_t id, Int_t lowGain, Int_t amp, Float_t time);
// Signal shape parameters
- Double_t GetRawFormatHighLowGainFactor() const {return fHighLowGainFactor ;}
- static Int_t GetRawFormatOrder() { return fgOrder ; }
+ Double_t GetRawFormatHighLowGainFactor() const { return fHighLowGainFactor ;}
+ Int_t GetRawFormatOrder() const { return fOrder ; }
+ Double_t GetRawFormatTau() const { return fTau ; }
+ Int_t GetNoiseThreshold() const { return fNoiseThreshold; }
+ Int_t GetNPedSamples() const { return fNPedSamples; }
+
+ void SetRawFormatHighLowGainFactor(Double_t val) {fHighLowGainFactor=val;}
+ void SetRawFormatOrder(Int_t val) {fOrder=val; }
+ void SetRawFormatTau(Double_t val) {fTau=val; }
+ void SetNoiseThreshold(Int_t val) {fNoiseThreshold=val; }
+ void SetNPedSamples(Int_t val) {fNPedSamples=val; }
+
static Int_t GetRawFormatTimeBins() { return fgkTimeBins ; }
static Double_t GetRawFormatTimeMax() { return fgkTimeBins*fgTimeBinWidth; }
static Double_t GetRawFormatTimeBinWidth() { return fgTimeBinWidth; }
- Double_t GetRawFormatTau() const { return fgTau ; }
Double_t GetRawFormatTimeTrigger() const { return fgTimeTrigger ; }
Int_t GetRawFormatThreshold() const { return fgThreshold ; }
Int_t GetRawFormatDDLPerSuperModule() const { return fgDDLPerSuperModule ; }
static Double_t RawResponseFunction(Double_t *x, Double_t *par);
Bool_t RawSampledResponse(Double_t dtime, Double_t damp, Int_t * adcH, Int_t * adcL) const;
- ClassDef(AliEMCALRawUtils,1)
private:
Double_t fHighLowGainFactor ; // high to low gain factor for the raw RO signal
- static Int_t fgOrder ; // order of the gamma function for the RO signal
- static Double_t fgTau ; // tau parameter of gamma function for the RO signal
- static Double_t fgTimeTrigger ; // time of the trigger for the RO signal
+ Int_t fOrder ; // order of the gamma function for the RO signal
+ Double_t fTau ; // tau parameter of gamma function for the RO signal
+ Int_t fNoiseThreshold; // threshold to consider signal or noise
+ Int_t fNPedSamples; // number of samples to use in pedestal calculation
+ static const Int_t fgkOverflowCut = 950; // cut to discriminate overflowed channels
static const Int_t fgkTimeBins = 256 ; // number of sampling bins of the raw RO signal
+ static const Int_t fgkRawSignalOverflow = 0x3FF; // maximum signal (10 bits)
+
+ static Double_t fgTimeTrigger ; // time of the trigger for the RO signal
static Double_t fgTimeBinWidth; // maximum sampled time of the raw RO signal
static Int_t fgThreshold; // threshold
static Int_t fgDDLPerSuperModule; // number of DDL per SuperModule
AliAltroMapping* fMapping[2]; //only two for now
TString fOption; //! option passed from Reconstructor
+
+ ClassDef(AliEMCALRawUtils,2) // utilities for raw signal fitting
};
#endif
//-----------------------------------------------------------------------------
// Container of EMCAL reconstruction parameters
// The purpose of this object is to store it to OCDB
-// and retrieve it in AliEMCALClusterizerv1, AliEMCALPID and AliEMCALTracker
+// and retrieve it in AliEMCALClusterizerv1, AliEMCALPID,
+// AliEMCALTracker and use it to configure AliEMCALRawUtils
+//
+//
// Author: Yuri Kharlov
//-----------------------------------------------------------------------------
Double_t GetTrkCutAlphaMax() const {return fTrkCutAlphaMax;}
Double_t GetTrkCutAngle() const {return fTrkCutAngle;}
+ //Raw signal fitting (Jenn)
+ /* raw signal setters */
+ void SetHighLowGainFactor(Double_t value) {fHighLowGainFactor = value;}
+ void SetOrderParameter(Int_t value) {fOrderParameter = value;}
+ void SetTau(Double_t value) {fTau = value;}
+ void SetNoiseThreshold(Int_t value) {fNoiseThreshold = value;}
+ void SetNPedSamples(Int_t value) {fNPedSamples = value;}
+ /* raw signal getters */
+ Double_t GetHighLowGainFactor() const {return fHighLowGainFactor;}
+ Int_t GetOrderParameter() const {return fOrderParameter;}
+ Double_t GetTau() const {return fTau;}
+ Int_t GetNoiseThreshold() const {return fNoiseThreshold;}
+ Int_t GetNPedSamples() const {return fNPedSamples;}
+
virtual void Print(Option_t * option="") const ;
static const TObjArray* GetMappings();
Double_t fTrkCutAlphaMax; // cut on 'alpha' parameter for track matching (min)
Double_t fTrkCutAngle; // cut on relative angle between different track points for track matching
+ //Raw signal fitting parameters (Jenn)
+ Double_t fHighLowGainFactor; //gain factor to convert between high and low gain
+ Int_t fOrderParameter; //order parameter for raw signal fit
+ Double_t fTau; //decay constant for raw signal fit
+ Int_t fNoiseThreshold; //threshold to consider signal or noise
+ Int_t fNPedSamples; //number of time samples to use in pedestal calculation
+
static TObjArray* fgkMaps; // ALTRO mappings for RCU0..RCUX
- ClassDef(AliEMCALRecParam,3) // Reconstruction parameters
+ ClassDef(AliEMCALRecParam,4) // Reconstruction parameters
} ;