| 12f69174 |
1 | /* |
| 2 | // Make a summary information of calibration. |
| 3 | // Store results in the summary trees |
| 4 | // OCDB configuration |
| 5 | |
| 5f547d58 |
6 | Example usage: |
| 12f69174 |
7 | |
| 5f547d58 |
8 | gSystem->Load("libANALYSIS"); |
| 9 | gSystem->Load("libTPCcalib"); |
| 12f69174 |
10 | |
| 5f547d58 |
11 | Int_t irun=119037; |
| 12 | gROOT->LoadMacro("$ALICE_ROOT/TPC/scripts/OCDBscan/ConfigOCDB.C"); |
| 13 | ConfigOCDB(irun) |
| 14 | |
| 15 | AliTPCcalibSummary *calibSummary = new AliTPCcalibSummary; |
| 16 | calibSummary->ProcessRun(irun); |
| 17 | delete calibSummary; |
| 12f69174 |
18 | |
| 19 | */ |
| 20 | |
| 21 | #include <TROOT.h> |
| 22 | #include <iostream> |
| 23 | #include <fstream> |
| 24 | #include <stdio.h> |
| 25 | #include <AliCDBManager.h> |
| 26 | #include <AliCDBEntry.h> |
| 27 | #include <AliLog.h> |
| 28 | #include <AliMagF.h> |
| 29 | #include "AliTPCcalibDB.h" |
| 30 | #include "AliTPCcalibDButil.h" |
| 31 | #include "AliTPCAltroMapping.h" |
| 32 | #include "AliTPCExB.h" |
| 33 | #include "AliTPCCalROC.h" |
| 34 | #include "AliTPCCalPad.h" |
| 35 | #include "AliTPCSensorTempArray.h" |
| 36 | #include "AliGRPObject.h" |
| 37 | #include "AliTPCTransform.h" |
| 38 | #include "TFile.h" |
| 39 | #include "TKey.h" |
| 40 | #include "TObjArray.h" |
| 41 | #include "TObjString.h" |
| 42 | #include "TString.h" |
| 43 | #include "AliTPCCalPad.h" |
| 44 | #include "AliTPCROC.h" |
| 45 | #include "AliTPCParam.h" |
| 46 | #include "AliTPCCalibPulser.h" |
| 47 | #include "AliTPCCalibPedestal.h" |
| 48 | #include "AliTPCCalibCE.h" |
| 49 | #include "AliTPCExBFirst.h" |
| 50 | #include "TTreeStream.h" |
| 51 | #include "AliTPCTempMap.h" |
| 52 | #include "TVectorD.h" |
| 53 | #include "TMatrixD.h" |
| 54 | #include "AliTPCCalibRaw.h" |
| 55 | #include "AliSplineFit.h" |
| 56 | #include "TGraphErrors.h" |
| 57 | #include <AliCTPTimeParams.h> |
| 58 | #include <AliTPCcalibSummary.h> |
| 59 | // |
| 60 | // |
| 61 | // |
| 62 | AliTPCcalibSummary::AliTPCcalibSummary(): |
| 63 | TNamed(), |
| 64 | fCalibDB(0), |
| 65 | fDButil(0), |
| 66 | fPcstream(0) |
| 67 | { |
| 68 | // |
| 69 | // default constructor |
| 70 | // OCDB have to be setupe before - not part of class |
| 71 | // usualy ConfigOCDB.C macro used |
| 72 | // |
| 73 | fPcstream = new TTreeSRedirector("dcsTime.root"); |
| 74 | fCalibDB = AliTPCcalibDB::Instance(); |
| 75 | fDButil= new AliTPCcalibDButil; |
| 76 | } |
| 77 | |
| 78 | AliTPCcalibSummary::~AliTPCcalibSummary(){ |
| 79 | // |
| 80 | // destructor - close streamer |
| 81 | // |
| 82 | delete fPcstream; |
| 83 | } |
| 84 | |
| 85 | void AliTPCcalibSummary::Process(const char * runList, Int_t first, Int_t last){ |
| 86 | // |
| 87 | // runList - listOfRuns to process |
| 88 | // first - first run to process |
| 89 | // last - last to process |
| 90 | // |
| 91 | // |
| 92 | // make list of runs |
| 93 | // |
| 94 | |
| 95 | ifstream inputFile; |
| 96 | inputFile.open("run.list"); |
| 97 | Int_t irun=0; |
| 98 | TArrayI runArray(100000); |
| 99 | Int_t indexes[100000]; |
| 100 | Int_t nruns=0; |
| 101 | printf("Runs to process:\n"); |
| 102 | if (!inputFile.is_open()) { |
| 103 | printf("Problem to open file %s\n",runList); |
| 104 | } |
| 105 | while( inputFile.good() ) { |
| 106 | inputFile >> irun; |
| 107 | printf("Run \t%d\n",irun); |
| 108 | if (irun<first) continue; // process only subset of list |
| 109 | if (last>0 && irun>last) continue; // process only subset of list |
| 110 | runArray[nruns]=irun; |
| 111 | nruns++; |
| 112 | } |
| 113 | |
| 114 | |
| 115 | TMath::Sort(nruns, runArray.fArray, indexes,kFALSE); |
| 116 | Int_t startTime = 0; |
| 117 | Int_t endTime = 0; |
| 118 | for (Int_t run=0; run<nruns; run++){ |
| 119 | irun=runArray[indexes[run]]; |
| 120 | printf("Processing run %d ...\n",irun); |
| 121 | fCalibDB->SetRun(irun); |
| 122 | fDButil->UpdateFromCalibDB(); |
| 123 | fDButil->SetReferenceRun(irun); |
| 124 | fDButil->UpdateRefDataFromOCDB(); |
| 125 | // |
| 126 | AliDCSSensorArray *arrHV=fCalibDB->GetVoltageSensors(irun); |
| 127 | if (!arrHV) continue; |
| 128 | for (Int_t isenHV=0; isenHV<arrHV->NumSensors(); ++isenHV){ |
| 129 | AliDCSSensor *senHV=arrHV->GetSensorNum(isenHV); |
| 130 | if (!senHV) { |
| 131 | printf("Not interesting OCDB info\n"); |
| 132 | continue; |
| 133 | } |
| 134 | startTime=senHV->GetStartTime(); |
| 135 | endTime =senHV->GetEndTime(); |
| 136 | if (startTime>0&&endTime>0) break; |
| 137 | } |
| 138 | AliDCSSensorArray* goofieArray = fCalibDB->GetGoofieSensors(irun); |
| 139 | if (goofieArray) fDButil->FilterGoofie(goofieArray,0.5,4.,6.85,7.05,fPcstream); |
| 140 | // don't filter goofie for the moment |
| 141 | ProcessRun(irun, startTime,endTime); |
| 142 | } |
| 143 | } |
| 144 | |
| 145 | |
| 146 | void AliTPCcalibSummary::ProcessRun(Int_t irun, Int_t startTime, Int_t endTime){ |
| 147 | // |
| 148 | // Process run irun |
| 149 | // |
| 150 | fCalibDB->SetRun(irun); |
| 151 | fDButil->UpdateFromCalibDB(); |
| 152 | fDButil->SetReferenceRun(irun); |
| 153 | fDButil->UpdateRefDataFromOCDB(); |
| 154 | // |
| 155 | AliSplineFit *fitVdrift=0x0; |
| 156 | Int_t startTimeGRP=0, stopTimeGRP=0; |
| 157 | if (fCalibDB->GetGRP(irun)){ |
| 158 | startTimeGRP = AliTPCcalibDB::GetGRP(irun)->GetTimeStart(); |
| 159 | stopTimeGRP = AliTPCcalibDB::GetGRP(irun)->GetTimeEnd(); |
| 160 | } |
| 161 | if (startTime==0){ |
| 162 | startTime=startTimeGRP; |
| 163 | endTime=stopTimeGRP; |
| 164 | } |
| 165 | AliTPCSensorTempArray * tempArray = fCalibDB->GetTemperatureSensor(irun); |
| 166 | AliTPCTempMap * tempMap = new AliTPCTempMap(tempArray); |
| 167 | AliDCSSensorArray* goofieArray = fCalibDB->GetGoofieSensors(irun); |
| 168 | // |
| 169 | Int_t dtime = TMath::Max((endTime-startTime)/20,10*60); |
| 170 | // |
| 171 | //Goofie statistical data |
| 172 | // |
| 173 | TVectorD vecEntries, vecMean, vecMedian,vecRMS; |
| 174 | fDButil->ProcessGoofie(vecEntries ,vecMedian, vecMean, vecRMS); |
| 175 | // |
| 176 | //CE data processing - see ProcessCEdata function for description of the results |
| 177 | // |
| 178 | TVectorD fitResultsA, fitResultsC; |
| 179 | Int_t nmaskedCE; |
| 180 | Double_t chi2ACE=0,chi2CCE=0; |
| 181 | // fDButil->ProcessCEdata("(sector<36)++gx++gy++lx++lx**2",fitResultsA,fitResultsC,nmaskedCE); |
| 182 | fDButil->ProcessCEdata("(sector<36)++gx++gy++(lx-134)++(sector<36)*(lx-134)++(ly/lx)^2",fitResultsA,fitResultsC,nmaskedCE,chi2ACE,chi2CCE); |
| 183 | |
| 184 | TVectorD fitCEResultsA(7), fitCEResultsC(7); |
| 185 | Int_t noutCE; |
| 186 | Double_t chi2CEA=0,chi2CEC=0; |
| 187 | AliTPCCalPad *time0 = fDButil->CreatePadTime0CE(fitCEResultsA, fitCEResultsC, noutCE, chi2CEA, chi2CEC); |
| 188 | delete time0; |
| 189 | // |
| 190 | // |
| 191 | TVectorD vecTEntries, vecTMean, vecTRMS, vecTMedian, vecQEntries, vecQMean, vecQRMS, vecQMedian; |
| 192 | Float_t driftTimeA, driftTimeC; |
| 193 | fDButil->ProcessCEgraphs(vecTEntries, vecTMean, vecTRMS, vecTMedian, |
| 194 | vecQEntries, vecQMean, vecQRMS, vecQMedian, |
| 195 | driftTimeA, driftTimeC ); |
| 196 | // |
| 197 | // |
| 198 | // |
| 199 | //drift velocity using tracks |
| 200 | // |
| 201 | // fitVdrift=fCalibDB->GetVdriftSplineFit("ALISPLINEFIT_MEAN_VDRIFT_COSMICS_ALL",irun); |
| 202 | fitVdrift=fCalibDB->CreateVdriftSplineFit("TGRAPHERRORS_MEAN_VDRIFT_COSMICS_ALL",irun); |
| 203 | //noise data Processing - see ProcessNoiseData function for description of the results |
| 204 | TVectorD vNoiseMean, vNoiseMeanSenRegions, vNoiseRMS, vNoiseRMSSenRegions; |
| 205 | Int_t nonMaskedZero=0, nNaN=0; |
| 206 | fDButil->ProcessNoiseData(vNoiseMean, vNoiseMeanSenRegions, vNoiseRMS, vNoiseRMSSenRegions, nonMaskedZero, nNaN); |
| 207 | // |
| 208 | // comparisons |
| 209 | // |
| 210 | TVectorF pedestalDeviations; |
| 211 | TVectorF noiseDeviations; |
| 212 | TVectorF pulserQdeviations; |
| 213 | Float_t varQMean; |
| 214 | Int_t npadsOutOneTB; |
| 215 | Int_t npadsOffAdd; |
| 216 | fDButil->ProcessPedestalVariations(pedestalDeviations); |
| 217 | fDButil->ProcessNoiseVariations(noiseDeviations); |
| 218 | fDButil->ProcessPulserVariations(pulserQdeviations,varQMean,npadsOutOneTB,npadsOffAdd); |
| 219 | // |
| 220 | //L3 data |
| 221 | // |
| 222 | Float_t bz=AliTPCcalibDB::GetBz(irun); |
| 223 | Char_t l3pol=AliTPCcalibDB::GetL3Polarity(irun); |
| 224 | // |
| 225 | //calibration Pulser data processing |
| 226 | // |
| 227 | Int_t nOffChannels=0; |
| 228 | TVectorD vTimePulser; |
| 229 | nOffChannels=fDButil->GetNPulserOutliers(); |
| 230 | fDButil->ProcessPulser(vTimePulser); |
| 231 | // |
| 232 | //ALTRO data |
| 233 | // |
| 234 | Int_t nMasked=0; |
| 235 | fDButil->ProcessALTROConfig(nMasked); |
| 236 | // |
| 237 | //Calib RAW data |
| 238 | // |
| 239 | Int_t nFailL1=-1; |
| 240 | if (fCalibDB->GetCalibRaw()) nFailL1=fCalibDB->GetCalibRaw()->GetNFailL1Phase(); |
| 241 | // |
| 242 | //production information |
| 243 | // |
| 244 | Int_t nalien=0,nRawAlien=0,nlocal=0,nRawLocal=0; |
| 245 | //run type |
| 246 | TObjString runType(AliTPCcalibDB::GetRunType(irun).Data()); |
| 247 | // |
| 248 | // |
| 249 | // |
| 250 | |
| 251 | for (Int_t itime=startTime; itime<endTime; itime+=dtime){ |
| 252 | // |
| 253 | TTimeStamp tstamp(itime); |
| 254 | Float_t valuePressure = fCalibDB->GetPressure(tstamp,irun,0); |
| 255 | Float_t valuePressure2 = fCalibDB->GetPressure(tstamp,irun,1); |
| 256 | Double_t ptrelative0 = AliTPCcalibDB::GetPTRelative((UInt_t)itime,irun,0); |
| 257 | Double_t ptrelative1 = AliTPCcalibDB::GetPTRelative((UInt_t)itime,irun,1); |
| 258 | //temperature fits |
| 259 | TLinearFitter * fitter = 0; |
| 260 | TVectorD vecTemp[10]; |
| 261 | for (Int_t itype=0; itype<5; itype++) |
| 262 | for (Int_t iside=0; iside<2; iside++){ |
| 263 | fitter= tempMap->GetLinearFitter(itype,iside,tstamp); |
| 264 | if (!fitter) continue; |
| 265 | fitter->Eval(); |
| 266 | fitter->GetParameters(vecTemp[itype+iside*5]); |
| 267 | delete fitter; |
| 268 | } |
| 269 | // |
| 270 | //measured skirt temperatures |
| 271 | // |
| 272 | TVectorD vecSkirtTempA(18); |
| 273 | TVectorD vecSkirtTempC(18); |
| 274 | Int_t nsenTemp=tempArray->NumSensors(); |
| 275 | for (Int_t isenTemp=0;isenTemp<nsenTemp;++isenTemp){ |
| 276 | AliTPCSensorTemp *senTemp=(AliTPCSensorTemp*)tempArray->GetSensorNum(isenTemp); |
| 277 | if (senTemp->GetType()!=3) continue; |
| 278 | if (TMath::Sqrt(senTemp->GetX()*senTemp->GetX()+senTemp->GetY()*senTemp->GetY())<100) continue; //only skirt, outer FC vessel |
| 279 | Double_t val=senTemp->GetValue(tstamp); |
| 280 | if (senTemp->GetSide()==0) |
| 281 | vecSkirtTempA[senTemp->GetSector()]=val; |
| 282 | else |
| 283 | vecSkirtTempC[senTemp->GetSector()]=val; |
| 284 | } |
| 285 | // |
| 286 | //goofie data |
| 287 | // |
| 288 | TVectorD vecGoofie; |
| 289 | if (goofieArray){ |
| 290 | vecGoofie.ResizeTo(goofieArray->NumSensors()); |
| 291 | for (Int_t isensor=0; isensor<goofieArray->NumSensors();isensor++){ |
| 292 | AliDCSSensor *gsensor = goofieArray->GetSensor(isensor); |
| 293 | if (gsensor){ |
| 294 | vecGoofie[isensor] = gsensor->GetValue(tstamp); |
| 295 | } |
| 296 | } |
| 297 | } else { |
| 298 | vecGoofie.ResizeTo(19); |
| 299 | } |
| 300 | // |
| 301 | TVectorD voltagesIROC(36); |
| 302 | TVectorD voltagesOROC(36); |
| 303 | for(Int_t j=1; j<36; j++) voltagesIROC[j-1] = fCalibDB->GetChamberHighVoltage(irun, j,itime); |
| 304 | for(Int_t j=36; j<72; j++) voltagesOROC[j-36] = fCalibDB->GetChamberHighVoltage(irun, j,itime); |
| 305 | Double_t voltIROC = TMath::Median(36, voltagesIROC.GetMatrixArray()); |
| 306 | Double_t voltOROC = TMath::Median(36, voltagesOROC.GetMatrixArray()); |
| 307 | // |
| 308 | Float_t coverIA=AliTPCcalibDB::GetCoverVoltage(irun,0,itime); |
| 309 | Float_t coverIC=AliTPCcalibDB::GetCoverVoltage(irun,18,itime); |
| 310 | Float_t coverOA=AliTPCcalibDB::GetCoverVoltage(irun,36,itime); |
| 311 | Float_t coverOC=AliTPCcalibDB::GetCoverVoltage(irun,54,itime); |
| 312 | Float_t skirtA=AliTPCcalibDB::GetSkirtVoltage(irun,0,itime); |
| 313 | Float_t skirtC=AliTPCcalibDB::GetSkirtVoltage(irun,18,itime); |
| 314 | Float_t ggOffA=AliTPCcalibDB::GetGGoffsetVoltage(irun,0,itime); |
| 315 | Float_t ggOffC=AliTPCcalibDB::GetGGoffsetVoltage(irun,18,itime); |
| 316 | //drift velocity |
| 317 | Float_t dvCorr=-5; |
| 318 | if (fitVdrift) dvCorr=fitVdrift->Eval(itime); |
| 319 | |
| 320 | //tempMap->GetLinearFitter(0,0,itime); |
| 321 | (*fPcstream)<<"dcs"<< |
| 322 | "run="<<irun<< |
| 323 | "time="<<itime<< |
| 324 | "startTimeGRP="<<startTimeGRP<< |
| 325 | "stopTimeGRP="<<stopTimeGRP<< |
| 326 | //run type |
| 327 | "runType.="<<&runType<< |
| 328 | // voltage setting |
| 329 | "VIROC.="<<&voltagesIROC<< |
| 330 | "VOROC.="<<&voltagesOROC<< |
| 331 | "medianVIROC="<<voltIROC<< |
| 332 | "medianVOROC="<<voltOROC<< |
| 333 | "coverIA=" << coverIA << |
| 334 | "coverIC=" << coverIC << |
| 335 | "coverOA=" << coverOA << |
| 336 | "coverOC=" << coverOC << |
| 337 | "skirtA=" << skirtA << |
| 338 | "skirtC=" << skirtC << |
| 339 | "ggOffA=" << ggOffA << |
| 340 | "ggOffC=" << ggOffC << |
| 341 | // |
| 342 | "ptrel0="<<ptrelative0<< // deltaTP/TP - A side |
| 343 | "ptrel1="<<ptrelative1<< // deltaTP/TPC - C side |
| 344 | "goofie.="<<&vecGoofie<< |
| 345 | "goofieE.="<<&vecEntries<< |
| 346 | "goofieMean.="<<&vecMean<< |
| 347 | "goofieMedian.="<<&vecMedian<< |
| 348 | "goofieRMS.="<<&vecRMS<< |
| 349 | // |
| 350 | "press="<<valuePressure<< |
| 351 | "press2="<<valuePressure2<< |
| 352 | "temp00.="<<&vecTemp[0]<< |
| 353 | "temp10.="<<&vecTemp[1]<< |
| 354 | "temp20.="<<&vecTemp[2]<< |
| 355 | "temp30.="<<&vecTemp[3]<< |
| 356 | "temp40.="<<&vecTemp[4]<< |
| 357 | "temp01.="<<&vecTemp[5]<< |
| 358 | "temp11.="<<&vecTemp[6]<< |
| 359 | "temp21.="<<&vecTemp[7]<< |
| 360 | "temp31.="<<&vecTemp[8]<< |
| 361 | "temp41.="<<&vecTemp[9]<< |
| 362 | "tempSkirtA.="<<&vecSkirtTempA<< |
| 363 | "tempSkirtC.="<<&vecSkirtTempC; |
| 364 | |
| 365 | ProcessDrift(irun, itime); |
| 366 | ProcessDriftCE(irun,itime); |
| 367 | ProcessDriftAll(irun,itime); |
| 5f547d58 |
368 | // ProcessKryptonTime(irun,itime); |
| 12f69174 |
369 | ProcessCTP(irun,itime); |
| 370 | ProcessAlign(irun,itime); |
| 371 | ProcessGain(irun,itime); |
| 372 | |
| 373 | |
| 374 | (*fPcstream)<<"dcs"<< |
| 375 | //noise data |
| 376 | "meanNoise.="<<&vNoiseMean<< |
| 377 | "meanNoiseSen.="<<&vNoiseMeanSenRegions<< |
| 378 | "rmsNoise.="<<&vNoiseRMS<< |
| 379 | "rmsNoiseSen.="<<&vNoiseRMSSenRegions<< |
| 380 | "zeroNoise="<<nonMaskedZero<< |
| 381 | "nNaN="<<nNaN<< |
| 382 | //pulser data |
| 383 | "timePulser.=" << &vTimePulser << |
| 384 | "nOffPulser="<<nOffChannels<< |
| 385 | //altro data |
| 386 | "nMasked="<<nMasked<< |
| 387 | //ce data -Jens version |
| 388 | "CEfitA.="<<&fitResultsA<< |
| 389 | "CEfitC.="<<&fitResultsC<< |
| 390 | "nmaskedCE="<<nmaskedCE<< |
| 391 | "chi2ACE="<<chi2ACE<< |
| 392 | "chi2CCE="<<chi2CCE<< |
| 393 | //ce data new - MI version |
| 394 | "CEfitAMI.="<<&fitCEResultsA<< |
| 395 | "CEfitCMI.="<<&fitCEResultsC<< |
| 396 | "chi2CEA="<<chi2CEA<< |
| 397 | "chi2CEC="<<chi2CEC<< |
| 398 | // |
| 399 | //ce graph data |
| 400 | "CEgrTEntries.="<<&vecTEntries<< |
| 401 | "CEgrTMean.="<<&vecTMean<< |
| 402 | "CEgrTRMS.="<<&vecTRMS<< |
| 403 | "CEgrTMedian.="<<&vecTMedian<< |
| 404 | "CEgrQEntries.="<<&vecQEntries<< |
| 405 | "CEgrQMean.="<<&vecQMean<< |
| 406 | "CEgrQRMS.="<<&vecQRMS<< |
| 407 | "CEgrQMedian.="<<&vecQMedian<< |
| 408 | "CEgrDriftA="<<driftTimeA<< |
| 409 | "CEgrDriftC="<<driftTimeC<< |
| 410 | //calib raw data |
| 411 | "nFailL1="<<nFailL1<< |
| 412 | // b field |
| 413 | "Bz="<< bz << |
| 414 | "L3polarity="<<l3pol<< |
| 415 | // production information |
| 416 | "nalien="<<nalien<< |
| 417 | "nRawAlien="<<nRawAlien<< |
| 418 | "nlocal="<<nlocal<< |
| 419 | "nRawLocal="<<nRawLocal<< |
| 420 | //comparisons with ref data |
| 421 | "pedestalDeviations.="<<&pedestalDeviations<< |
| 422 | "noiseDeviations.="<<&noiseDeviations<< |
| 423 | "pulserQdeviations.="<<&pulserQdeviations<< |
| 424 | // "pulserVarQMean="<<varQMean<< |
| 425 | "pulserNpadsOutOneTB="<<npadsOutOneTB<< |
| 426 | "pulserNpadsOffAdd="<<npadsOffAdd<< |
| 427 | "driftCorrCosmAll="<<dvCorr<< |
| 428 | "\n"; |
| 429 | }//end run loop |
| 430 | } |
| 431 | |
| 432 | |
| 433 | |
| 434 | |
| 435 | |
| 436 | |
| 437 | void AliTPCcalibSummary::ProcessDrift(Int_t run, Int_t timeStamp){ |
| 438 | // |
| 439 | // dump drift calibration data to the tree |
| 440 | // |
| 441 | TObjArray *array =fCalibDB->GetTimeVdriftSplineRun(run); |
| 442 | TGraphErrors *laserA[3]={0,0,0}; |
| 443 | TGraphErrors *laserC[3]={0,0,0}; |
| 444 | TGraphErrors *cosmicAll=0; |
| 445 | static Double_t vlaserA[3]={0,0,0}; |
| 446 | static Double_t vlaserC[3]={0,0,0}; |
| 447 | static Double_t vcosmicAll=0; |
| 448 | static Double_t vdrift1=0; |
| 449 | vdrift1=fCalibDB->GetVDriftCorrectionTime(timeStamp,run,0,1); |
| 450 | |
| 451 | if (array){ |
| 452 | laserA[0]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DELAY_LASER_ALL_A"); |
| 453 | laserA[1]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_A"); |
| 454 | laserA[2]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_A"); |
| 455 | laserC[0]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DELAY_LASER_ALL_C"); |
| 456 | laserC[1]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_C"); |
| 457 | laserC[2]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_C"); |
| 458 | cosmicAll =(TGraphErrors*)array->FindObject("TGRAPHERRORS_MEAN_VDRIFT_COSMICS_ALL"); |
| 459 | } |
| 460 | if (laserA[0]) vlaserA[0]= AliTPCcalibDButil::EvalGraphConst(laserA[0],timeStamp); |
| 461 | if (laserA[1]) vlaserA[1]= AliTPCcalibDButil::EvalGraphConst(laserA[1],timeStamp); |
| 462 | if (laserA[2]) vlaserA[2]= AliTPCcalibDButil::EvalGraphConst(laserA[2],timeStamp); |
| 463 | if (laserC[0]) vlaserC[0]= AliTPCcalibDButil::EvalGraphConst(laserC[0],timeStamp); |
| 464 | if (laserC[1]) vlaserC[1]= AliTPCcalibDButil::EvalGraphConst(laserC[1],timeStamp); |
| 465 | if (laserC[2]) vlaserC[2]= AliTPCcalibDButil::EvalGraphConst(laserC[2],timeStamp); |
| 466 | if (cosmicAll) vcosmicAll= AliTPCcalibDButil::EvalGraphConst(cosmicAll,timeStamp); |
| 467 | (*fPcstream)<<"dcs"<< |
| 468 | "vlaserA0="<<vlaserA[0]<< |
| 469 | "vlaserA1="<<vlaserA[1]<< |
| 470 | "vlaserA2="<<vlaserA[2]<< |
| 471 | "vlaserC0="<<vlaserC[0]<< |
| 472 | "vlaserC1="<<vlaserC[1]<< |
| 473 | "vlaserC2="<<vlaserC[2]<< |
| 474 | "vcosmicAll="<<vcosmicAll<< |
| 475 | "vdrift1="<<vdrift1; |
| 476 | |
| 477 | // |
| 478 | // define distance to measurement |
| 479 | // |
| 480 | static Double_t dlaserA=0; |
| 481 | static Double_t dlaserC=0; |
| 482 | static Double_t dcosmic=0; |
| 483 | static Double_t slaserA=0; |
| 484 | static Double_t slaserC=0; |
| 485 | static Double_t scosmic=0; |
| 486 | static Double_t vclaserA[3]={0,0,0}; |
| 487 | static Double_t vclaserC[3]={0,0,0}; |
| 488 | static Double_t vccosmicAll=0; |
| 489 | for (Int_t i=0;i<3;i++){ |
| 490 | if (laserA[i]) AliTPCcalibDButil::GetNearest(laserA[i],timeStamp,dlaserA,vclaserA[i]); |
| 491 | if (laserC[i]) AliTPCcalibDButil::GetNearest(laserC[i],timeStamp,dlaserC,vclaserC[i]); |
| 492 | } |
| 493 | if (cosmicAll) AliTPCcalibDButil::GetNearest(cosmicAll,timeStamp,dcosmic,vccosmicAll); |
| 494 | (*fPcstream)<<"dcs"<< |
| 495 | "vclaserA0="<<vclaserA[0]<< |
| 496 | "vclaserA1="<<vclaserA[1]<< |
| 497 | "vclaserA2="<<vclaserA[2]<< |
| 498 | "vclaserC0="<<vclaserC[0]<< |
| 499 | "vclaserC1="<<vclaserC[1]<< |
| 500 | "vclaserC2="<<vclaserC[2]<< |
| 501 | "vccosmicAll="<<vccosmicAll<< |
| 502 | "dlaserA="<<dlaserA<< |
| 503 | "dlaserC="<<dlaserC<< |
| 504 | "dcosmic="<<dcosmic<< |
| 505 | "slaserA="<<slaserA<< |
| 506 | "slaserC="<<slaserC<< |
| 507 | "scosmic="<<scosmic; |
| 508 | } |
| 509 | |
| 510 | void AliTPCcalibSummary::ProcessDriftCE(Int_t run,Int_t timeStamp){ |
| 511 | // |
| 512 | // dump drift calibration data CE |
| 513 | // |
| 514 | TObjArray *arrT=fCalibDB->GetCErocTtime(); |
| 515 | AliTPCParam *param=fCalibDB->GetParameters(); |
| 516 | static TVectorD tdriftCE(74); |
| 517 | static TVectorD tndriftCE(74); |
| 518 | static TVectorD vdriftCE(74); |
| 519 | static TVectorD tcdriftCE(74); |
| 520 | static TVectorD tddriftCE(74); |
| 521 | static Double_t ltime0A; |
| 522 | static Double_t ltime0C; |
| 523 | // |
| 524 | // |
| 525 | // |
| 526 | ltime0A = fDButil->GetLaserTime0(run,timeStamp,36000,0); |
| 527 | ltime0C = fDButil->GetLaserTime0(run,timeStamp,36000,1); |
| 528 | // |
| 529 | for (Int_t i=0; i<arrT->GetEntries();i++){ |
| 530 | tdriftCE[i]=0; |
| 531 | vdriftCE[i]=0; |
| 532 | TGraph *graph = (TGraph*)arrT->At(i); |
| 533 | if (!graph) continue; |
| 534 | tdriftCE[i]=AliTPCcalibDButil::EvalGraphConst(graph,timeStamp); |
| 535 | Double_t deltaT,gry; |
| 536 | AliTPCcalibDButil::GetNearest(graph,timeStamp,deltaT,gry); |
| 537 | tndriftCE[i]=graph->GetN(); |
| 538 | tcdriftCE[i]=gry; |
| 539 | tddriftCE[i]=deltaT; |
| 540 | if (i%36<18){ |
| 541 | vdriftCE[i] =(param->GetZLength(i)/(tdriftCE[i]*param->GetTSample()*(1.-ltime0A)-param->GetL1Delay()))/param->GetDriftV(); |
| 542 | }else{ |
| 543 | vdriftCE[i] =(param->GetZLength(i)/(tdriftCE[i]*param->GetTSample()*(1.-ltime0A)-param->GetL1Delay()))/param->GetDriftV(); |
| 544 | } |
| 545 | } |
| 546 | // export values |
| 547 | (*fPcstream)<<"dcs"<< |
| 548 | "tdriftCE.="<<&tdriftCE<< // arrival time |
| 549 | "vdriftCE.="<<&vdriftCE<< // derived drift velocity per chamber |
| 550 | "tndriftCE.="<<&tndriftCE<< // number of points (chambers) |
| 551 | "tcdriftCE.="<<&tcdriftCE<< // constant evaluation - nearest point used |
| 552 | "tddriftCE.="<<&tddriftCE<< // distance to closest measuement |
| 553 | "ltime0A="<<ltime0A<< // laser offset expected in reconstruction |
| 554 | "ltime0C="<<ltime0C; // laser offset expected in reconstruction |
| 555 | } |
| 556 | |
| 557 | |
| 558 | void AliTPCcalibSummary::ProcessDriftAll(Int_t run,Int_t timeStamp){ |
| 559 | // |
| 560 | // dump drift calibration data all calibrations form DB util |
| 561 | // test of utils |
| 562 | static Double_t vdriftCEA=0, vdriftCEC=0, vdriftCEM=0; |
| 563 | static Double_t vdriftLTA=0, vdriftLTC=0, vdriftLTM=0; |
| 564 | static Double_t vdriftITS=0; |
| 565 | static Double_t vdriftP=0; |
| 566 | static Double_t dcea=0, dcec=0, dcem=0, dla=0,dlc=0,dlm=0,dp=0; |
| 567 | static Double_t dits=0; |
| 568 | static Double_t ltime0A; |
| 569 | static Double_t ltime0C; |
| 570 | static Double_t ctime0; |
| 571 | static Double_t vdrift1=0; |
| 572 | vdrift1= fCalibDB->GetVDriftCorrectionTime(timeStamp,run,0,1); |
| 573 | vdriftP = fDButil->GetVDriftTPC(dp, run, timeStamp, 86400, 3600,0); |
| 574 | ctime0 = AliTPCcalibDButil::GetTriggerOffsetTPC(run,timeStamp, 36000, 3600,0); |
| 575 | // |
| 576 | vdriftCEA= fDButil->GetVDriftTPCCE(dcea,run,timeStamp,36000,0); |
| 577 | vdriftCEC= fDButil->GetVDriftTPCCE(dcec,run,timeStamp,36000,1); |
| 578 | vdriftCEM= fDButil->GetVDriftTPCCE(dcem,run,timeStamp,36000,2); |
| 579 | // |
| 580 | vdriftLTA= fDButil->GetVDriftTPCLaserTracks(dla,run,timeStamp,36000,0); |
| 581 | vdriftLTC= fDButil->GetVDriftTPCLaserTracks(dlc,run,timeStamp,36000,1); |
| 582 | vdriftLTM= fDButil->GetVDriftTPCLaserTracks(dlm,run,timeStamp,36000,2); |
| 583 | // |
| 584 | vdriftITS= fDButil->GetVDriftTPCITS(dits, run,timeStamp); |
| 585 | // |
| 586 | ltime0A = fDButil->GetLaserTime0(run,timeStamp,36000,0); |
| 587 | ltime0C = fDButil->GetLaserTime0(run,timeStamp,36000,1); |
| 588 | |
| 589 | (*fPcstream)<<"dcs"<< |
| 590 | // |
| 591 | "vdriftCEA="<<vdriftCEA<< // drift velocity CE |
| 592 | "vdriftCEC="<<vdriftCEC<< |
| 593 | "vdriftCEM="<<vdriftCEM<< |
| 594 | "dcea="<<dcea<< |
| 595 | "dcec="<<dcec<< |
| 596 | "dcem="<<dcem<< |
| 597 | "vdriftLTA="<<vdriftLTA<< // drift velocity laser tracks |
| 598 | "vdriftLTC="<<vdriftLTC<< |
| 599 | "vdriftLTM="<<vdriftLTM<< |
| 600 | "dla="<<dla<< |
| 601 | "dlc="<<dlc<< |
| 602 | "dlm="<<dlm<< |
| 603 | // |
| 604 | // |
| 605 | "vdriftITS="<<vdriftITS<< |
| 606 | "dits="<<dits<< |
| 607 | "ctime0="<<ctime0<< |
| 608 | "vdriftP="<<vdriftP<< // drift velocity comsic |
| 609 | "dp="<<dp<< |
| 610 | "vdrift1="<<vdrift1; // combined drift velocity |
| 611 | |
| 612 | } |
| 613 | |
| 614 | |
| 615 | |
| 616 | void AliTPCcalibSummary::ProcessKryptonTime(Int_t run, Int_t timeStamp){ |
| 617 | // |
| 618 | // Dumping krypton calibration results |
| 619 | // |
| 620 | static TObjArray * krArray=0; |
| 621 | if (!krArray) { |
| 622 | AliCDBEntry* entry = AliCDBManager::Instance()->Get("TPC/Calib/TimeGainKrypton", run); |
| 623 | if (entry){ |
| 624 | krArray = (TObjArray*)entry->GetObject(); |
| 625 | } |
| 626 | } |
| 627 | static TVectorD krMean(74); |
| 628 | static TVectorD krErr(74); |
| 629 | static TVectorD krDist(74); |
| 630 | TGraphErrors *gr=0; |
| 631 | Double_t deltaT=0,gry=0; |
| 632 | if (krArray){ |
| 633 | for (Int_t isec=0; isec<72; isec++){ |
| 634 | krMean[isec]=0; |
| 635 | krDist[isec]=0; |
| 636 | krErr[isec]=0; |
| 637 | gr=(TGraphErrors*)krArray->At(isec); |
| 638 | if (gr) { |
| 639 | krMean[isec]=gr->Eval(timeStamp); |
| 640 | AliTPCcalibDButil::GetNearest(gr, timeStamp,deltaT,gry); |
| 641 | krDist[isec]=deltaT; |
| 642 | } |
| 643 | if (72+isec<krArray->GetEntries()) { |
| 644 | gr=(TGraphErrors*)krArray->At(72+isec); |
| 645 | if (gr) krErr[isec]=gr->Eval(timeStamp); |
| 646 | } |
| 647 | } |
| 648 | krMean[72]= TMath::Median(36,krMean.GetMatrixArray()); |
| 649 | krMean[73]= TMath::Median(36,&(krMean.GetMatrixArray()[36])); |
| 650 | krErr[72]= TMath::Median(36,krErr.GetMatrixArray()); |
| 651 | krErr[73]= TMath::Median(36,&(krErr.GetMatrixArray()[36])); |
| 652 | } |
| 653 | (*fPcstream)<<"dcs"<< |
| 654 | "krMean.="<<&krMean<< |
| 655 | "krErr.="<<&krErr<< |
| 656 | "krDist.="<<&krDist; |
| 657 | } |
| 658 | |
| 659 | void AliTPCcalibSummary::ProcessCTP(Int_t irun, Int_t timeStamp){ |
| 660 | // |
| 661 | // |
| 662 | // |
| 663 | static TClonesArray *pcarray = new TClonesArray("AliCTPInputTimeParams",1); |
| 664 | static AliCTPTimeParams *ctpParams =0; |
| 665 | ctpParams = fCalibDB->GetCTPTimeParams(); // |
| 666 | const TObjArray *arr = ctpParams->GetInputTimeParams(); |
| 667 | pcarray->ExpandCreateFast(TMath::Max(arr->GetEntries(),1)); |
| 668 | for (Int_t i=0; i<arr->GetEntries(); i++){ |
| 669 | new ((*pcarray)[i]) AliCTPInputTimeParams(*((AliCTPInputTimeParams*)arr->At(i))); |
| 670 | } |
| 671 | (*fPcstream)<<"ctp"<< |
| 672 | "run="<<irun<< |
| 673 | "time="<<timeStamp<< |
| 674 | "ctpP.="<<ctpParams<< |
| 675 | "ctpArr="<<pcarray<< |
| 676 | "\n"; |
| 677 | (*fPcstream)<<"dcs"<< |
| 678 | "ctpP.="<<ctpParams<< |
| 679 | "ctpArr="<<pcarray; |
| 680 | } |
| 681 | |
| 682 | void AliTPCcalibSummary::ProcessGain(Int_t irun, Int_t timeStamp){ |
| 683 | // |
| 684 | // Dump gain related information to the tree |
| 685 | // |
| 686 | static Float_t gainCosmic = 0; |
| 687 | static Float_t gainMIP = 0; |
| 688 | TObjArray * gainSplines = fCalibDB->GetTimeGainSplinesRun(irun); |
| 689 | if (gainSplines) { |
| 690 | TGraphErrors * graphMIP = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_GAIN_BEAM_ALL"); |
| 691 | TGraphErrors * graphCosmic = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_GAIN_COSMIC_ALL"); |
| 692 | if (graphMIP) gainMIP = AliTPCcalibDButil::EvalGraphConst(graphMIP,timeStamp); |
| 693 | if (graphCosmic) gainCosmic = AliTPCcalibDButil::EvalGraphConst(graphCosmic,timeStamp); |
| 694 | } |
| 695 | // time dependence of gain |
| 696 | (*fPcstream)<<"dcs"<< |
| 697 | "gainMIP="<<gainMIP<< |
| 698 | "gainCosmic="<<gainCosmic; |
| 699 | } |
| 700 | |
| 701 | |
| 702 | void AliTPCcalibSummary::ProcessAlign(Int_t run, Int_t timeStamp){ |
| 703 | // |
| 704 | // Proccess alignment |
| 705 | // |
| 706 | TString grnames[12]={"ALIGN_ITS", "ALIGN_ITSP", "ALIGN_ITSM", "ALIGN_ITSB", |
| 707 | "ALIGN_TRD", "ALIGN_TRDP", "ALIGN_TRDM","ALIGN_TRDB", |
| 708 | "ALIGN_TOF", "ALIGN_TOFP", "ALIGN_TOFM","ALIGN_TOFB"}; |
| 709 | TString grpar[9]={"DELTAPSI", "DELTATHETA", "DELTAPHI", |
| 710 | "DELTAX", "DELTAY", "DELTAZ", |
| 711 | "DRIFTVD", "T0", "VDGY"}; |
| 712 | static Double_t values[12*9]; |
| 713 | static Double_t errs[12*9]; |
| 714 | |
| 715 | TObjArray *array =fCalibDB->GetTimeVdriftSplineRun(run); |
| 716 | TGraphErrors *gr=0; |
| 717 | for (Int_t idet=0; idet<12; idet++){ |
| 718 | for (Int_t ipar=0; ipar<9; ipar++){ |
| 719 | TString grName=grnames[idet]; |
| 720 | grName+="_TPC_"; |
| 721 | grName+=grpar[ipar]; |
| 722 | if (array){ |
| 723 | gr = (TGraphErrors*)array->FindObject(grName.Data()); |
| 724 | } |
| 725 | values[9*idet+ipar]=0; |
| 726 | errs[9*idet+ipar]=0; |
| 727 | if (gr) values[9*idet+ipar]=gr->Eval(timeStamp); |
| 728 | (*fPcstream)<<"dcs"<< |
| 729 | Form("%s=",grName.Data())<<values[9*idet+ipar]; |
| 730 | (*fPcstream)<<"align"<< |
| 731 | Form("%s=",grName.Data())<<values[9*idet+ipar]; |
| 732 | } |
| 733 | } |
| 734 | (*fPcstream)<<"align"<< |
| 735 | "time="<<timeStamp<< |
| 736 | "run="<<run<< |
| 737 | "\n"; |
| 738 | } |
| 739 | |
| 740 | |
| 741 | |
git://git.uio.no / u / mrichter / AliRoot.git / blame