From b17bf9b9092fdc19ed258b10e90e0a1eb42e18ed Mon Sep 17 00:00:00 2001 From: marian Date: Sun, 28 Mar 2010 21:38:12 +0000 Subject: [PATCH] A guiAlias.C - macros from TPC/calibMacros - moved to TPC/scripts A CalibEnv.C M guiTime M makeCalibTree.sh - CalibEnv.C is uesd from the scripts directory Marian --- TPC/scripts/OCDBscan/CalibEnv.C | 762 ++++++++++++++++++++++++++ TPC/scripts/OCDBscan/guiAlias.C | 195 +++++++ TPC/scripts/OCDBscan/guiTime | 2 +- TPC/scripts/OCDBscan/makeCalibTree.sh | 2 +- 4 files changed, 959 insertions(+), 2 deletions(-) create mode 100644 TPC/scripts/OCDBscan/CalibEnv.C create mode 100644 TPC/scripts/OCDBscan/guiAlias.C diff --git a/TPC/scripts/OCDBscan/CalibEnv.C b/TPC/scripts/OCDBscan/CalibEnv.C new file mode 100644 index 00000000000..3685e9eb7b7 --- /dev/null +++ b/TPC/scripts/OCDBscan/CalibEnv.C @@ -0,0 +1,762 @@ +/* +//Make a tree dump of TPC calibration: + +gSystem->AddIncludePath("-I$ALICE_ROOT/TPC"); +.L $ALICE_ROOT/TPC/scripts/OCDBscan/CalibEnv.C+ + +CalibEnv("run.list"); +TFile f("dcsTime.root") +*/ + +#if !defined(__CINT__) || defined(__MAKECINT__) + +#include "TMVA/TSpline1.h" +#include "TMVA/TSpline2.h" +#include +#include +#include +#include +#include +#include +#include +#include "AliTPCcalibDB.h" +#include "AliTPCcalibDButil.h" +#include "AliTPCAltroMapping.h" +#include "AliTPCExB.h" +#include "AliTPCCalROC.h" +#include "AliTPCCalPad.h" +#include "AliTPCSensorTempArray.h" +#include "AliGRPObject.h" +#include "AliTPCTransform.h" +#include "TFile.h" +#include "TKey.h" +#include "TObjArray.h" +#include "TObjString.h" +#include "TString.h" +#include "AliTPCCalPad.h" +#include "AliTPCROC.h" +#include "AliTPCParam.h" +#include "AliTPCCalibPulser.h" +#include "AliTPCCalibPedestal.h" +#include "AliTPCCalibCE.h" +#include "AliTPCExBFirst.h" +#include "TTreeStream.h" +#include "AliTPCTempMap.h" +#include "TVectorD.h" +#include "TMatrixD.h" +#include "AliTPCCalibRaw.h" +#include "AliSplineFit.h" +#include "TGraphErrors.h" +#include +#include +#endif +// +AliTPCcalibDB *calibDB=0; +AliTPCcalibDButil *dbutil =0; +TTree * dcsTree=0; +TString refFile="dummy.root"; +TTreeSRedirector *pcstream =0; +// +// +void ProcessRun(Int_t irun, Int_t startTime, Int_t endTime); +void GetProductionInfo(Int_t run, Int_t &nalien, Int_t &nRawAlien, Int_t &nlocal, Int_t &nRawLocal); +void ProcessDrift(Int_t run, Int_t timeStamp); +void ProcessDriftCE(Int_t run, Int_t timeStamp); +void ProcessDriftAll(Int_t run, Int_t timeStamp); +void ProcessKryptonTime(Int_t run, Int_t timeStamp); +void ProcessCTP(Int_t run, Int_t timeStamp); +void ProcessAlign(Int_t run, Int_t timeStamp); +void CalibEnv(const char * runList, Int_t first=1, Int_t last=-1){ + // + // runList - listOfRuns to process + // first - first run to process + // last - last to process + // + // + // make list of runs + // + ifstream inputFile; + inputFile.open("run.list"); + Int_t irun=0; + TArrayI runArray(100000); + Int_t indexes[100000]; + Int_t nruns=0; + printf("Runs to process:\n"); + if (!inputFile.is_open()) { + printf("Problem to open file %s\n",runList); + } + while( inputFile.good() ) { + inputFile >> irun; + printf("Run \t%d\n",irun); + if (irun0 && irun>last) continue; // process only subset of list + runArray[nruns]=irun; + nruns++; + } + // FILE *pFile = fopen(runList, "r" ); +// if (pFile!=NULL){ +// while(fscanf (pFile, "%d", &irun)){ +// printf("%d\n",irun); +// } +// }else{ +// printf("Problem to open file2 %s\n",runList); +// fclose (pFile); +// } + + calibDB = AliTPCcalibDB::Instance(); + dbutil= new AliTPCcalibDButil; + + TMath::Sort(nruns, runArray.fArray, indexes,kFALSE); + pcstream = new TTreeSRedirector("dcsTime.root"); + Int_t startTime = 0; + Int_t endTime = 0; + for (Int_t run=0; runSetRun(irun); + dbutil->UpdateFromCalibDB(); + dbutil->SetReferenceRun(irun); + dbutil->UpdateRefDataFromOCDB(); + // + AliDCSSensorArray *arrHV=calibDB->GetVoltageSensors(irun); + if (!arrHV) continue; + for (Int_t isenHV=0; isenHVNumSensors(); ++isenHV){ + AliDCSSensor *senHV=arrHV->GetSensorNum(isenHV); + if (!senHV) { + printf("Not interesting OCDB info\n"); + continue; + } + startTime=senHV->GetStartTime(); + endTime =senHV->GetEndTime(); + if (startTime>0&&endTime>0) break; + } + //dbutil->FilterCE(120., 3., 4.,pcstream); + //dbutil->FilterTracks(irun, 10.,pcstream); + AliDCSSensorArray* goofieArray = AliTPCcalibDB::Instance()->GetGoofieSensors(irun); + if (goofieArray) dbutil->FilterGoofie(goofieArray,0.5,4.,6.85,7.05,pcstream); + // don't filter goofie for the moment + ProcessRun(irun, startTime,endTime); + } + delete pcstream; +} + + +void ProcessRun(Int_t irun, Int_t startTime, Int_t endTime){ + // + // + // + AliSplineFit *fitVdrift=0x0; + Int_t startTimeGRP=0, stopTimeGRP=0; + if (calibDB->GetGRP(irun)){ + startTimeGRP = AliTPCcalibDB::GetGRP(irun)->GetTimeStart(); + stopTimeGRP = AliTPCcalibDB::GetGRP(irun)->GetTimeEnd(); + } + + AliTPCSensorTempArray * tempArray = AliTPCcalibDB::Instance()->GetTemperatureSensor(irun); + AliTPCTempMap * tempMap = new AliTPCTempMap(tempArray); + AliDCSSensorArray* goofieArray = AliTPCcalibDB::Instance()->GetGoofieSensors(irun); + // + Int_t dtime = TMath::Max((endTime-startTime)/20,10*60); + // + //Goofie statistical data + // + TVectorD vecEntries, vecMean, vecMedian,vecRMS; + dbutil->ProcessGoofie(vecEntries ,vecMedian, vecMean, vecRMS); + // + //CE data processing - see ProcessCEdata function for description of the results + // + TVectorD fitResultsA, fitResultsC; + Int_t nmaskedCE; + Double_t chi2ACE=0,chi2CCE=0; + // dbutil->ProcessCEdata("(sector<36)++gx++gy++lx++lx**2",fitResultsA,fitResultsC,nmaskedCE); + dbutil->ProcessCEdata("(sector<36)++gx++gy++(lx-134)++(sector<36)*(lx-134)++(ly/lx)^2",fitResultsA,fitResultsC,nmaskedCE,chi2ACE,chi2CCE); + + TVectorD fitCEResultsA(7), fitCEResultsC(7); + Int_t noutCE; + Double_t chi2CEA=0,chi2CEC=0; + AliTPCCalPad *time0 = dbutil->CreatePadTime0CE(fitCEResultsA, fitCEResultsC, noutCE, chi2CEA, chi2CEC); + delete time0; + // + // + TVectorD vecTEntries, vecTMean, vecTRMS, vecTMedian, vecQEntries, vecQMean, vecQRMS, vecQMedian; + Float_t driftTimeA, driftTimeC; + dbutil->ProcessCEgraphs(vecTEntries, vecTMean, vecTRMS, vecTMedian, + vecQEntries, vecQMean, vecQRMS, vecQMedian, + driftTimeA, driftTimeC ); + // + // + // + //drift velocity using tracks + // + // fitVdrift=calibDB->GetVdriftSplineFit("ALISPLINEFIT_MEAN_VDRIFT_COSMICS_ALL",irun); + fitVdrift=calibDB->CreateVdriftSplineFit("TGRAPHERRORS_MEAN_VDRIFT_COSMICS_ALL",irun); + //noise data Processing - see ProcessNoiseData function for description of the results + TVectorD vNoiseMean, vNoiseMeanSenRegions, vNoiseRMS, vNoiseRMSSenRegions; + Int_t nonMaskedZero=0, nNaN=0; + dbutil->ProcessNoiseData(vNoiseMean, vNoiseMeanSenRegions, vNoiseRMS, vNoiseRMSSenRegions, nonMaskedZero, nNaN); + // + // comparisons + // + TVectorF pedestalDeviations; + TVectorF noiseDeviations; + TVectorF pulserQdeviations; + Float_t varQMean; + Int_t npadsOutOneTB; + Int_t npadsOffAdd; + dbutil->ProcessPedestalVariations(pedestalDeviations); + dbutil->ProcessNoiseVariations(noiseDeviations); + dbutil->ProcessPulserVariations(pulserQdeviations,varQMean,npadsOutOneTB,npadsOffAdd); + // + //L3 data + // + Float_t bz=AliTPCcalibDB::GetBz(irun); + Char_t l3pol=AliTPCcalibDB::GetL3Polarity(irun); + // + //calibration Pulser data processing + // + Int_t nOffChannels=0; + TVectorD vTimePulser; + nOffChannels=dbutil->GetNPulserOutliers(); + dbutil->ProcessPulser(vTimePulser); + // + //ALTRO data + // + Int_t nMasked=0; + dbutil->ProcessALTROConfig(nMasked); + // + //Calib RAW data + // + Int_t nFailL1=-1; + if (calibDB->GetCalibRaw()) nFailL1=calibDB->GetCalibRaw()->GetNFailL1Phase(); + // + //production information + // + Int_t nalien=0,nRawAlien=0,nlocal=0,nRawLocal=0; + GetProductionInfo(irun, nalien, nRawAlien, nlocal,nRawLocal); + //run type + TObjString runType(AliTPCcalibDB::GetRunType(irun).Data()); + // + // + // + + for (Int_t itime=startTime; itimeGetPressure(tstamp,irun,0); + Float_t valuePressure2 = calibDB->GetPressure(tstamp,irun,1); + Double_t ptrelative0 = AliTPCcalibDB::GetPTRelative((UInt_t)itime,irun,0); + Double_t ptrelative1 = AliTPCcalibDB::GetPTRelative((UInt_t)itime,irun,1); + //temperature fits + TLinearFitter * fitter = 0; + TVectorD vecTemp[10]; + for (Int_t itype=0; itype<5; itype++) + for (Int_t iside=0; iside<2; iside++){ + fitter= tempMap->GetLinearFitter(itype,iside,tstamp); + if (!fitter) continue; + fitter->Eval(); + fitter->GetParameters(vecTemp[itype+iside*5]); + delete fitter; + } + // + //measured skirt temperatures + // + TVectorD vecSkirtTempA(18); + TVectorD vecSkirtTempC(18); + Int_t nsenTemp=tempArray->NumSensors(); + for (Int_t isenTemp=0;isenTempGetSensorNum(isenTemp); + if (senTemp->GetType()!=3) continue; + if (TMath::Sqrt(senTemp->GetX()*senTemp->GetX()+senTemp->GetY()*senTemp->GetY())<100) continue; //only skirt, outer FC vessel + Double_t val=senTemp->GetValue(tstamp); + if (senTemp->GetSide()==0) + vecSkirtTempA[senTemp->GetSector()]=val; + else + vecSkirtTempC[senTemp->GetSector()]=val; + } + // + //goofie data + // + TVectorD vecGoofie; + if (goofieArray){ + vecGoofie.ResizeTo(goofieArray->NumSensors()); + for (Int_t isensor=0; isensorNumSensors();isensor++){ + AliDCSSensor *gsensor = goofieArray->GetSensor(isensor); + if (gsensor){ + vecGoofie[isensor] = gsensor->GetValue(tstamp); + } + } + } else { + vecGoofie.ResizeTo(19); + } + // + TVectorD voltagesIROC(36); + TVectorD voltagesOROC(36); + for(Int_t j=1; j<36; j++) voltagesIROC[j-1] = AliTPCcalibDB::Instance()->GetChamberHighVoltage(irun, j,itime); + for(Int_t j=36; j<72; j++) voltagesOROC[j-36] = AliTPCcalibDB::Instance()->GetChamberHighVoltage(irun, j,itime); + Double_t voltIROC = TMath::Median(36, voltagesIROC.GetMatrixArray()); + Double_t voltOROC = TMath::Median(36, voltagesOROC.GetMatrixArray()); + // + Float_t coverIA=AliTPCcalibDB::GetCoverVoltage(irun,0,itime); + Float_t coverIC=AliTPCcalibDB::GetCoverVoltage(irun,18,itime); + Float_t coverOA=AliTPCcalibDB::GetCoverVoltage(irun,36,itime); + Float_t coverOC=AliTPCcalibDB::GetCoverVoltage(irun,54,itime); + Float_t skirtA=AliTPCcalibDB::GetSkirtVoltage(irun,0,itime); + Float_t skirtC=AliTPCcalibDB::GetSkirtVoltage(irun,18,itime); + Float_t ggOffA=AliTPCcalibDB::GetGGoffsetVoltage(irun,0,itime); + Float_t ggOffC=AliTPCcalibDB::GetGGoffsetVoltage(irun,18,itime); + //drift velocity + Float_t dvCorr=-5; + if (fitVdrift) dvCorr=fitVdrift->Eval(itime); + // + // Gain - Alexander Kalveit + // + Float_t gainCosmic = 0; + Float_t gainMIP = 0; + TObjArray * gainSplines = AliTPCcalibDB::Instance()->GetTimeGainSplinesRun(irun); + if (gainSplines) { + TGraphErrors * graphMIP = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_GAIN_BEAM_ALL"); + TGraphErrors * graphCosmic = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_GAIN_COSMIC_ALL"); + if (graphMIP) gainMIP = graphMIP->Eval(itime); + if (graphCosmic) gainCosmic = graphCosmic->Eval(itime); + } + + + //tempMap->GetLinearFitter(0,0,itime); + (*pcstream)<<"dcs"<< + "run="<GetFromPipe(command.Data()); + nalien=sNlines.Atoi(); + //find number of raw files on alien + command="alien_find /alice/data/2009 "; + command += Form("%09d",run); + command += " | grep raw | grep -v tag | wc -l"; + sNlines = gSystem->GetFromPipe(command.Data()); + nRawAlien=sNlines.Atoi(); + // //find number of ESDs local +// command="find /lustre/alice/alien/alice/data/2009 -name AliESDs.root | grep "; +// command += Form("%09d",run); +// command += " | wc -l"; +// sNlines = gSystem->GetFromPipe(command.Data()); +// nlocal=sNlines.Atoi(); +// //find number of local raw data files +// command="find /lustre/alice/alien/alice/data/2009 -name \"*.root\" | grep "; +// command += Form("%09d",run); +// command += " | grep raw | grep -v tag | wc -l"; +// sNlines = gSystem->GetFromPipe(command.Data()); +// nRawLocal=sNlines.Atoi(); +} + + + +void ProcessDrift(Int_t run, Int_t timeStamp){ + // + // dump drift calibration data to the tree + // + TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run); + TGraphErrors *laserA[3]={0,0,0}; + TGraphErrors *laserC[3]={0,0,0}; + TGraphErrors *cosmicAll=0; + static Double_t vlaserA[3]={0,0,0}; + static Double_t vlaserC[3]={0,0,0}; + static Double_t vcosmicAll=0; + static Double_t vdrift1=0; + vdrift1=AliTPCcalibDB::Instance()->GetVDriftCorrectionTime(timeStamp,run,0,1); + + if (array){ + laserA[0]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DELAY_LASER_ALL_A"); + laserA[1]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_A"); + laserA[2]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_A"); + laserC[0]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DELAY_LASER_ALL_C"); + laserC[1]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_C"); + laserC[2]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_C"); + cosmicAll =(TGraphErrors*)array->FindObject("TGRAPHERRORS_MEAN_VDRIFT_COSMICS_ALL"); + } + if (laserA[0]) vlaserA[0]= AliTPCcalibDButil::EvalGraphConst(laserA[0],timeStamp); + if (laserA[1]) vlaserA[1]= AliTPCcalibDButil::EvalGraphConst(laserA[1],timeStamp); + if (laserA[2]) vlaserA[2]= AliTPCcalibDButil::EvalGraphConst(laserA[2],timeStamp); + if (laserC[0]) vlaserC[0]= AliTPCcalibDButil::EvalGraphConst(laserC[0],timeStamp); + if (laserC[1]) vlaserC[1]= AliTPCcalibDButil::EvalGraphConst(laserC[1],timeStamp); + if (laserC[2]) vlaserC[2]= AliTPCcalibDButil::EvalGraphConst(laserC[2],timeStamp); + if (cosmicAll) vcosmicAll= AliTPCcalibDButil::EvalGraphConst(cosmicAll,timeStamp); + (*pcstream)<<"dcs"<< + "vlaserA0="<GetObject(); + } + } + static TVectorD krMean(74); + static TVectorD krErr(74); + static TVectorD krDist(74); + TGraphErrors *gr=0; + Double_t deltaT=0,gry=0; + if (krArray){ + for (Int_t isec=0; isec<72; isec++){ + krMean[isec]=0; + krDist[isec]=0; + krErr[isec]=0; + gr=(TGraphErrors*)krArray->At(isec); + if (gr) { + krMean[isec]=gr->Eval(timeStamp); + AliTPCcalibDButil::GetNearest(gr, timeStamp,deltaT,gry); + krDist[isec]=deltaT; + } + if (72+isecGetEntries()) { + gr=(TGraphErrors*)krArray->At(72+isec); + if (gr) krErr[isec]=gr->Eval(timeStamp); + } + } + krMean[72]= TMath::Median(36,krMean.GetMatrixArray()); + krMean[73]= TMath::Median(36,&(krMean.GetMatrixArray()[36])); + krErr[72]= TMath::Median(36,krErr.GetMatrixArray()); + krErr[73]= TMath::Median(36,&(krErr.GetMatrixArray()[36])); + } + (*pcstream)<<"dcs"<< + "krMean.="<<&krMean<< + "krErr.="<<&krErr<< + "krDist.="<<&krDist; +} + +void ProcessCTP(Int_t irun, Int_t timeStamp){ + // + // + // + static TClonesArray *pcarray = new TClonesArray("AliCTPInputTimeParams",1); + static AliCTPTimeParams *ctpParams =0; + ctpParams = AliTPCcalibDB::Instance()->GetCTPTimeParams(); // + const TObjArray *arr = ctpParams->GetInputTimeParams(); + pcarray->ExpandCreateFast(TMath::Max(arr->GetEntries(),1)); + for (Int_t i=0; iGetEntries(); i++){ + new ((*pcarray)[i]) AliCTPInputTimeParams(*((AliCTPInputTimeParams*)arr->At(i))); + } + (*pcstream)<<"ctp"<< + "run="<GetTimeVdriftSplineRun(run); + TGraphErrors *gr=0; + for (Int_t idet=0; idet<12; idet++){ + for (Int_t ipar=0; ipar<9; ipar++){ + TString grName=grnames[idet]; + grName+="_TPC_"; + grName+=grpar[ipar]; + if (array){ + gr = (TGraphErrors*)array->FindObject(grName.Data()); + } + values[9*idet+ipar]=0; + errs[9*idet+ipar]=0; + if (gr) values[9*idet+ipar]=gr->Eval(timeStamp); + (*pcstream)<<"dcs"<< + Form("%s=",grName.Data())<AddIncludePath("-I$ALICE_ROOT/TPC/macros"); + gROOT->LoadMacro("$ALICE_ROOT/TPC/macros/AliXRDPROOFtoolkit.cxx+") + AliXRDPROOFtoolkit tool; + TChain * chainDCS = tool.MakeChainRandom("time.txt","dcs",0,10000); + TChain * chainCTP = tool.MakeChainRandom("time.txt","ctp",0,10000); + TChain * chainAlign = tool.MakeChainRandom("time.txt","align",0,10000); + +*/ + +TObjArray *picArray = new TObjArray; + +TTree * guiTree = guiTime->GetChain(); +void SetStyle(); +void guiAlias(){ + guiTree = guiTime->GetChain(); + MakeAliasCE(4); + MakeAliasLT(4); + MakeAliasCosmic(4); + SetGoofieAlias(); + SetStyle(); +} + +void SetStyle(){ + Float_t mx0=0.15, mx1=0.05, my0=0.15, my1=0.1; + guiTime->GetCanvas()->SetTicks(1,1); + guiTime->GetCanvas()->SetMargin(mx0,mx1,my0,my1); + gStyle->SetTitleYSize(0.03); + gStyle->SetTitleXSize(0.03); + gStyle->SetTitleXOffset(2); + gStyle->SetTitleYOffset(6); +} + +void MakeAliasCE(Double_t deltaT){ + // + // Aliases cuts for CE + // + guiTree->SetAlias("ceCut0", "tdriftCE.fElements[72]>100 && tdriftCE.fElements[73]>100"); + guiTree->SetAlias("dceCutTime", Form("sqrt(dcea^2+dcec^2)<%f",deltaT*3600)); + guiTree->SetAlias("ceCut","dceCutTime&&ceCut0"); +}; + +void MakeAliasLT(Double_t deltaT){ + guiTree->SetAlias("ltCut", Form("sqrt(dla^2+dlc^2)<%f", deltaT*3600)); +} + +void MakeAliasCosmic(Double_t deltaT){ + guiTree->SetAlias("cosmicCut", Form("abs(dcosmic)<%f", deltaT*3600)); + guiTree->SetAlias("itsCut", Form("((dits!=0)&&abs(dits)<%f)", deltaT*3600)); +} + + +void SetGoofieAlias(){ + // + // goofie aliases + // + guiTree->SetAlias("ptrelG","(goofie.fElements[17]/0.3426-1)"); + guiTree->SetAlias("vdriftGN","goofie.fElements[3]/(1+ptrelG)"); + guiTree->SetAlias("goCut","goofie.fElements[3]>0"); + // +} +// +// Make default plots +// + + +void DrawLaserDrift(){ + // + // laser calibration default picture + // Data are filtered + + // + // draw laser residuals A side -C side - when it is defined + // + TH1 * his=0; + guiTree->Draw("CEgrDriftA-CEgrDriftC","CEgrDriftA>0&&CEgrDriftC>0"); + his=(TH1*)htemp->Clone(); + his->SetDirectory(0); + his->SetTitle("#Delta CE time"); + his->SetName("#Delta CE time"); + his->GetXaxis()->SetTitle("#Delta T (time bin)"); + his->Draw(); + picArray->AddLast(his); + // + // laser drift CE correction + // + guiTree->Draw("100*(vdriftCEA-vdriftCEC)","CEgrDriftA>0&&CEgrDriftC>0"); + his=(TH1*)htemp->Clone(); + his->SetDirectory(0); + his->SetTitle("#Delta CE drift"); + his->SetName("#Delta CE drift"); + his->GetXaxis()->SetTitle("#Delta v_{drift} (%) (laser A side - C side)"); + his->Draw(); + picArray->AddLast(his); + // + // laser track drift correction + // + guiTree->Draw("100*(vdriftLTA-vdriftLTC)","abs(dlaserA)<500&&abs(dlaserC)<500&&vdriftLTA!=0&&vdriftLTC!=0"); + his=(TH1*)htemp->Clone(); + his->SetDirectory(0); + his->SetTitle("#Delta LaserTracks drift"); + his->SetName("#Delta LaserTracks drift"); + his->GetXaxis()->SetTitle("#Delta v_{drift} (%) (laser A side - C side)"); + his->Draw(); + picArray->AddLast(his); + // + // laser track drift correction: time + // + guiTree->Draw("100*(vdriftLTA-vdriftLTC):time","abs(dlaserA)<500&&abs(dlaserC)<500&&vdriftLTA!=0&&vdriftLTC!=0","colz"); + his=(TH1*)htemp->Clone(); + his->SetDirectory(0); + his->Draw(); + his->SetTitle("#Delta LaserTracks drift"); + his->SetName("#Delta LaserTracks drift"); + his->GetYaxis()->SetTitle("#Delta v_{drift} (%) (laser A side - C side)"); + his->GetXaxis()->SetTitle("time"); + his->GetXaxis()->SetTimeDisplay(kTRUE); + his->Draw(); + picArray->AddLast(his); + // + // + // + guiTree->Draw("250*(vlaserA0-vlaserC0)","abs(dlaserA)<500&&abs(dlaserC)<500&&vdriftLTA!=0&&vdriftLTC!=0"); + his=(TH1*)htemp->Clone(); + his->SetDirectory(0); + his->SetTitle("#Delta LaserTracks offset"); + his->SetName("#Delta LaserTracks offset"); + his->GetXaxis()->SetTitle("#Delta z0 (cm) (laser A side - C side)"); + his->Draw(); + picArray->AddLast(his); +} + + +void DrawITSVD(){ + // + // ITS/TPC drift velocity correction + // + guiTree->Draw("100*(ALIGN_ITSP_TPC_DRIFTVD-ALIGN_ITSM_TPC_DRIFTVD)","abs(dits)<3000&&ALIGN_ITSM_TPC_DRIFTVD!=0"); + his=(TH1*)htemp->Clone(); + his->SetDirectory(0); + his->SetTitle("#Delta ITS/TPC drift correction positive and negative extrapolation"); + his->SetName("#Delta ITS/TPC drift correction"); + his->GetXaxis()->SetTitle("#Delta v_{dcorr} (%)"); + his->Draw(); + picArray->AddLast(his); + // + // comparison with laser + // + guiTree->Draw("100*(vdriftLTA-vdriftITS)","abs(dlaserA)<3600&&vdriftLTA!=0&&abs(dits)<3600"); + his=(TH1*)htemp->Clone(); + his->SetDirectory(0); + his->SetTitle("#Delta ITS/TPC drift correction - Laser track corr"); + his->SetName("#Delta ITS/TPC drift correction - laser track corr"); + his->GetXaxis()->SetTitle("#Delta v_{dcorr} (%)"); + his->Draw(); + picArray->AddLast(his); + // + guiTree->Draw("100*(vdriftLTA-ALIGN_ITS_TPC_DRIFTVD)","abs(dlaserA)<3600&&vdriftLTA!=0&&abs(dits)<3600"); + his=(TH1*)htemp->Clone(); + his->SetDirectory(0); + his->SetTitle("#Delta ITS/TPC non smmoth drift correction - Laser track corr"); + his->SetName("#Delta ITS/TPC non smooth drift correction - laser track corr"); + his->GetXaxis()->SetTitle("#Delta v_{dcorr} (%)"); + his->Draw(); + picArray->AddLast(his); + // + guiTree->Draw("100*(vdriftLTA-vdriftP)","abs(dlaserA)<1800&&vdriftLTA!=0&&abs(dp)<1800"); + his=(TH1*)htemp->Clone(); + his->SetDirectory(0); + his->SetTitle("#Delta TPC/TPC - Laser track corr"); + his->SetName("#Delta TPC/TPC - Laser track corr"); + his->GetXaxis()->SetTitle("#Delta v_{dcorr} (%)"); + his->Draw(); + picArray->AddLast(his); + +} + + +void CEdrift(){ + // + // + // + guiTree->SetAlias("vdriftCE0","250/CEgrDriftA"); + guiTree->SetAlias("vdriftCE1","vdriftCE0/(1+ptrel0)"); +} diff --git a/TPC/scripts/OCDBscan/guiTime b/TPC/scripts/OCDBscan/guiTime index df5223ee2e3..b70c8b38c0b 100755 --- a/TPC/scripts/OCDBscan/guiTime +++ b/TPC/scripts/OCDBscan/guiTime @@ -8,4 +8,4 @@ if [ "x$SCRIPTDIR" == "x" ]; then fi source $SCRIPTDIR/guiEnv.sh test -d $GUI_OUTDIR_RUNS || mkdir -p $GUI_OUTDIR_RUNS -root.exe $SCRIPTDIR/loadlibsREC.C $SCRIPTDIR/ConfigOCDB.C $ALICE_ROOT/TPC/scripts/startGUItime.C\(\"$1\"\) $ALICE_ROOT/TPC/CalibMacros/guiAlias.C +root.exe $SCRIPTDIR/loadlibsREC.C $SCRIPTDIR/ConfigOCDB.C $ALICE_ROOT/TPC/scripts/startGUItime.C\(\"$1\"\) $SCRIPTDIR/guiAlias.C diff --git a/TPC/scripts/OCDBscan/makeCalibTree.sh b/TPC/scripts/OCDBscan/makeCalibTree.sh index 775cdefd12b..49c08858a55 100755 --- a/TPC/scripts/OCDBscan/makeCalibTree.sh +++ b/TPC/scripts/OCDBscan/makeCalibTree.sh @@ -20,7 +20,7 @@ cd $workdir source guiEnv.sh source $ALICE_ROOT/TPC/scripts/halloWorld.sh # -aliroot -q -b $SCRIPTDIR/ConfigOCDB.C $ALICE_ROOT/TPC/CalibMacros/CalibEnv.C+\(\"$runList\",$startRun,$endRun\) +aliroot -q -b $SCRIPTDIR/ConfigOCDB.C $SCRIPTDIR/CalibEnv.C+\(\"$runList\",$startRun,$endRun\) echo End of job: echo pwd=`pwd` echo ls= -- 2.43.0