#include <AliCDBEntry.h>
#include <AliCDBManager.h>
#include <AliCDBId.h>
+#include <AliSplineFit.h>
#include "AliTPCcalibDB.h"
#include "AliTPCCalPad.h"
#include "AliTPCCalROC.h"
}
}
+//_____________________________________________________________________________________
+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){
+
+ printf("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();
+
+ printf("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)
{
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;
}
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) {
+ delete [] tdelta;
printf("AliFatal: No time offset calibration available\n");
return 0;
}
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;
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) {
+ printf("AliTPCcalibDButil::EvalGraphConst: 0 pointer\n");
+ return 0;
+ }
+ if (graph->GetKnots()<1){
+ printf("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 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;
}
//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]));
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