#include <AliCDBEntry.h>
#include <AliCDBManager.h>
#include <AliCDBId.h>
+#include <AliSplineFit.h>
#include "AliTPCcalibDB.h"
#include "AliTPCCalPad.h"
#include "AliTPCCalROC.h"
}
//check for nan
if ( !(noiseVal<10000000) ){
-// printf ("Warning: nan detected in (sec,row,pad - val): %02d,%02d,%03d - %.1f\n",isec,irow,ipad,noiseVal);
+ AliInfo(Form("Warning: nan detected in (sec,row,pad - val): %02d,%02d,%03d - %.1f\n",isec,irow,ipad,noiseVal));
++nNaN;
continue;
}
Double_t rmsSen=0;
if (c[i]>verySmall){
-// printf ("i: %d - m: %.3f, c: %.0f, r: %.3f\n",i,vNoiseMean[i],c[i],vNoiseRMS[i]);
+ AliInfo(Form("i: %d - m: %.3f, c: %.0f, r: %.3f\n",i,vNoiseMean[i],c[i],vNoiseRMS[i]));
mean=vNoiseMean[i]/c[i];
rms=vNoiseRMS[i];
rms=TMath::Sqrt(TMath::Abs(rms/c[i]-mean*mean));
for (UInt_t isec=0;isec<AliTPCCalPad::kNsec;++isec){
- printf("Sector %d\n", isec);
-
+ AliInfo(Form("Sector %d\n", isec));
AliTPCCalROC* occupancyROC = fDataQA->GetNoThreshold()->GetCalROC(isec);
AliTPCCalROC* nclusterROC = fDataQA->GetNLocalMaxima()->GetCalROC(isec);
AliTPCCalROC* qROC = fDataQA->GetMeanCharge()->GetCalROC(isec);
const UInt_t nchannels=occupancyROC->GetNchannels();
- printf("Nchannels %d\n", nchannels);
+ AliInfo(Form("Nchannels %d\n", nchannels));
for (UInt_t ichannel=0;ichannel<nchannels;++ichannel){
Float_t pt=ptROC->GetValue(irow,ipad);
// Float_t ptRef=ptRefROC->GetValue(irow,ipad);
//comparisons q
- Float_t deviation=TMath::Abs(pq/pqRef-1);
+ Float_t deviation=TMath::Abs(pqRef)>1e-20?TMath::Abs(pq/pqRef-1):-999;
for (Int_t i=0;i<npar;++i){
if (deviation>vThres[i])
++pulserQdeviations.GetMatrixArray()[i];
if (!fRefDataQA){
AliError(Form("Could not get object from entry '%s'\nPlease check!!!",entry->GetId().GetPath().Data()));
} else {
- fRefDataQA=(AliTPCdataQA*)fDataQA->Clone();
+ fRefDataQA=(AliTPCdataQA*)fRefDataQA->Clone();
}
delete entry;
}
if (!fCurrentRefMap) return -2;
TObjString *str=dynamic_cast<TObjString*>(fCurrentRefMap->GetValue(type));
if (!str) return -2;
- return (const Int_t)str->GetString().Atoi();
+ return (Int_t)str->GetString().Atoi();
}
//_____________________________________________________________________________________
Int_t AliTPCcalibDButil::GetReferenceRun(const char* type) const{
if (!fRefMap) return -1;
TObjString *str=dynamic_cast<TObjString*>(fRefMap->GetValue(type));
if (!str) return -1;
- return (const Int_t)str->GetString().Atoi();
+ return (Int_t)str->GetString().Atoi();
}
//_____________________________________________________________________________________
AliTPCCalPad *AliTPCcalibDButil::CreateCEOutlyerMap( Int_t & noutliersCE, AliTPCCalPad * const ceOut, Float_t minSignal, Float_t cutTrmsMin, Float_t cutTrmsMax, Float_t cutMaxDistT){
Double_t rmsMedian = fCETrms->GetMedian();
for (UInt_t iroc=0;iroc<fCETmean->kNsec;++iroc){
AliTPCCalROC *rocData=fCETmean->GetCalROC(iroc);
+ if (!rocData) continue;
if (fALTROMasked) rocMasked= fALTROMasked->GetCalROC(iroc);
AliTPCCalROC *rocOut = out->GetCalROC(iroc);
AliTPCCalROC *rocCEQ = fCEQmean->GetCalROC(iroc);
AliTPCCalROC *rocCETrms = fCETrms->GetCalROC(iroc);
Double_t trocMedian = rocData->GetMedian();
//
- if (!rocData) {
+ if (!rocData || !rocCEQ || !rocCETrms || !rocData) {
noutliersCE+=AliTPCROC::Instance()->GetNChannels(iroc);
rocOut->Add(1.);
continue;
Float_t valTmean=rocData->GetValue(ichannel);
Float_t valQmean=rocPulserQ->GetValue(ichannel);
Float_t valTrms =rocPulserTrms->GetValue(ichannel);
+ Float_t valMasked =0;
+ if (rocMasked) valMasked = rocMasked->GetValue(ichannel);
Int_t isOut=0;
+ if (valMasked>0.5) isOut=1;
if (TMath::Abs(valTmean-rocMedianT)>cutTime) isOut=1;
if (TMath::Abs(valQmean-rocMedianQ)>cutnRMSQ*rocRMSQ) isOut=1;
if (TMath::Abs(valTrms-rocMedianTrms)>cutnRMSrms*rocRMSTrms) isOut=1;
tdelta[nused]=ccosmic-claser;
nused++;
}
- if (nused<kMinPoints &&deltaT<kMaxPeriod) return AliTPCcalibDButil::GetTriggerOffsetTPC(run, timeStamp, deltaT*2,deltaTLaser);
+ if (nused<kMinPoints &&deltaT<kMaxPeriod) {
+ delete [] tdelta;
+ return AliTPCcalibDButil::GetTriggerOffsetTPC(run, timeStamp, deltaT*2,deltaTLaser);
+ }
if (nused<kMinPoints) {
- printf("AliFatal: No time offset calibration available\n");
+ delete [] tdelta;
+ //AliWarning("AliFatal: No time offset calibration available\n");
return 0;
}
Double_t median = TMath::Median(nused,tdelta);
if (!tmpRun) continue;
fRunsStart[irun]=tmpRun->GetStartTime().GetSec();
fRunsStop[irun]=tmpRun->GetEndTime().GetSec();
- // printf("irun\t%d\tRun\t%d\t%d\t%d\n",irun,fRuns[irun],tmpRun->GetStartTime().GetSec(),tmpRun->GetEndTime().GetSec());
+ //AliInfo(Form("irun\t%d\tRun\t%d\t%d\t%d\n",irun,fRuns[irun],tmpRun->GetStartTime().GetSec(),tmpRun->GetEndTime().GetSec()));
}}
return fRuns.fN;
}
for (Int_t index=index0; index<=index1; index++){
if (fRunsStart[index]<=itime && fRunsStop[index]>=itime) cindex=index;
if (debug) {
- printf("%d\t%d\t%d\n",fRuns[index], fRunsStart[index]-itime, fRunsStop[index]-itime);
+ AliInfo(Form("%d\t%d\t%d\n",fRuns[index], fRunsStart[index]-itime, fRunsStop[index]-itime));
}
}
if (cindex<0) cindex =(index0+index1)/2;
// Use constant interpolation outside of range
//
if (!graph) {
- printf("AliTPCcalibDButil::EvalGraphConst: 0 pointer\n");
+ AliInfoGeneral("AliTPCcalibDButil","AliTPCcalibDButil::EvalGraphConst: 0 pointer\n");
return 0;
}
if (graph->GetN()<1){
- printf("AliTPCcalibDButil::EvalGraphConst: Empty graph \n");
+ AliInfoGeneral("AliTPCcalibDButil","AliTPCcalibDButil::EvalGraphConst: Empty graph \n");
return 0;
}
if (xref<graph->GetX()[0]) return graph->GetY()[0];
if (xref>graph->GetX()[graph->GetN()-1]) return graph->GetY()[graph->GetN()-1];
- // printf("graph->Eval(graph->GetX()[0]) %f, graph->Eval(xref) %f \n",graph->Eval(graph->GetX()[0]), graph->Eval(xref));
+ // AliInfo(Form("graph->Eval(graph->GetX()[0]) %f, graph->Eval(xref) %f \n",graph->Eval(graph->GetX()[0]), graph->Eval(xref)));
if(graph->GetN()==1)
return graph->Eval(graph->GetX()[0]);
return graph->Eval(xref);
}
+Double_t AliTPCcalibDButil::EvalGraphConst(AliSplineFit *graph, Double_t xref){
+ //
+ // Use constant interpolation outside of range also for spline fits
+ //
+ if (!graph) {
+ AliInfoGeneral("AliTPCcalibDButil","AliTPCcalibDButil::EvalGraphConst: 0 pointer\n");
+ return 0;
+ }
+ if (graph->GetKnots()<1){
+ AliInfoGeneral("AliTPCcalibDButil","AliTPCcalibDButil::EvalGraphConst: Empty graph");
+ return 0;
+ }
+ if (xref<graph->GetX()[0]) return graph->GetY0()[0];
+ if (xref>graph->GetX()[graph->GetKnots()-1]) return graph->GetY0()[graph->GetKnots()-1];
+ return graph->Eval( xref);
+}
+
Float_t AliTPCcalibDButil::FilterSensor(AliDCSSensor * sensor, Double_t ymin, Double_t ymax, Double_t maxdy, Double_t sigmaCut){
//
// Filter DCS sensor information
for (Int_t isensor=0; isensor<nsensors; isensor++){
AliDCSSensor *sensor = tempArray->GetSensorNum(isensor);
if (!sensor) continue;
- //printf("%d\n",isensor);
FilterSensor(sensor,ymin,ymax,kMaxDy, sigmaCut);
if (sensor->GetFit()==0){
//delete sensor;
continue;
}
TGraph* graphTS= FilterGraphMedian(graphTS0,cutSigma,medianY);
+ if (!graphTS) continue;
graphTS->Sort();
AliTPCcalibDButil::SmoothGraph(graphTS,deltaT);
if (pcstream){
"\n";
}
delete graphTS0;
- if (!graphTS) continue;
arrT->AddAt(graphTS,i);
delete graph;
}
//if (index1-index0 <kMinPoints) { index1+=kMinPoints; index0-=kMinPoints;}
if (index0<0) index0=0;
if (index1>=npoints-1) index1=npoints-1;
- if (index1-index0<kMinPoints) return 0;
+ if (index1-index0<kMinPoints) {
+ delete [] ylaser;
+ delete [] xlaser;
+ return 0;
+ }
//
//Double_t median = TMath::Median(index1-index0, &(ylaser[index0]));
Double_t mean = TMath::Mean(index1-index0, &(ylaser[index0]));
AliTPCcalibDButil::SmoothGraph(graphNew2,deltaT);
AliTPCcalibDButil::SmoothGraph(graphNew2,deltaT);
AliTPCcalibDButil::SmoothGraph(graphNew2,deltaT);
- printf("%d\t%f\t%f\n",isensor, median,vrmsArray[isensor]);
+ // AliInfo(Form("%d\t%f\t%f\n",isensor, median,vrmsArray[isensor]));
vmedianArray[isensor]=median;
//
}
if (!kalman) continue;
if (TMath::Abs(kalman->GetTPCvdCorr()-1)>maxvd) continue;
if (kalman->GetNUpdates()<minStat) continue;
- if (kalman->GetNUpdates()/kalman->GetNTracks()<minFraction) continue;
+ if (Float_t(kalman->GetNUpdates())/Float_t(kalman->GetNTracks())<minFraction) continue;
kalman->GetState(state);
for (Int_t ipar=0; ipar<9; ipar++)
(*valArray[ipar])[naccept]=state[ipar];
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff