#include "AliMathBase.h"
#include "AliRelAlignerKalman.h"
+const Float_t kAlmost0=1.e-30;
+
ClassImp(AliTPCcalibDButil)
AliTPCcalibDButil::AliTPCcalibDButil() :
TObject(),
// Update pointers from calibDB
//
if (!fCalibDB) fCalibDB=AliTPCcalibDB::Instance();
+ fCalibDB->UpdateNonRec(); // load all infromation now
fPadNoise=fCalibDB->GetPadNoise();
fPedestals=fCalibDB->GetPedestals();
fPulserTmean=fCalibDB->GetPulserTmean();
fCalibRaw=fCalibDB->GetCalibRaw();
fDataQA=fCalibDB->GetDataQA();
UpdatePulserOutlierMap();
- SetReferenceRun();
- UpdateRefDataFromOCDB();
+// SetReferenceRun();
+// UpdateRefDataFromOCDB();
}
//_____________________________________________________________________________________
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;
}
//_____________________________________________________________________________________
void AliTPCcalibDButil::ProcessNoiseData(TVectorD &vNoiseMean, TVectorD &vNoiseMeanSenRegions,
TVectorD &vNoiseRMS, TVectorD &vNoiseRMSSenRegions,
- Int_t &nonMaskedZero)
+ Int_t &nonMaskedZero, Int_t &nNaN)
{
//
// process noise data
vNoiseRMS.Zero();
vNoiseRMSSenRegions.Zero();
nonMaskedZero=0;
+ nNaN=0;
//counters
TVectorD c(infoSize);
TVectorD cs(infoSize);
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;
}
//check for nan
if ( !(noiseVal<10000000) ){
- printf ("Warning: nan detected in (sec,row,pad - val): %02d,%02d,%03d - %.1f\n",isec,irow,ipad,noiseVal);
+// printf ("Warning: nan detected in (sec,row,pad - val): %02d,%02d,%03d - %.1f\n",isec,irow,ipad,noiseVal);
+ ++nNaN;
continue;
}
Int_t cpad=(Int_t)ipad-(Int_t)npads/2;
//don't use masked channels;
if (mROC ->GetValue(irow,ipad)) continue;
if (mRefROC->GetValue(irow,ipad)) continue;
+ if (nRefROC->GetValue(irow,ipad)==0) continue;
Float_t deviation=(nROC->GetValue(irow,ipad)/nRefROC->GetValue(irow,ipad))-1;
for (Int_t i=0;i<npar;++i){
if (deviation>vThres[i])
AliTPCCalROC *mROC=fALTROMasked->GetCalROC(isec);
AliTPCCalROC *mRefROC=fRefALTROMasked->GetCalROC(isec);
AliTPCCalROC *oROC=fPulserOutlier->GetCalROC(isec);
- Float_t pt_mean=ptROC->GetMean(oROC);
+ Float_t ptmean=ptROC->GetMean(oROC);
UInt_t nrows=mROC->GetNrows();
for (UInt_t irow=0;irow<nrows;++irow){
UInt_t npads=mROC->GetNPads(irow);
if (pqRef>11&&pq<11) ++npadsOffAdd;
varQMean+=pq-pqRef;
//comparisons t
- if (TMath::Abs(pt-pt_mean)>1) ++npadsOutOneTB;
+ if (TMath::Abs(pt-ptmean)>1) ++npadsOutOneTB;
++nActive;
}//end ipad
}//ind irow
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);
return padTime0;
}
//_____________________________________________________________________________________
-Float_t AliTPCcalibDButil::GetMeanAltro(const AliTPCCalROC *roc, const Int_t row, const Int_t pad, AliTPCCalROC *rocOut)
+Float_t AliTPCcalibDButil::GetMeanAltro(const AliTPCCalROC *roc, const Int_t row, const Int_t pad, AliTPCCalROC *const rocOut)
{
+ //
+ // GetMeanAlto information
+ //
if (roc==0) return 0.;
const Int_t sector=roc->GetSector();
AliTPCROC *tpcRoc=AliTPCROC::Instance();
return entry;
}
//_____________________________________________________________________________________
-const Int_t AliTPCcalibDButil::GetCurrentReferenceRun(const char* type){
+Int_t AliTPCcalibDButil::GetCurrentReferenceRun(const char* type) const {
//
// Get reference run number for the specified OCDB path
//
if (!fCurrentRefMap) return -2;
TObjString *str=dynamic_cast<TObjString*>(fCurrentRefMap->GetValue(type));
if (!str) return -2;
- return str->GetString().Atoi();
+ return (const Int_t)str->GetString().Atoi();
}
//_____________________________________________________________________________________
-const Int_t AliTPCcalibDButil::GetReferenceRun(const char* type) const{
+Int_t AliTPCcalibDButil::GetReferenceRun(const char* type) const{
//
// Get reference run number for the specified OCDB path
//
if (!fRefMap) return -1;
TObjString *str=dynamic_cast<TObjString*>(fRefMap->GetValue(type));
if (!str) return -1;
- return str->GetString().Atoi();
+ 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
//
//
//
const Float_t kLaserCut=0.0005;
- const Int_t kMaxPeriod=3600*24*30*3; // 3 month max
+ const Int_t kMaxPeriod=3600*24*30*12; // one year max
const Int_t kMinPoints=20;
//
TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
nused++;
}
if (nused<kMinPoints &&deltaT<kMaxPeriod) return AliTPCcalibDButil::GetTriggerOffsetTPC(run, timeStamp, deltaT*2,deltaTLaser);
+ if (nused<kMinPoints) {
+ printf("AliFatal: No time offset calibration available\n");
+ return 0;
+ }
Double_t median = TMath::Median(nused,tdelta);
Double_t mean = TMath::Mean(nused,tdelta);
delete tdelta;
Double_t vcosmic= AliTPCcalibDButil::EvalGraphConst(cosmicAll, timeStamp);
if (timeStamp>cosmicAll->GetX()[cosmicAll->GetN()-1]) vcosmic=cosmicAll->GetY()[cosmicAll->GetN()-1];
if (timeStamp<cosmicAll->GetX()[0]) vcosmic=cosmicAll->GetY()[0];
- return vcosmic+t0;
+ return vcosmic-t0;
/*
Example usage:
return corrM;
}
+Double_t AliTPCcalibDButil::GetVDriftTPCITS(Double_t &dist, Int_t run, Int_t timeStamp){
+ //
+ // return drift velocity using the TPC-ITS matchin method
+ // return also distance to the closest point
+ //
+ TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
+ TGraphErrors *graph=0;
+ dist=0;
+ if (!array) return 0;
+ graph = (TGraphErrors*)array->FindObject("ALIGN_ITSB_TPC_DRIFTVD");
+ if (!graph) return 0;
+ Double_t deltaY;
+ AliTPCcalibDButil::GetNearest(graph,timeStamp,dist,deltaY);
+ Double_t value = AliTPCcalibDButil::EvalGraphConst(graph,timeStamp);
+ return value;
+}
+
+Double_t AliTPCcalibDButil::GetTime0TPCITS(Double_t &dist, Int_t run, Int_t timeStamp){
+ //
+ // Get time dependent time 0 (trigger delay in cm) correction
+ // Arguments:
+ // timestamp - timestamp
+ // run - run number
+ //
+ // Notice - Extrapolation outside of calibration range - using constant function
+ //
+ TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
+ TGraphErrors *graph=0;
+ dist=0;
+ if (!array) return 0;
+ graph = (TGraphErrors*)array->FindObject("ALIGN_ITSM_TPC_T0");
+ if (!graph) return 0;
+ Double_t deltaY;
+ AliTPCcalibDButil::GetNearest(graph,timeStamp,dist,deltaY);
+ Double_t value = AliTPCcalibDButil::EvalGraphConst(graph,timeStamp);
+ return value;
+}
+
+
-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:
//
//
AliTPCSensorTempArray *tempMapCE = (AliTPCSensorTempArray *)cearray->FindObject("TempMap");
- AliDCSSensor * cavernPressureCE = (AliDCSSensor *) cearray->FindObject("CavernPressure");
+ AliDCSSensor * cavernPressureCE = (AliDCSSensor *) cearray->FindObject("CavernAtmosPressure");
if ( tempMapCE && cavernPressureCE){
//
- Bool_t isOK = FilterTemperature(tempMapCE)>0.1;
- FilterSensor(cavernPressureCE,960,1050,10, 5.);
- if (cavernPressureCE->GetFit()==0) isOK=kFALSE;
+ // Bool_t isOK = FilterTemperature(tempMapCE)>0.1;
+ // FilterSensor(cavernPressureCE,960,1050,10, 5.);
+ // if (cavernPressureCE->GetFit()==0) isOK=kFALSE;
+ Bool_t isOK=kTRUE;
if (isOK) {
// recalculate P/T correction map for time of the CE
AliTPCCalibVdrift * driftCalib = new AliTPCCalibVdrift(tempMapCE,cavernPressureCE ,0);
}
-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
Double_t medianY=0;
if (!arrT) return;
for (Int_t i=0; i<arrT->GetEntries();i++){
- TGraphErrors *graph= (TGraphErrors*)arrT->At(i);
+ TGraphErrors *graph= dynamic_cast<TGraphErrors*>(arrT->At(i));
if (!graph) continue;
if (graph->GetN()<kMinPoints){
delete graph;
-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:
// row - parameter type (rotation[3], translation[3], drift[3])
if (!array) return 0;
if (array->GetEntries()<=0) return 0;
- Int_t entries = array->GetEntries();
+ // Int_t entries = array->GetEntries();
Int_t entriesFast = array->GetEntriesFast();
TVectorD state(9);
TVectorD *valArray[9];
(*valArray[ipar])[naccept]=state[ipar];
naccept++;
}
+ if (naccept<2) return 0;
TMatrixD *pstat=new TMatrixD(9,3);
TMatrixD &stat=*pstat;
for (Int_t ipar=0; ipar<9; ipar++){
}
-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:
// sigmaCut - maximal allowed deviation from mean in terms of RMS
if (!array) return 0;
if (array->GetEntries()<=0) return 0;
- const Double_t errvd = 0.0001;
- const Double_t errt0 = 0.001;
- const Double_t errvy = 0.0001;
-
+ if (!(&stat)) return 0;
+ // error increase in 1 hour
+ const Double_t kerrsTime[9]={
+ 0.00001, 0.00001, 0.00001,
+ 0.001, 0.001, 0.001,
+ 0.0001, 0.001, 0.0001};
+ //
+ //
Int_t entries = array->GetEntriesFast();
TObjArray *sArray= new TObjArray(entries);
AliRelAlignerKalman * sKalman =0;
}
if (!sKalman) continue;
Double_t deltaT=TMath::Abs(Int_t(kalman->GetTimeStamp())-Int_t(sKalman->GetTimeStamp()))/3600.;
- (*(sKalman->GetStateCov()))(6,6)+=deltaT*errvd*errvd;
- (*(sKalman->GetStateCov()))(7,7)+=deltaT*errt0*errt0;
- (*(sKalman->GetStateCov()))(8,8)+=deltaT*errvy*errvy;
+ for (Int_t ipar=0; ipar<9; ipar++){
+// (*(sKalman->GetStateCov()))(6,6)+=deltaT*errvd*errvd;
+// (*(sKalman->GetStateCov()))(7,7)+=deltaT*errt0*errt0;
+// (*(sKalman->GetStateCov()))(8,8)+=deltaT*errvy*errvy;
+ (*(sKalman->GetStateCov()))(ipar,ipar)+=deltaT*kerrsTime[ipar]*kerrsTime[ipar];
+ }
sKalman->SetRunNumber(kalman->GetRunNumber());
if (!isOK) sKalman->SetRunNumber(0);
sArray->AddAt(new AliRelAlignerKalman(*sKalman),index);
return sArray;
}
+TObjArray *AliTPCcalibDButil::SmoothRelKalman(TObjArray * const arrayP, TObjArray * const arrayM){
+ //
+ // Merge 2 RelKalman arrays
+ // Input:
+ // arrayP - rel kalman in direction plus
+ // arrayM - rel kalman in direction minus
+ if (!arrayP) return 0;
+ if (arrayP->GetEntries()<=0) return 0;
+ if (!arrayM) return 0;
+ if (arrayM->GetEntries()<=0) return 0;
+ Int_t entries = arrayP->GetEntriesFast();
+ TObjArray *array = new TObjArray(arrayP->GetEntriesFast());
+ for (Int_t i=0; i<entries; i++){
+ AliRelAlignerKalman * kalmanP = (AliRelAlignerKalman *) arrayP->UncheckedAt(i);
+ AliRelAlignerKalman * kalmanM = (AliRelAlignerKalman *) arrayM->UncheckedAt(i);
+ if (!kalmanP) continue;
+ if (!kalmanM) continue;
+ AliRelAlignerKalman *kalman = new AliRelAlignerKalman(*kalmanP);
+ kalman->Merge(kalmanM);
+ array->AddAt(kalman,i);
+ }
+ return array;
+}