const double kTempCoeffP1Const = -0.023; //
const double kTempCoeffP1Factor = -4.966e5; //
+const double kTempMaxDiffMedian = 2; // Temperature values should not be further away from median value within SM when considered in the average calc.
+
const double kErrorCode = -999; // to indicate that something went wrong
using namespace std;
fMaxTemp(0),
fMinTempVariation(0),
fMaxTempVariation(0),
+ fMinTempValid(15),
+ fMaxTempValid(35),
fMinTime(0),
fMaxTime(0),
fTemperatureResolution(0.1), // 0.1 deg C is default
fMaxTemp(calibt.GetMaxTemp()),
fMinTempVariation(calibt.GetMinTempVariation()),
fMaxTempVariation(calibt.GetMaxTempVariation()),
+ fMinTempValid(calibt.GetMinTempValid()),
+ fMaxTempValid(calibt.GetMaxTempValid()),
fMinTime(calibt.GetMinTime()),
fMaxTime(calibt.GetMaxTime()),
fTemperatureResolution(calibt.GetTemperatureResolution()),
fMaxTemp = 0;
fMinTempVariation = 0;
fMaxTempVariation = 0;
+ fMinTempValid = 15;
+ fMaxTempValid = 35;
fMinTime = 0;
fMaxTime = 0;
fTemperatureResolution = 0.1; // 0.1 deg C is default
<< " GetMinTemp() " << GetMinTemp() << endl
<< " GetMaxTemp() " << GetMaxTemp() << endl
<< " GetMinTempVariation() " << GetMinTempVariation() << endl
- << " GetMaxTempVariation() " << GetMaxTempVariation() << endl;
+ << " GetMaxTempVariation() " << GetMaxTempVariation() << endl
+ << " GetTemperatureResolution() " << GetTemperatureResolution() << endl;
// run ranges
cout << " RUN INFO: " << endl
<< " runnumber " << GetRunNumber() << endl
// first convert from seconds to hours..
Double_t timeHour = (timeStamp - fStartTime) * kSecToHour;
- Double_t average = 0;
int n = 0;
+ Double_t valArr[8]={0}; // 8 sensors per SM
for (int i=0; i<fTempArray->NumSensors(); i++) {
if ( fVerbosity > 0 ) {
cout << " sensor i " << i << " val " << val << endl;
}
- average += val;
- n++;
+ if (val>fMinTempValid && val<fMaxTempValid && n<8) {
+ valArr[n] = val;
+ n++;
+ }
}
} // time
}
} // loop over fTempArray
if (n>0) { // some valid data was found
- average /= n;
- return average;
+ Double_t median = TMath::Median(n, valArr);
+ Double_t average = 0;
+ Int_t nval = 0;
+ for (int is=0; is<n; is++) {
+ if (TMath::Abs(valArr[is] - median) < kTempMaxDiffMedian) {
+ average += valArr[is];
+ nval++;
+ }
+ }
+ if (nval > 0) {
+ average /= nval;
+ return average;
+ }
+ else { // this case should not happen, but kept for completeness (coverity etc)
+ return median;
+ }
}
else { // no good data
return kErrorCode;
if (nBins == 1) {
binSize = fEndTime - fStartTime;
}
- if (fVerbosity > 1) {
+ if (fVerbosity > 0) {
cout << " nBins " << nBins << " binSize " << binSize << endl;
}
// min and max values within the single sensor
Double_t min = 999;
Double_t max = 0;
+ int nval = 0;
for (int ip=0; ip<np; ip++) {
- if (min > y0[ip]) { min = y0[ip]; }
- if (max < y0[ip]) { max = y0[ip]; }
+ if (y0[ip]>fMinTempValid && y0[ip]<fMaxTempValid) {
+ if (min > y0[ip]) { min = y0[ip]; }
+ if (max < y0[ip]) { max = y0[ip]; }
+ nval++;
+ }
+ }
+ if (nval>0) {
+ if (fMinTemp > min) { fMinTemp = min; }
+ if (fMaxTemp < max) { fMaxTemp = max; }
+ Double_t variation = max - min;
+ if (fMinTempVariation > variation) { fMinTempVariation = variation; }
+ if (fMaxTempVariation < variation) { fMaxTempVariation = variation; }
+
+ n++;
}
- if (fMinTemp > min) { fMinTemp = min; }
- if (fMaxTemp < max) { fMaxTemp = max; }
- Double_t variation = max - min;
- if (fMinTempVariation > variation) { fMinTempVariation = variation; }
- if (fMaxTempVariation < variation) { fMaxTempVariation = variation; }
-
- n++;
}
} // loop over fTempArray
Double_t GetMaxTemp() const { return fMaxTemp; } //
Double_t GetMinTempVariation() const { return fMinTempVariation; } //
Double_t GetMaxTempVariation() const { return fMaxTempVariation; } //
+ Double_t GetMinTempValid() const { return fMinTempValid; } //
+ Double_t GetMaxTempValid() const { return fMaxTempValid; } //
UInt_t GetMinTime() const { return fMinTime; } //
UInt_t GetMaxTime() const { return fMaxTime; } //
Double_t GetRangeOfTempMeasureInHours() const; //!
void SetStartTime(UInt_t ui) { fStartTime = ui; } //
void SetEndTime(UInt_t ui) { fEndTime = ui; } //
+ void SetMinTempValid(Double_t d) { fMinTempValid = d; } //
+ void SetMaxTempValid(Double_t d) { fMaxTempValid = d; } //
+
Int_t GetVerbosity() const { return fVerbosity; } // debug flag
void SetVerbosity(Int_t i) { fVerbosity= i; } // debug flag
Double_t fMaxTemp; // max temp
Double_t fMinTempVariation; // min temp variation, within a sensor
Double_t fMaxTempVariation; // max temp variation, within a sensor
+ Double_t fMinTempValid; // min limit for when temp. readings appear valid
+ Double_t fMaxTempValid; // max limit for when temp. readings appear valid
UInt_t fMinTime; // min time
UInt_t fMaxTime; // max time
//
Int_t fVerbosity; // debug flag
//
- ClassDef(AliEMCALCalibTimeDep,4) // EMCAL time-dep Calibration data
+ ClassDef(AliEMCALCalibTimeDep,5) // EMCAL time-dep Calibration data
};
#endif