#include "AliMathBase.h"
#include "AliRelAlignerKalman.h"
+const Float_t kAlmost0=1.e-30;
+
ClassImp(AliTPCcalibDButil)
AliTPCcalibDButil::AliTPCcalibDButil() :
TObject(),
}
//_____________________________________________________________________________________
void AliTPCcalibDButil::ProcessCEdata(const char* fitFormula, TVectorD &fitResultsA, TVectorD &fitResultsC,
- Int_t &noutliersCE, Double_t & chi2A, Double_t &chi2C, AliTPCCalPad *outCE)
+ Int_t &noutliersCE, Double_t & chi2A, Double_t &chi2C, AliTPCCalPad * const outCE)
{
//
// Process the CE data for this run
if (ipad==0||ipad==npads-1) rocOut->SetValue(irow,ipad,1);
Float_t valTmean=rocData->GetValue(irow,ipad);
//exclude values that are exactly 0
- if (valTmean==0) {
+ if ( !(TMath::Abs(valTmean)>kAlmost0) ) {
rocOut->SetValue(irow,ipad,1);
++noutliersCE;
}
if (rocMasked && rocMasked->GetValue(irow,ipad)) continue;
Float_t noiseVal=noiseROC->GetValue(irow,ipad);
//check if noise==0
- if (noiseVal==0) {
+ if (noiseVal<kAlmost0) {
++nonMaskedZero;
continue;
}
void AliTPCcalibDButil::UpdatePulserOutlierMap()
{
//
- //
+ // Update the outlier map of the pulser data
//
PulserOutlierMap(fPulserOutlier,fPulserTmean, fPulserQmean);
}
void AliTPCcalibDButil::UpdateRefPulserOutlierMap()
{
//
- //
+ // Update the outlier map of the pulser reference data
//
PulserOutlierMap(fRefPulserOutlier,fRefPulserTmean, fRefPulserQmean);
}
AliTPCCalROC *rocOut=fPulserOutlier->GetCalROC(isec);
Float_t mean=rocPulTmean->GetMean(rocOut);
//treat case where a whole partition is masked
- if (mean==0) mean=rocPulTmean->GetMean();
+ if ( TMath::Abs(mean)<kAlmost0 ) mean=rocPulTmean->GetMean();
if (model==1) {
Int_t type=isec/18;
mean=vMean[type];
//This should be the most precise guess in that case.
if (rocOut->GetValue(irow,ipad)) {
time=GetMeanAltro(rocPulTmean,irow,ipad,rocOut);
- if (time==0) time=mean;
+ if ( TMath::Abs(time)<kAlmost0 ) time=mean;
}
Float_t val=time-mean;
rocTime0->SetValue(irow,ipad,val);
rocTime0->GlobalFit(rocOutCE,kFALSE,vFitROC,mFitROC,chi2);
AliTPCCalROC *rocCEfit=AliTPCCalROC::CreateGlobalFitCalROC(vFitROC, isec);
Float_t mean=rocPulTmean->GetMean(rocOutPul);
- if (mean==0) mean=rocPulTmean->GetMean();
+ if ( TMath::Abs(mean)<kAlmost0 ) mean=rocPulTmean->GetMean();
UInt_t nrows=rocTime0->GetNrows();
for (UInt_t irow=0;irow<nrows;++irow){
UInt_t npads=rocTime0->GetNPads(irow);
//_____________________________________________________________________________________
Float_t AliTPCcalibDButil::GetMeanAltro(const AliTPCCalROC *roc, const Int_t row, const Int_t pad, AliTPCCalROC *rocOut)
{
+ //
+ // GetMeanAlto information
+ //
if (roc==0) return 0.;
const Int_t sector=roc->GetSector();
AliTPCROC *tpcRoc=AliTPCROC::Instance();
return (const Int_t)str->GetString().Atoi();
}
//_____________________________________________________________________________________
-AliTPCCalPad *AliTPCcalibDButil::CreateCEOutlyerMap( Int_t & noutliersCE, AliTPCCalPad *ceOut, Float_t minSignal, Float_t cutTrmsMin, Float_t cutTrmsMax, Float_t cutMaxDistT){
+AliTPCCalPad *AliTPCcalibDButil::CreateCEOutlyerMap( Int_t & noutliersCE, AliTPCCalPad * const ceOut, Float_t minSignal, Float_t cutTrmsMin, Float_t cutTrmsMax, Float_t cutMaxDistT){
//
// Author: marian.ivanov@cern.ch
//
//2. exclude edge pads
if (ipad==0||ipad==npads-1) rocOut->SetValue(irow,ipad,1);
//exclude values that are exactly 0
- if (valTmean==0) {
+ if ( TMath::Abs(valTmean)<kAlmost0) {
rocOut->SetValue(irow,ipad,1);
++noutliersCE;
}
}
-AliTPCCalPad *AliTPCcalibDButil::CreatePulserOutlyerMap(Int_t &noutliersPulser, AliTPCCalPad *pulserOut,Float_t cutTime, Float_t cutnRMSQ, Float_t cutnRMSrms){
+AliTPCCalPad *AliTPCcalibDButil::CreatePulserOutlyerMap(Int_t &noutliersPulser, AliTPCCalPad * const pulserOut,Float_t cutTime, Float_t cutnRMSQ, Float_t cutnRMSrms){
//
// Author: marian.ivanov@cern.ch
//
-TGraphErrors* AliTPCcalibDButil::FilterGraphMedianErr(TGraphErrors * graph, Float_t sigmaCut,Double_t &medianY){
+TGraphErrors* AliTPCcalibDButil::FilterGraphMedianErr(TGraphErrors * const graph, Float_t sigmaCut,Double_t &medianY){
//
// filter outlyer measurement
// Only points with normalized errors median +- sigmaCut filtered
delete[] outy;
}
-Double_t AliTPCcalibDButil::EvalGraphConst(TGraph *graph, Double_t xref){
+Double_t AliTPCcalibDButil::EvalGraphConst(TGraph * const graph, Double_t xref){
//
// Use constant interpolation outside of range
//
}
-void AliTPCcalibDButil::FilterCE(Double_t deltaT, Double_t cutAbs, Double_t cutSigma, TTreeSRedirector *pcstream){
+void AliTPCcalibDButil::FilterCE(Double_t deltaT, Double_t cutAbs, Double_t cutSigma, TTreeSRedirector * const pcstream){
//
// Filter CE data
// Input parameters:
}
-void AliTPCcalibDButil::FilterTracks(Int_t run, Double_t cutSigma, TTreeSRedirector *pcstream){
+void AliTPCcalibDButil::FilterTracks(Int_t run, Double_t cutSigma, TTreeSRedirector * const pcstream){
//
// Filter Drift velocity measurement using the tracks
// 0. remove outlyers - error based
-void AliTPCcalibDButil::FilterGoofie(AliDCSSensorArray * goofieArray, Double_t deltaT, Double_t cutSigma, Double_t minVd, Double_t maxVd, TTreeSRedirector *pcstream){
+void AliTPCcalibDButil::FilterGoofie(AliDCSSensorArray * goofieArray, Double_t deltaT, Double_t cutSigma, Double_t minVd, Double_t maxVd, TTreeSRedirector * const pcstream){
//
// Filter Goofie data
// goofieArray - points will be filtered
-TMatrixD* AliTPCcalibDButil::MakeStatRelKalman(TObjArray *array, Float_t minFraction, Int_t minStat, Float_t maxvd){
+TMatrixD* AliTPCcalibDButil::MakeStatRelKalman(TObjArray * const array, Float_t minFraction, Int_t minStat, Float_t maxvd){
//
// Make a statistic matrix
// Input parameters:
}
-TObjArray *AliTPCcalibDButil::SmoothRelKalman(TObjArray *array,TMatrixD & stat, Bool_t direction, Float_t sigmaCut){
+TObjArray *AliTPCcalibDButil::SmoothRelKalman(TObjArray * const array, const TMatrixD & stat, Bool_t direction, Float_t sigmaCut){
//
// Smooth the array of AliRelKalmanAlign - detector alignment and drift calibration)
// Input:
return sArray;
}
-TObjArray *AliTPCcalibDButil::SmoothRelKalman(TObjArray *arrayP, TObjArray *arrayM){
+TObjArray *AliTPCcalibDButil::SmoothRelKalman(TObjArray * const arrayP, TObjArray * const arrayM){
//
// Merge 2 RelKalman arrays
// Input:
-#ifndef AliTPCCALIBDBUTIL_H
-#define AliTPCCALIBDBUTIL_H
+#ifndef ALITPCCALIBDBUTIL_H
+#define ALITPCCALIBDBUTIL_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
class TGraphErrors;
class TTreeSRedirector;
class AliTPCCalROC;
+
+
class AliTPCcalibDButil : public TObject
{
public:
void UpdateFromCalibDB();
//data processing functions
void ProcessCEdata(const char* fitFormula, TVectorD &fitResultsA, TVectorD &fitResultsC,
- Int_t &noutliersCE, Double_t & chi2A, Double_t &chi2C, AliTPCCalPad *outCE=0);
+ Int_t &noutliersCE, Double_t & chi2A, Double_t &chi2C, AliTPCCalPad * const outCE=0);
void ProcessCEgraphs(TVectorD &vecTEntries, TVectorD &vecTMean, TVectorD &vecTRMS, TVectorD &vecTMedian,
TVectorD &vecQEntries, TVectorD &vecQMean, TVectorD &vecQRMS, TVectorD &vecQMedian,
Float_t &driftTimeA, Float_t &driftTimeC );
//getter preprocess information
Int_t GetNPulserOutliers() const {return fNpulserOutliers;}
- Float_t GetMeanAltro(const AliTPCCalROC *roc, const Int_t row, const Int_t pad, AliTPCCalROC *rocOut=0x0);
+ Float_t GetMeanAltro(const AliTPCCalROC *roc, const Int_t row, const Int_t pad, AliTPCCalROC * const rocOut=0x0);
AliTPCCalPad *GetPulserOutlierMap() const {return fPulserOutlier;}
//getters ref data
//setters for pad by pad information
- void SetPulserData(AliTPCCalPad *tmean, AliTPCCalPad *trms=0x0, AliTPCCalPad *qmean=0x0)
+ void SetPulserData(AliTPCCalPad * const tmean, AliTPCCalPad * const trms=0x0, AliTPCCalPad * const qmean=0x0)
{fPulserTmean=tmean; fPulserTrms=trms; fPulserQmean=qmean;}
void SetCEData(AliTPCCalPad *tmean, AliTPCCalPad *trms=0x0, AliTPCCalPad *qmean=0x0)
{fCETmean=tmean; fCETrms=trms; fCEQmean=qmean;}
//
// create outlyer maps
//
- AliTPCCalPad *CreateCEOutlyerMap(Int_t &noutliersCE, AliTPCCalPad *ceOut=0, Float_t minSignal=10, Float_t cutTrmsMin=0.9, Float_t cutTrmsMax=1.2, Float_t cutMaxDistT=0.7);
- AliTPCCalPad *CreatePulserOutlyerMap(Int_t &noutliersPulser, AliTPCCalPad *pulserOut=0, Float_t cutTime=3, Float_t cutnRMSQ=5, Float_t cutnRMSrms=5);
+ AliTPCCalPad *CreateCEOutlyerMap(Int_t &noutliersCE, AliTPCCalPad * const ceOut=0, Float_t minSignal=10, Float_t cutTrmsMin=0.9, Float_t cutTrmsMax=1.2, Float_t cutMaxDistT=0.7);
+ AliTPCCalPad *CreatePulserOutlyerMap(Int_t &noutliersPulser, AliTPCCalPad * const pulserOut=0, Float_t cutTime=3, Float_t cutnRMSQ=5, Float_t cutnRMSrms=5);
//
AliTPCCalPad *CreatePadTime0CE(TVectorD &fitResultsA, TVectorD&fitResultsC, Int_t &nOut, Double_t &chi2A, Double_t &chi2C, const char *dumpfile=0);
//
// graph tools
//
static Double_t GetLaserTime0(Int_t run, Int_t timeStamp, Int_t deltaT, Int_t side);
- static TGraph* FilterGraphMedian(TGraph * graph, Float_t sigmaCut, Double_t &medianY);
+ static TGraph* FilterGraphMedian(TGraph * const graph, Float_t sigmaCut, Double_t &medianY);
static TGraph* FilterGraphMedianAbs(TGraph * graph, Float_t cut, Double_t &medianY);
static TGraphErrors* FilterGraphMedianErr(TGraphErrors * graph, Float_t sigmaCut,Double_t &medianY);
//
static void Sort(TGraph *graph);
static void SmoothGraph(TGraph *graph, Double_t delta);
static Int_t GetNearest(TGraph *graph, Double_t xref, Double_t &dx, Double_t &y);
- static Double_t EvalGraphConst(TGraph *graph, Double_t xref);
+ static Double_t EvalGraphConst(TGraph * const graph, Double_t xref);
//
// Filter sensors
//
//
// Filter AliRelAlignmentKalman - Alignment/Drift velocity
//
- static TMatrixD* MakeStatRelKalman(TObjArray *array, Float_t minFraction, Int_t minStat, Float_t maxvd);
- static TObjArray *SmoothRelKalman(TObjArray *array,TMatrixD & stat, Bool_t direction, Float_t sigmaCut);
- static TObjArray *SmoothRelKalman(TObjArray *arrayP, TObjArray *arrayM);
- static void FilterCE(Double_t deltaT=100, Double_t cutAbs=10, Double_t cutSigma=4., TTreeSRedirector *pcstream=0);
- static void FilterTracks(Int_t run, Double_t cutSigma=20., TTreeSRedirector *pcstream=0);
+ static TMatrixD* MakeStatRelKalman(TObjArray * const array, Float_t minFraction, Int_t minStat, Float_t maxvd);
+ static TObjArray *SmoothRelKalman(TObjArray * const array,const TMatrixD & stat, Bool_t direction, Float_t sigmaCut);
+ static TObjArray *SmoothRelKalman(TObjArray * const arrayP, TObjArray * const arrayM);
+ static void FilterCE(Double_t deltaT=100, Double_t cutAbs=10, Double_t cutSigma=4., TTreeSRedirector * const pcstream=0);
+ static void FilterTracks(Int_t run, Double_t cutSigma=20., TTreeSRedirector * const pcstream=0);
static Float_t FilterTemperature(AliTPCSensorTempArray *tempArray, Double_t ymin=15, Double_t ymax=22, Double_t sigmaCut=5);
- static void FilterGoofie(AliDCSSensorArray * goofieArray, Double_t deltaT=2, Double_t cutSigma=4., Double_t minVdn=8.5, Double_t maxVdn=9.05, TTreeSRedirector *pcstream=0);
+ static void FilterGoofie(AliDCSSensorArray * goofieArray, Double_t deltaT=2, Double_t cutSigma=4., Double_t minVdn=8.5, Double_t maxVdn=9.05, TTreeSRedirector * const pcstream=0);
static Double_t GetTriggerOffsetTPC(Int_t run, Int_t timeStamp, Double_t deltaT=86400, Double_t deltaTLaser=3600, Int_t valType=0);
static Double_t GetVDriftTPC(Double_t &dist, Int_t run, Int_t timeStamp, Double_t deltaT=86400, Double_t deltaTLaser=3600, Int_t valType=0);
static Double_t GetVDriftTPCLaserTracks(Double_t &dist,Int_t run, Int_t timeStamp, Double_t deltaT=43200, Int_t side=2);
//
// filters
-public:
TArrayI fRuns; // run list with OCDB info
TArrayI fRunsStart; // start time for given run
TArrayI fRunsStop; // stop time for given run
-private:
+
AliTPCcalibDButil (const AliTPCcalibDButil& );
AliTPCcalibDButil& operator= (const AliTPCcalibDButil& );