#include <AliCDBEntry.h>
#include <AliCDBManager.h>
#include <AliCDBId.h>
+#include <AliSplineFit.h>
#include "AliTPCcalibDB.h"
#include "AliTPCCalPad.h"
#include "AliTPCCalROC.h"
// Update pointers from calibDB
//
if (!fCalibDB) fCalibDB=AliTPCcalibDB::Instance();
+ fCalibDB->UpdateNonRec(); // load all infromation now
fPadNoise=fCalibDB->GetPadNoise();
fPedestals=fCalibDB->GetPedestals();
fPulserTmean=fCalibDB->GetPulserTmean();
}
//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));
}
}
+//_____________________________________________________________________________________
+void AliTPCcalibDButil::ProcessQAData(TVectorD &vQaOcc, TVectorD &vQaQtot,
+ TVectorD &vQaQmax)
+{
+ //
+ // process QA data
+ //
+ // vQaOcc/Qtot/Qmax contains the Mean occupancy/Qtot/Qmax for each sector
+ //
+
+
+ const UInt_t infoSize = 72;
+ //reset counters to error number
+ vQaOcc.ResizeTo(infoSize);
+ vQaOcc.Zero();
+ vQaQtot.ResizeTo(infoSize);
+ vQaQtot.Zero();
+ vQaQmax.ResizeTo(infoSize);
+ vQaQmax.Zero();
+ //counter
+ //retrieve pulser and ALTRO data
+
+ if (!fDataQA) {
+
+ AliInfo("No QA data");
+ return;
+ }
+ if (fDataQA->GetEventCounter()<=0) {
+
+ AliInfo("No QA data");
+ return; // no data processed
+ }
+ //
+ fDataQA->Analyse();
+
+ TVectorD normOcc(infoSize);
+ TVectorD normQ(infoSize);
+
+ for (UInt_t isec=0;isec<AliTPCCalPad::kNsec;++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);
+ AliTPCCalROC* qmaxROC = fDataQA->GetMaxCharge()->GetCalROC(isec);
+ if (!occupancyROC) continue;
+ if (!nclusterROC) continue;
+ if (!qROC) continue;
+ if (!qmaxROC) continue;
+
+ const UInt_t nchannels=occupancyROC->GetNchannels();
+
+ AliInfo(Form("Nchannels %d\n", nchannels));
+
+ for (UInt_t ichannel=0;ichannel<nchannels;++ichannel){
+
+ vQaOcc[isec] += occupancyROC->GetValue(ichannel);
+ ++normOcc[isec];
+
+ Float_t nClusters = nclusterROC->GetValue(ichannel);
+ normQ[isec] += nClusters;
+ vQaQtot[isec]+=nClusters*qROC->GetValue(ichannel);
+ vQaQmax[isec]+=nClusters*qmaxROC->GetValue(ichannel);
+ }
+ }
+
+ //calculate mean values
+ for (UInt_t isec=0;isec<AliTPCCalPad::kNsec;++isec){
+
+ if (normOcc[isec]>0) vQaOcc[isec] /= normOcc[isec];
+ else vQaOcc[isec] = 0;
+
+ if (normQ[isec]>0) {
+ vQaQtot[isec] /= normQ[isec];
+ vQaQmax[isec] /= normQ[isec];
+ }else {
+
+ vQaQtot[isec] = 0;
+ vQaQmax[isec] = 0;
+ }
+ }
+}
+
//_____________________________________________________________________________________
void AliTPCcalibDButil::ProcessPulser(TVectorD &vMeanTime)
{
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];
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
entry=GetRefEntry(cdbPath.Data());
if (entry){
entry->SetOwner(kTRUE);
- fDataQA=dynamic_cast<AliTPCdataQA*>(entry->GetObject());
- if (!fDataQA){
+ f
RefDataQA=dynamic_cast<AliTPCdataQA*>(entry->GetObject());
+ 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;
}
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 (const Int_t)str->GetString().Atoi();
+ return (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 (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;
//
// find the closest point to xref in x direction
// return dx and value
+ dx = 0;
+ y = 0;
+
+ if(!graph) return 0;
+ if(graph->GetN() < 1) return 0;
+
Int_t index=0;
index = TMath::BinarySearch(graph->GetN(), graph->GetX(),xref);
if (index<0) index=0;
- if (index>=graph->GetN()-1) index=graph->GetN()-2;
- if (xref-graph->GetX()[index]>graph->GetX()[index]-xref) index++;
- dx = xref-graph->GetX()[index];
+ if(graph->GetN()==1) {
+ dx = xref-graph->GetX()[index];
+ }
+ else {
+ if (index>=graph->GetN()-1) index=graph->GetN()-2;
+ if (xref-graph->GetX()[index]>graph->GetX()[index]-xref) index++;
+ dx = xref-graph->GetX()[index];
+ }
y = graph->GetY()[index];
return index;
}
-
Double_t AliTPCcalibDButil::GetTriggerOffsetTPC(Int_t run, Int_t timeStamp, Double_t deltaT, Double_t deltaTLaser, Int_t valType){
//
// Get the correction of the trigger offset
//
//
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);
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) {
+ delete [] tdelta;
+ //AliWarning("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;
+ delete [] tdelta;
return (valType==0) ? median:mean;
}
AliTPCcalibDButil::GetNearest(cosmicAll,timeStamp,dist,grY);
Double_t t0= AliTPCcalibDButil::GetTriggerOffsetTPC(run,timeStamp, deltaT, deltaTLaser,valType);
- Double_t vcosmic= AliTPCcalibDButil::EvalGraphConst(cosmicAll, timeStamp);
+ 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;
Double_t AliTPCcalibDButil::GetVDriftTPCLaserTracks(Double_t &dist, Int_t run, Int_t timeStamp, Double_t deltaT, Int_t side){
//
- // Get the correction of the drift velocity using the laser tracks calbration
+ // Get the correction of the drift velocity using the offline laser tracks calbration
//
// run - run number
// timeStamp - tim stamp in seconds
// side - 0 - A side, 1 - C side, 2 - mean from both sides
// Note in case no data form both A and C side - the value from active side used
TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
+
+ return GetVDriftTPCLaserTracksCommon(dist, timeStamp, deltaT, side, array);
+}
+
+Double_t AliTPCcalibDButil::GetVDriftTPCLaserTracksOnline(Double_t &dist, Int_t /*run*/, Int_t timeStamp, Double_t deltaT, Int_t side){
+ //
+ // Get the correction of the drift velocity using the online laser tracks calbration
+ //
+ // run - run number
+ // timeStamp - tim stamp in seconds
+ // deltaT - integration period to calculate time0 offset
+ // side - 0 - A side, 1 - C side, 2 - mean from both sides
+ // Note in case no data form both A and C side - the value from active side used
+ TObjArray *array =AliTPCcalibDB::Instance()->GetCEfitsDrift();
+
+ Double_t dv = GetVDriftTPCLaserTracksCommon(dist, timeStamp, deltaT, side, array);
+ AliTPCParam *param =AliTPCcalibDB::Instance()->GetParameters();
+ if (!param) return 0;
+
+ //the drift velocity is hard wired in the AliTPCCalibCE class, since online there is no access to OCDB
+ dv*=param->GetDriftV()/2.61301900000000000e+06;
+ if (dv>1e-20) dv=1/dv-1;
+ else return 0;
+ // T/P correction
+ TObjArray* cearray =AliTPCcalibDB::Instance()->GetCEData();
+
+ AliTPCSensorTempArray *temp = (AliTPCSensorTempArray*)cearray->FindObject("TempMap");
+ AliDCSSensor *press = (AliDCSSensor*)cearray->FindObject("CavernAtmosPressure");
+
+ Double_t corrPTA=0;
+ Double_t corrPTC=0;
+
+ if (temp&&press) {
+ AliTPCCalibVdrift corr(temp,press,0);
+ corrPTA=corr.GetPTRelative(timeStamp,0);
+ corrPTC=corr.GetPTRelative(timeStamp,1);
+ }
+
+ if (side==0) dv -= corrPTA;
+ if (side==1) dv -= corrPTC;
+ if (side==2) dv -= (corrPTA+corrPTC)/2;
+
+ return dv;
+}
+
+Double_t AliTPCcalibDButil::GetVDriftTPCLaserTracksCommon(Double_t &dist, Int_t timeStamp, Double_t deltaT,
+ Int_t side, TObjArray * const array){
+ //
+ // common drift velocity retrieval for online and offline method
+ //
TGraphErrors *grlaserA=0;
TGraphErrors *grlaserC=0;
Double_t vlaserA=0, vlaserC=0;
grlaserA=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_A");
grlaserC=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_C");
Double_t deltaY;
- if (grlaserA) {
+ if (grlaserA && grlaserA->GetN()>0) {
AliTPCcalibDButil::GetNearest(grlaserA,timeStamp,dist,deltaY);
if (TMath::Abs(dist)>deltaT) vlaserA= deltaY;
else vlaserA = AliTPCcalibDButil::EvalGraphConst(grlaserA,timeStamp);
}
- if (grlaserC) {
+ if (grlaserC && grlaserC->GetN()>0) {
AliTPCcalibDButil::GetNearest(grlaserC,timeStamp,dist,deltaY);
if (TMath::Abs(dist)>deltaT) vlaserC= deltaY;
else vlaserC = AliTPCcalibDButil::EvalGraphConst(grlaserC,timeStamp);
Double_t gry=0;
Double_t corrA=0, corrC=0;
Double_t timeA=0, timeC=0;
+ const Double_t kEpsilon = 0.00001;
TGraph *graphA = (TGraph*)arrT->At(72);
TGraph *graphC = (TGraph*)arrT->At(73);
if (!graphA && !graphC) return 0.;
timeA = AliTPCcalibDButil::EvalGraphConst(graphA,timeStamp);
Int_t mtime =TMath::Nint((graphA->GetX()[0]+graphA->GetX()[graphA->GetN()-1])*0.5);
ltime0A = GetLaserTime0(run,mtime,TMath::Nint(deltaT),0);
+ if(ltime0A < kEpsilon) return 0;
if (driftCalib) corrPTA = driftCalib->GetPTRelative(timeStamp,0);
corrA = (param->GetZLength(36)/(timeA*param->GetTSample()*(1.-ltime0A)-param->GetL1Delay()-0*param->GetZSigma()/param->GetDriftV()))/param->GetDriftV()-1;
corrA-=corrPTA;
timeC=AliTPCcalibDButil::EvalGraphConst(graphC,timeStamp);
Int_t mtime=TMath::Nint((graphC->GetX()[0]+graphC->GetX()[graphC->GetN()-1])*0.5);
ltime0C = GetLaserTime0(run,mtime,TMath::Nint(deltaT),0);
- if (driftCalib) corrPTC = driftCalib->GetPTRelative(timeStamp,0);
+ if(ltime0C < kEpsilon) return 0;
+if (driftCalib) corrPTC = driftCalib->GetPTRelative(timeStamp,0);
corrC = (param->GetZLength(54)/(timeC*param->GetTSample()*(1.-ltime0C)-param->GetL1Delay()-0*param->GetZSigma()/param->GetDriftV()))/param->GetDriftV()-1;
corrC-=corrPTC;
}
TGraphErrors *graph=0;
dist=0;
if (!array) return 0;
+ //array->ls();
graph = (TGraphErrors*)array->FindObject("ALIGN_ITSB_TPC_DRIFTVD");
if (!graph) return 0;
Double_t deltaY;
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;
Int_t npoints0 = graph->GetN();
Int_t npoints=0;
Float_t rmsY=0;
- Double_t *outx=new Double_t[npoints0];
- Double_t *outy=new Double_t[npoints0];
//
//
if (npoints0<kMinPoints) return 0;
+
+ Double_t *outx=new Double_t[npoints0];
+ Double_t *outy=new Double_t[npoints0];
for (Int_t iter=0; iter<3; iter++){
npoints=0;
for (Int_t ipoint=0; ipoint<npoints0; ipoint++){
}
TGraph *graphOut=0;
if (npoints>1) graphOut= new TGraph(npoints,outx,outy);
+ delete [] outx;
+ delete [] outy;
return graphOut;
}
Int_t npoints0 = graph->GetN();
Int_t npoints=0;
Float_t rmsY=0;
- Double_t *outx=new Double_t[npoints0];
- Double_t *outy=new Double_t[npoints0];
//
//
if (npoints0<kMinPoints) return 0;
+
+ Double_t *outx=new Double_t[npoints0];
+ Double_t *outy=new Double_t[npoints0];
for (Int_t iter=0; iter<3; iter++){
npoints=0;
for (Int_t ipoint=0; ipoint<npoints0; ipoint++){
}
TGraph *graphOut=0;
if (npoints>1) graphOut= new TGraph(npoints,outx,outy);
+ delete [] outx;
+ delete [] outy;
return graphOut;
}
Int_t npoints0 = graph->GetN();
Int_t npoints=0;
Float_t medianErr=0, rmsErr=0;
+ //
+ //
+ if (npoints0<kMinPoints) return 0;
+
Double_t *outx=new Double_t[npoints0];
Double_t *outy=new Double_t[npoints0];
Double_t *erry=new Double_t[npoints0];
Double_t *nerry=new Double_t[npoints0];
Double_t *errx=new Double_t[npoints0];
- //
- //
- if (npoints0<kMinPoints) return 0;
+
for (Int_t iter=0; iter<3; iter++){
npoints=0;
for (Int_t ipoint=0; ipoint<npoints0; ipoint++){
if (npoints>1) graphOut= new TGraphErrors(npoints,outx,outy,errx,erry);
delete []outx;
delete []outy;
- delete []errx;
delete []erry;
+ delete []nerry;
+ delete []errx;
return graphOut;
}
for (Int_t i=0;i<npoints;i++) graph->GetX()[i]=outx[i];
for (Int_t i=0;i<npoints;i++) graph->GetY()[i]=outy[i];
+ delete [] indexes;
+ delete [] outx;
+ delete [] outy;
}
void AliTPCcalibDButil::SmoothGraph(TGraph *graph, Double_t delta){
//
// 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");
+ 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];
+
+ // 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);
}
if (naccept<1) {
delete fit;
sensor->SetFit(0);
+ delete [] yin0;
+ delete [] yin1;
return 0.;
}
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;
//
//
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);
for (Int_t i=0; i<72;i++){
TGraph *graph= (TGraph*)arrT->At(i);
- if (!graph) continue;
+ if (!graph) continue;
+ graph->Sort();
if (graph->GetN()<kMinPoints){
arrT->AddAt(0,i);
delete graph; // delete empty graph
Double_t median = (isec%36<18) ? medianA: medianC;
Double_t rms = (isec%36<18) ? rmsA: rmsC;
Int_t naccept=0;
- for (Int_t ipoint=kMinPoints-1; ipoint<graph->GetN();ipoint++){
+ // for (Int_t ipoint=kMinPoints-1; ipoint<graph->GetN();ipoint++){ //not neccessary to remove first points
+ for (Int_t ipoint=0; ipoint<graph->GetN();ipoint++){
if (TMath::Abs(graph->GetY()[ipoint]-median)>cutAbs) continue;
if (TMath::Abs(graph->GetY()[ipoint]-median)>cutSigma*rms) continue;
vecX[naccept]= graph->GetX()[ipoint];
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;
}
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;
arrT->AddAt(0,i);
continue;
}
- TGraphErrors *graph2= FilterGraphMedianErr(graph,cutSigma,medianY);
- if (!graph2) {
- delete graph; arrT->AddAt(0,i); continue;
+ TGraphErrors *graph2 = NULL;
+ if(graph->GetN()<10) {
+ graph2 = new TGraphErrors(graph->GetN(),graph->GetX(),graph->GetY(),graph->GetEX(),graph->GetEY());
+ if (!graph2) {
+ delete graph; arrT->AddAt(0,i); continue;
+ }
+ }
+ else {
+ graph2= FilterGraphMedianErr(graph,cutSigma,medianY);
+ if (!graph2) {
+ delete graph; arrT->AddAt(0,i); continue;
+ }
}
if (graph2->GetN()<1) {
delete graph; arrT->AddAt(0,i); continue;
//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];
naccept++;
}
- if (naccept<2) return 0;
+ //if (naccept<2) return 0;
+ if (naccept<1) return 0;
TMatrixD *pstat=new TMatrixD(9,3);
TMatrixD &stat=*pstat;
for (Int_t ipar=0; ipar<9; ipar++){
const Double_t kerrsTime[9]={
0.00001, 0.00001, 0.00001,
0.001, 0.001, 0.001,
- 0.0001, 0.001, 0.0001};
+ 0.002, 0.01, 0.001};
//
//
Int_t entries = array->GetEntriesFast();
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);
+
+ AliRelAlignerKalman *kalman = NULL;
+ if(kalmanP->GetRunNumber() != 0 && kalmanM->GetRunNumber() != 0) {
+ kalman = new AliRelAlignerKalman(*kalmanP);
+ kalman->Merge(kalmanM);
+ }
+ else if (kalmanP->GetRunNumber() == 0) {
+ kalman = new AliRelAlignerKalman(*kalmanM);
+ }
+ else if (kalmanM->GetRunNumber() == 0) {
+ kalman = new AliRelAlignerKalman(*kalmanP);
+ }
+ else
+ continue;
+
array->AddAt(kalman,i);
}
+
return array;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff