| 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> |
| af6a50bb |
59 | #include <TStatToolkit.h> |
| 99369b07 |
60 | #include <TCut.h> |
| 61 | #include "AliTPCCalibGlobalMisalignment.h" |
| 62 | #include "AliTPCExBTwist.h" |
| 63 | #include "AliTPCComposedCorrection.h" |
| 12f69174 |
64 | // |
| 65 | // |
| 66 | // |
| 67 | AliTPCcalibSummary::AliTPCcalibSummary(): |
| 68 | TNamed(), |
| 69 | fCalibDB(0), |
| 70 | fDButil(0), |
| 71 | fPcstream(0) |
| 72 | { |
| 73 | // |
| 74 | // default constructor |
| 75 | // OCDB have to be setupe before - not part of class |
| 76 | // usualy ConfigOCDB.C macro used |
| 77 | // |
| 78 | fPcstream = new TTreeSRedirector("dcsTime.root"); |
| 79 | fCalibDB = AliTPCcalibDB::Instance(); |
| 80 | fDButil= new AliTPCcalibDButil; |
| 81 | } |
| 82 | |
| 83 | AliTPCcalibSummary::~AliTPCcalibSummary(){ |
| 84 | // |
| 85 | // destructor - close streamer |
| 86 | // |
| 87 | delete fPcstream; |
| 88 | } |
| 89 | |
| 90 | void AliTPCcalibSummary::Process(const char * runList, Int_t first, Int_t last){ |
| 91 | // |
| 92 | // runList - listOfRuns to process |
| 93 | // first - first run to process |
| 94 | // last - last to process |
| 95 | // |
| 96 | // |
| 97 | // make list of runs |
| 98 | // |
| 99 | |
| 100 | ifstream inputFile; |
| 101 | inputFile.open("run.list"); |
| 102 | Int_t irun=0; |
| 103 | TArrayI runArray(100000); |
| 104 | Int_t indexes[100000]; |
| 105 | Int_t nruns=0; |
| 106 | printf("Runs to process:\n"); |
| 107 | if (!inputFile.is_open()) { |
| 108 | printf("Problem to open file %s\n",runList); |
| 109 | } |
| 110 | while( inputFile.good() ) { |
| 111 | inputFile >> irun; |
| 112 | printf("Run \t%d\n",irun); |
| 113 | if (irun<first) continue; // process only subset of list |
| 114 | if (last>0 && irun>last) continue; // process only subset of list |
| 115 | runArray[nruns]=irun; |
| 116 | nruns++; |
| 117 | } |
| 118 | |
| 119 | |
| 120 | TMath::Sort(nruns, runArray.fArray, indexes,kFALSE); |
| 121 | Int_t startTime = 0; |
| 122 | Int_t endTime = 0; |
| 123 | for (Int_t run=0; run<nruns; run++){ |
| 124 | irun=runArray[indexes[run]]; |
| 125 | printf("Processing run %d ...\n",irun); |
| 126 | fCalibDB->SetRun(irun); |
| 127 | fDButil->UpdateFromCalibDB(); |
| 128 | fDButil->SetReferenceRun(irun); |
| 129 | fDButil->UpdateRefDataFromOCDB(); |
| af6a50bb |
130 | fCalibDB->CreateGUITree("calPads.root"); |
| 131 | fDButil->CreateGUIRefTree("calPadsRef.root"); |
| 12f69174 |
132 | // |
| 133 | AliDCSSensorArray *arrHV=fCalibDB->GetVoltageSensors(irun); |
| 134 | if (!arrHV) continue; |
| 135 | for (Int_t isenHV=0; isenHV<arrHV->NumSensors(); ++isenHV){ |
| 136 | AliDCSSensor *senHV=arrHV->GetSensorNum(isenHV); |
| 137 | if (!senHV) { |
| 138 | printf("Not interesting OCDB info\n"); |
| 139 | continue; |
| 140 | } |
| 141 | startTime=senHV->GetStartTime(); |
| 142 | endTime =senHV->GetEndTime(); |
| 143 | if (startTime>0&&endTime>0) break; |
| 144 | } |
| 145 | AliDCSSensorArray* goofieArray = fCalibDB->GetGoofieSensors(irun); |
| 99369b07 |
146 | if (goofieArray) fDButil->FilterGoofie(goofieArray,0.5,4.,4,10,fPcstream); |
| 12f69174 |
147 | // don't filter goofie for the moment |
| 148 | ProcessRun(irun, startTime,endTime); |
| 149 | } |
| 150 | } |
| 151 | |
| 152 | |
| 153 | void AliTPCcalibSummary::ProcessRun(Int_t irun, Int_t startTime, Int_t endTime){ |
| 154 | // |
| 155 | // Process run irun |
| 156 | // |
| 157 | fCalibDB->SetRun(irun); |
| 158 | fDButil->UpdateFromCalibDB(); |
| 159 | fDButil->SetReferenceRun(irun); |
| 160 | fDButil->UpdateRefDataFromOCDB(); |
| af6a50bb |
161 | fCalibDB->CreateGUITree("calPads.root"); |
| 162 | fDButil->CreateGUIRefTree("calPadsRef.root"); |
| 163 | |
| 12f69174 |
164 | // |
| 165 | AliSplineFit *fitVdrift=0x0; |
| 166 | Int_t startTimeGRP=0, stopTimeGRP=0; |
| 167 | if (fCalibDB->GetGRP(irun)){ |
| 168 | startTimeGRP = AliTPCcalibDB::GetGRP(irun)->GetTimeStart(); |
| 169 | stopTimeGRP = AliTPCcalibDB::GetGRP(irun)->GetTimeEnd(); |
| 170 | } |
| 171 | if (startTime==0){ |
| 172 | startTime=startTimeGRP; |
| 173 | endTime=stopTimeGRP; |
| 174 | } |
| 175 | AliTPCSensorTempArray * tempArray = fCalibDB->GetTemperatureSensor(irun); |
| 176 | AliTPCTempMap * tempMap = new AliTPCTempMap(tempArray); |
| 177 | AliDCSSensorArray* goofieArray = fCalibDB->GetGoofieSensors(irun); |
| 178 | // |
| a3b590cf |
179 | Int_t dtime = TMath::Max((endTime-startTime)/20,10); |
| 12f69174 |
180 | // |
| 181 | //Goofie statistical data |
| 182 | // |
| 183 | TVectorD vecEntries, vecMean, vecMedian,vecRMS; |
| 184 | fDButil->ProcessGoofie(vecEntries ,vecMedian, vecMean, vecRMS); |
| 185 | // |
| 186 | //CE data processing - see ProcessCEdata function for description of the results |
| 187 | // |
| 188 | TVectorD fitResultsA, fitResultsC; |
| 189 | Int_t nmaskedCE; |
| 190 | Double_t chi2ACE=0,chi2CCE=0; |
| 191 | // fDButil->ProcessCEdata("(sector<36)++gx++gy++lx++lx**2",fitResultsA,fitResultsC,nmaskedCE); |
| 192 | fDButil->ProcessCEdata("(sector<36)++gx++gy++(lx-134)++(sector<36)*(lx-134)++(ly/lx)^2",fitResultsA,fitResultsC,nmaskedCE,chi2ACE,chi2CCE); |
| 193 | |
| 194 | TVectorD fitCEResultsA(7), fitCEResultsC(7); |
| 195 | Int_t noutCE; |
| 196 | Double_t chi2CEA=0,chi2CEC=0; |
| 197 | AliTPCCalPad *time0 = fDButil->CreatePadTime0CE(fitCEResultsA, fitCEResultsC, noutCE, chi2CEA, chi2CEC); |
| 198 | delete time0; |
| 199 | // |
| 200 | // |
| 201 | TVectorD vecTEntries, vecTMean, vecTRMS, vecTMedian, vecQEntries, vecQMean, vecQRMS, vecQMedian; |
| 202 | Float_t driftTimeA, driftTimeC; |
| 203 | fDButil->ProcessCEgraphs(vecTEntries, vecTMean, vecTRMS, vecTMedian, |
| 204 | vecQEntries, vecQMean, vecQRMS, vecQMedian, |
| 205 | driftTimeA, driftTimeC ); |
| 206 | // |
| 207 | // |
| 208 | // |
| 209 | //drift velocity using tracks |
| 210 | // |
| 211 | // fitVdrift=fCalibDB->GetVdriftSplineFit("ALISPLINEFIT_MEAN_VDRIFT_COSMICS_ALL",irun); |
| 212 | fitVdrift=fCalibDB->CreateVdriftSplineFit("TGRAPHERRORS_MEAN_VDRIFT_COSMICS_ALL",irun); |
| 213 | //noise data Processing - see ProcessNoiseData function for description of the results |
| 214 | TVectorD vNoiseMean, vNoiseMeanSenRegions, vNoiseRMS, vNoiseRMSSenRegions; |
| 215 | Int_t nonMaskedZero=0, nNaN=0; |
| 216 | fDButil->ProcessNoiseData(vNoiseMean, vNoiseMeanSenRegions, vNoiseRMS, vNoiseRMSSenRegions, nonMaskedZero, nNaN); |
| 217 | // |
| 218 | // comparisons |
| 219 | // |
| 220 | TVectorF pedestalDeviations; |
| 221 | TVectorF noiseDeviations; |
| 222 | TVectorF pulserQdeviations; |
| 223 | Float_t varQMean; |
| 224 | Int_t npadsOutOneTB; |
| 225 | Int_t npadsOffAdd; |
| 226 | fDButil->ProcessPedestalVariations(pedestalDeviations); |
| 227 | fDButil->ProcessNoiseVariations(noiseDeviations); |
| 228 | fDButil->ProcessPulserVariations(pulserQdeviations,varQMean,npadsOutOneTB,npadsOffAdd); |
| 229 | // |
| 230 | //L3 data |
| 231 | // |
| 5b1577ef |
232 | Float_t bz=AliTPCcalibDB::GetBz(irun); |
| 233 | Char_t l3pol=AliTPCcalibDB::GetL3Polarity(irun); |
| 12f69174 |
234 | // |
| abb20887 |
235 | //QA data processing |
| 236 | // |
| 237 | TVectorD vQaOcc; |
| 238 | TVectorD vQaQtot; |
| 239 | TVectorD vQaQmax; |
| 240 | fDButil->ProcessQAData(vQaOcc, vQaQtot, vQaQmax); |
| 241 | // |
| 12f69174 |
242 | //calibration Pulser data processing |
| 243 | // |
| 244 | Int_t nOffChannels=0; |
| 245 | TVectorD vTimePulser; |
| 246 | nOffChannels=fDButil->GetNPulserOutliers(); |
| 247 | fDButil->ProcessPulser(vTimePulser); |
| 248 | // |
| 249 | //ALTRO data |
| 250 | // |
| 251 | Int_t nMasked=0; |
| 252 | fDButil->ProcessALTROConfig(nMasked); |
| 253 | // |
| 254 | //Calib RAW data |
| 255 | // |
| 256 | Int_t nFailL1=-1; |
| 257 | if (fCalibDB->GetCalibRaw()) nFailL1=fCalibDB->GetCalibRaw()->GetNFailL1Phase(); |
| 258 | // |
| 259 | //production information |
| 260 | // |
| 261 | Int_t nalien=0,nRawAlien=0,nlocal=0,nRawLocal=0; |
| 262 | //run type |
| 263 | TObjString runType(AliTPCcalibDB::GetRunType(irun).Data()); |
| 264 | // |
| 265 | // |
| 266 | // |
| 267 | |
| 268 | for (Int_t itime=startTime; itime<endTime; itime+=dtime){ |
| 269 | // |
| 270 | TTimeStamp tstamp(itime); |
| 271 | Float_t valuePressure = fCalibDB->GetPressure(tstamp,irun,0); |
| 272 | Float_t valuePressure2 = fCalibDB->GetPressure(tstamp,irun,1); |
| 273 | Double_t ptrelative0 = AliTPCcalibDB::GetPTRelative((UInt_t)itime,irun,0); |
| 274 | Double_t ptrelative1 = AliTPCcalibDB::GetPTRelative((UInt_t)itime,irun,1); |
| 275 | //temperature fits |
| 276 | TLinearFitter * fitter = 0; |
| 277 | TVectorD vecTemp[10]; |
| 278 | for (Int_t itype=0; itype<5; itype++) |
| 279 | for (Int_t iside=0; iside<2; iside++){ |
| 280 | fitter= tempMap->GetLinearFitter(itype,iside,tstamp); |
| 281 | if (!fitter) continue; |
| 282 | fitter->Eval(); |
| 283 | fitter->GetParameters(vecTemp[itype+iside*5]); |
| 284 | delete fitter; |
| 285 | } |
| 286 | // |
| 287 | //measured skirt temperatures |
| 288 | // |
| 289 | TVectorD vecSkirtTempA(18); |
| 290 | TVectorD vecSkirtTempC(18); |
| 291 | Int_t nsenTemp=tempArray->NumSensors(); |
| 292 | for (Int_t isenTemp=0;isenTemp<nsenTemp;++isenTemp){ |
| 293 | AliTPCSensorTemp *senTemp=(AliTPCSensorTemp*)tempArray->GetSensorNum(isenTemp); |
| 294 | if (senTemp->GetType()!=3) continue; |
| 295 | if (TMath::Sqrt(senTemp->GetX()*senTemp->GetX()+senTemp->GetY()*senTemp->GetY())<100) continue; //only skirt, outer FC vessel |
| 296 | Double_t val=senTemp->GetValue(tstamp); |
| 297 | if (senTemp->GetSide()==0) |
| 298 | vecSkirtTempA[senTemp->GetSector()]=val; |
| 299 | else |
| 300 | vecSkirtTempC[senTemp->GetSector()]=val; |
| 301 | } |
| 302 | // |
| 303 | //goofie data |
| 304 | // |
| 305 | TVectorD vecGoofie; |
| 306 | if (goofieArray){ |
| 307 | vecGoofie.ResizeTo(goofieArray->NumSensors()); |
| 308 | for (Int_t isensor=0; isensor<goofieArray->NumSensors();isensor++){ |
| 309 | AliDCSSensor *gsensor = goofieArray->GetSensor(isensor); |
| 310 | if (gsensor){ |
| 311 | vecGoofie[isensor] = gsensor->GetValue(tstamp); |
| 312 | } |
| 313 | } |
| 314 | } else { |
| 315 | vecGoofie.ResizeTo(19); |
| 316 | } |
| 317 | // |
| 661f340b |
318 | static TVectorF voltagesIROC(36); |
| 319 | static TVectorF voltagesIROCMedian(36); |
| 320 | static TVectorF voltagesIROCNominal(36); |
| 321 | static TVectorF voltagesIROCCurrentNominal(36); |
| 322 | static TVectorF voltagesIROCStatus(36); |
| 323 | static TVectorF voltagesIROCGoodFraction(36); |
| 324 | // |
| 325 | static TVectorF voltagesOROC(36); |
| 326 | static TVectorF voltagesOROCMedian(36); |
| 327 | static TVectorF voltagesOROCNominal(36); |
| 328 | static TVectorF voltagesOROCCurrentNominal(36); |
| 329 | static TVectorF voltagesOROCStatus(36); |
| 330 | static TVectorF voltagesOROCGoodFraction(36); |
| 331 | |
| 332 | for(Int_t j=0; j<36; j++){ |
| 333 | voltagesIROC[j] = fCalibDB->GetChamberHighVoltage(irun, j,itime); |
| 334 | voltagesIROCMedian[j] = fCalibDB->GetChamberHighVoltageMedian(j); |
| 335 | voltagesIROCNominal[j] = fCalibDB->GetParameters()->GetNominalVoltage(j); |
| 336 | voltagesIROCCurrentNominal[j] = fCalibDB->GetChamberCurrentNominalHighVoltage(j); |
| 337 | voltagesIROCStatus[j] = fCalibDB->GetChamberHVStatus(j); |
| 338 | voltagesIROCGoodFraction[j] = fCalibDB->GetChamberGoodHighVoltageFraction(j); |
| 339 | } |
| 340 | |
| 341 | for(Int_t j=36; j<72; j++) { |
| 342 | voltagesOROC[j-36] = fCalibDB->GetChamberHighVoltage(irun, j,itime); |
| 343 | voltagesOROCMedian[j-36] = fCalibDB->GetChamberHighVoltageMedian(j); |
| 344 | voltagesOROCNominal[j-36] = fCalibDB->GetParameters()->GetNominalVoltage(j); |
| 345 | voltagesOROCCurrentNominal[j-36] = fCalibDB->GetChamberCurrentNominalHighVoltage(j); |
| 346 | voltagesOROCStatus[j-36] = fCalibDB->GetChamberHVStatus(j); |
| 347 | voltagesOROCGoodFraction[j-36] = fCalibDB->GetChamberGoodHighVoltageFraction(j); |
| 348 | } |
| 349 | |
| 12f69174 |
350 | Double_t voltIROC = TMath::Median(36, voltagesIROC.GetMatrixArray()); |
| 351 | Double_t voltOROC = TMath::Median(36, voltagesOROC.GetMatrixArray()); |
| 352 | // |
| 353 | Float_t coverIA=AliTPCcalibDB::GetCoverVoltage(irun,0,itime); |
| 354 | Float_t coverIC=AliTPCcalibDB::GetCoverVoltage(irun,18,itime); |
| 355 | Float_t coverOA=AliTPCcalibDB::GetCoverVoltage(irun,36,itime); |
| 356 | Float_t coverOC=AliTPCcalibDB::GetCoverVoltage(irun,54,itime); |
| 357 | Float_t skirtA=AliTPCcalibDB::GetSkirtVoltage(irun,0,itime); |
| 358 | Float_t skirtC=AliTPCcalibDB::GetSkirtVoltage(irun,18,itime); |
| 359 | Float_t ggOffA=AliTPCcalibDB::GetGGoffsetVoltage(irun,0,itime); |
| 360 | Float_t ggOffC=AliTPCcalibDB::GetGGoffsetVoltage(irun,18,itime); |
| 361 | //drift velocity |
| 362 | Float_t dvCorr=-5; |
| 363 | if (fitVdrift) dvCorr=fitVdrift->Eval(itime); |
| 661f340b |
364 | //data taking active |
| 365 | Bool_t dataTakingActive=fCalibDB->IsDataTakingActive((time_t)itime); |
| 12f69174 |
366 | |
| 367 | //tempMap->GetLinearFitter(0,0,itime); |
| 368 | (*fPcstream)<<"dcs"<< |
| 369 | "run="<<irun<< |
| 370 | "time="<<itime<< |
| 371 | "startTimeGRP="<<startTimeGRP<< |
| 372 | "stopTimeGRP="<<stopTimeGRP<< |
| 661f340b |
373 | "dataTakingActive="<<dataTakingActive<< |
| 12f69174 |
374 | //run type |
| 375 | "runType.="<<&runType<< |
| 376 | // voltage setting |
| 661f340b |
377 | "VIROC.=" << &voltagesIROC<< |
| 378 | "VIROCMedian.=" << &voltagesIROCMedian<< |
| 379 | "VIROCNominal.=" << &voltagesIROCNominal << |
| 380 | "VIROCCurrentNominal.=" << &voltagesIROCCurrentNominal << |
| 381 | "VIROCGoodHVFraction.=" << &voltagesIROCGoodFraction << |
| 382 | "VIROCStatus.=" << &voltagesIROCStatus << |
| 383 | // |
| 384 | "VOROC.=" << &voltagesOROC<< |
| 385 | "VOROCMedian.=" << &voltagesOROCMedian<< |
| 386 | "VOROCNominal.=" << &voltagesOROCNominal << |
| 387 | "VOROCCurrentNominal.=" << &voltagesOROCCurrentNominal << |
| 388 | "VOROCGoodHVFraction.=" << &voltagesOROCGoodFraction << |
| 389 | "VOROCStatus.=" << &voltagesOROCStatus << |
| 12f69174 |
390 | "medianVIROC="<<voltIROC<< |
| 391 | "medianVOROC="<<voltOROC<< |
| 392 | "coverIA=" << coverIA << |
| 393 | "coverIC=" << coverIC << |
| 394 | "coverOA=" << coverOA << |
| 395 | "coverOC=" << coverOC << |
| 396 | "skirtA=" << skirtA << |
| 397 | "skirtC=" << skirtC << |
| 398 | "ggOffA=" << ggOffA << |
| 399 | "ggOffC=" << ggOffC << |
| 400 | // |
| 401 | "ptrel0="<<ptrelative0<< // deltaTP/TP - A side |
| 402 | "ptrel1="<<ptrelative1<< // deltaTP/TPC - C side |
| 403 | "goofie.="<<&vecGoofie<< |
| 404 | "goofieE.="<<&vecEntries<< |
| 405 | "goofieMean.="<<&vecMean<< |
| 406 | "goofieMedian.="<<&vecMedian<< |
| 407 | "goofieRMS.="<<&vecRMS<< |
| 408 | // |
| 409 | "press="<<valuePressure<< |
| 410 | "press2="<<valuePressure2<< |
| 411 | "temp00.="<<&vecTemp[0]<< |
| 412 | "temp10.="<<&vecTemp[1]<< |
| 413 | "temp20.="<<&vecTemp[2]<< |
| 414 | "temp30.="<<&vecTemp[3]<< |
| 415 | "temp40.="<<&vecTemp[4]<< |
| 416 | "temp01.="<<&vecTemp[5]<< |
| 417 | "temp11.="<<&vecTemp[6]<< |
| 418 | "temp21.="<<&vecTemp[7]<< |
| 419 | "temp31.="<<&vecTemp[8]<< |
| 420 | "temp41.="<<&vecTemp[9]<< |
| 421 | "tempSkirtA.="<<&vecSkirtTempA<< |
| 422 | "tempSkirtC.="<<&vecSkirtTempC; |
| 423 | |
| 424 | ProcessDrift(irun, itime); |
| 425 | ProcessDriftCE(irun,itime); |
| 426 | ProcessDriftAll(irun,itime); |
| 5f547d58 |
427 | // ProcessKryptonTime(irun,itime); |
| 12f69174 |
428 | ProcessCTP(irun,itime); |
| 429 | ProcessAlign(irun,itime); |
| 430 | ProcessGain(irun,itime); |
| a3b590cf |
431 | //ProcessDriftCERef(); |
| 432 | //ProcessPulserRef(); |
| 5b1577ef |
433 | //ProcessCurrent(irun,itime); |
| 12f69174 |
434 | |
| 435 | |
| 436 | (*fPcstream)<<"dcs"<< |
| 437 | //noise data |
| 438 | "meanNoise.="<<&vNoiseMean<< |
| 439 | "meanNoiseSen.="<<&vNoiseMeanSenRegions<< |
| 440 | "rmsNoise.="<<&vNoiseRMS<< |
| 441 | "rmsNoiseSen.="<<&vNoiseRMSSenRegions<< |
| 442 | "zeroNoise="<<nonMaskedZero<< |
| abb20887 |
443 | "nNaN="<<nNaN<< |
| 444 | //QA data |
| 445 | "occQA.=" << &vQaOcc << |
| 446 | "qQA.=" << &vQaQtot << |
| 447 | "qmaxQA.=" << &vQaQmax << |
| 12f69174 |
448 | //pulser data |
| 449 | "timePulser.=" << &vTimePulser << |
| 450 | "nOffPulser="<<nOffChannels<< |
| 451 | //altro data |
| 452 | "nMasked="<<nMasked<< |
| 453 | //ce data -Jens version |
| 454 | "CEfitA.="<<&fitResultsA<< |
| 455 | "CEfitC.="<<&fitResultsC<< |
| 456 | "nmaskedCE="<<nmaskedCE<< |
| 457 | "chi2ACE="<<chi2ACE<< |
| 458 | "chi2CCE="<<chi2CCE<< |
| 459 | //ce data new - MI version |
| 460 | "CEfitAMI.="<<&fitCEResultsA<< |
| 461 | "CEfitCMI.="<<&fitCEResultsC<< |
| 462 | "chi2CEA="<<chi2CEA<< |
| 463 | "chi2CEC="<<chi2CEC<< |
| 464 | // |
| 465 | //ce graph data |
| 466 | "CEgrTEntries.="<<&vecTEntries<< |
| 467 | "CEgrTMean.="<<&vecTMean<< |
| 468 | "CEgrTRMS.="<<&vecTRMS<< |
| 469 | "CEgrTMedian.="<<&vecTMedian<< |
| 470 | "CEgrQEntries.="<<&vecQEntries<< |
| 471 | "CEgrQMean.="<<&vecQMean<< |
| 472 | "CEgrQRMS.="<<&vecQRMS<< |
| 473 | "CEgrQMedian.="<<&vecQMedian<< |
| 474 | "CEgrDriftA="<<driftTimeA<< |
| 475 | "CEgrDriftC="<<driftTimeC<< |
| 476 | //calib raw data |
| 477 | "nFailL1="<<nFailL1<< |
| 478 | // b field |
| 479 | "Bz="<< bz << |
| 480 | "L3polarity="<<l3pol<< |
| 481 | // production information |
| 482 | "nalien="<<nalien<< |
| 483 | "nRawAlien="<<nRawAlien<< |
| 484 | "nlocal="<<nlocal<< |
| 485 | "nRawLocal="<<nRawLocal<< |
| 486 | //comparisons with ref data |
| 487 | "pedestalDeviations.="<<&pedestalDeviations<< |
| 488 | "noiseDeviations.="<<&noiseDeviations<< |
| 489 | "pulserQdeviations.="<<&pulserQdeviations<< |
| 490 | // "pulserVarQMean="<<varQMean<< |
| 491 | "pulserNpadsOutOneTB="<<npadsOutOneTB<< |
| 492 | "pulserNpadsOffAdd="<<npadsOffAdd<< |
| 493 | "driftCorrCosmAll="<<dvCorr<< |
| 494 | "\n"; |
| 495 | }//end run loop |
| 496 | } |
| 497 | |
| 498 | |
| 499 | |
| 500 | |
| 501 | |
| 502 | |
| 503 | void AliTPCcalibSummary::ProcessDrift(Int_t run, Int_t timeStamp){ |
| 504 | // |
| 505 | // dump drift calibration data to the tree |
| 506 | // |
| 507 | TObjArray *array =fCalibDB->GetTimeVdriftSplineRun(run); |
| 508 | TGraphErrors *laserA[3]={0,0,0}; |
| 509 | TGraphErrors *laserC[3]={0,0,0}; |
| 510 | TGraphErrors *cosmicAll=0; |
| 511 | static Double_t vlaserA[3]={0,0,0}; |
| 512 | static Double_t vlaserC[3]={0,0,0}; |
| 513 | static Double_t vcosmicAll=0; |
| 514 | static Double_t vdrift1=0; |
| 515 | vdrift1=fCalibDB->GetVDriftCorrectionTime(timeStamp,run,0,1); |
| 516 | |
| 517 | if (array){ |
| 518 | laserA[0]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DELAY_LASER_ALL_A"); |
| 519 | laserA[1]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_A"); |
| 520 | laserA[2]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_A"); |
| 521 | laserC[0]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DELAY_LASER_ALL_C"); |
| 522 | laserC[1]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_C"); |
| 523 | laserC[2]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_C"); |
| 524 | cosmicAll =(TGraphErrors*)array->FindObject("TGRAPHERRORS_MEAN_VDRIFT_COSMICS_ALL"); |
| 525 | } |
| 526 | if (laserA[0]) vlaserA[0]= AliTPCcalibDButil::EvalGraphConst(laserA[0],timeStamp); |
| 527 | if (laserA[1]) vlaserA[1]= AliTPCcalibDButil::EvalGraphConst(laserA[1],timeStamp); |
| 528 | if (laserA[2]) vlaserA[2]= AliTPCcalibDButil::EvalGraphConst(laserA[2],timeStamp); |
| 529 | if (laserC[0]) vlaserC[0]= AliTPCcalibDButil::EvalGraphConst(laserC[0],timeStamp); |
| 530 | if (laserC[1]) vlaserC[1]= AliTPCcalibDButil::EvalGraphConst(laserC[1],timeStamp); |
| 531 | if (laserC[2]) vlaserC[2]= AliTPCcalibDButil::EvalGraphConst(laserC[2],timeStamp); |
| 532 | if (cosmicAll) vcosmicAll= AliTPCcalibDButil::EvalGraphConst(cosmicAll,timeStamp); |
| 533 | (*fPcstream)<<"dcs"<< |
| 534 | "vlaserA0="<<vlaserA[0]<< |
| 535 | "vlaserA1="<<vlaserA[1]<< |
| 536 | "vlaserA2="<<vlaserA[2]<< |
| 537 | "vlaserC0="<<vlaserC[0]<< |
| 538 | "vlaserC1="<<vlaserC[1]<< |
| 539 | "vlaserC2="<<vlaserC[2]<< |
| 540 | "vcosmicAll="<<vcosmicAll<< |
| 541 | "vdrift1="<<vdrift1; |
| 542 | |
| 543 | // |
| 544 | // define distance to measurement |
| 545 | // |
| 546 | static Double_t dlaserA=0; |
| 547 | static Double_t dlaserC=0; |
| 548 | static Double_t dcosmic=0; |
| 549 | static Double_t slaserA=0; |
| 550 | static Double_t slaserC=0; |
| 551 | static Double_t scosmic=0; |
| 552 | static Double_t vclaserA[3]={0,0,0}; |
| 553 | static Double_t vclaserC[3]={0,0,0}; |
| 554 | static Double_t vccosmicAll=0; |
| 555 | for (Int_t i=0;i<3;i++){ |
| 556 | if (laserA[i]) AliTPCcalibDButil::GetNearest(laserA[i],timeStamp,dlaserA,vclaserA[i]); |
| 557 | if (laserC[i]) AliTPCcalibDButil::GetNearest(laserC[i],timeStamp,dlaserC,vclaserC[i]); |
| 558 | } |
| 559 | if (cosmicAll) AliTPCcalibDButil::GetNearest(cosmicAll,timeStamp,dcosmic,vccosmicAll); |
| 560 | (*fPcstream)<<"dcs"<< |
| 561 | "vclaserA0="<<vclaserA[0]<< |
| 562 | "vclaserA1="<<vclaserA[1]<< |
| 563 | "vclaserA2="<<vclaserA[2]<< |
| 564 | "vclaserC0="<<vclaserC[0]<< |
| 565 | "vclaserC1="<<vclaserC[1]<< |
| 566 | "vclaserC2="<<vclaserC[2]<< |
| 567 | "vccosmicAll="<<vccosmicAll<< |
| 568 | "dlaserA="<<dlaserA<< |
| 569 | "dlaserC="<<dlaserC<< |
| 570 | "dcosmic="<<dcosmic<< |
| 571 | "slaserA="<<slaserA<< |
| 572 | "slaserC="<<slaserC<< |
| 573 | "scosmic="<<scosmic; |
| 99369b07 |
574 | |
| 575 | static TGeoMatrix * matrixAlign=0; |
| 576 | static Double_t twistX=0; |
| 577 | static Double_t twistY=0; |
| 578 | if (matrixAlign==0){ |
| 579 | AliTPCComposedCorrection * corr = (AliTPCComposedCorrection *)array->FindObject("FitCorrectionTime"); |
| 580 | if (!corr) { |
| 581 | matrixAlign=new TGeoHMatrix; |
| 582 | |
| 583 | } |
| 584 | if (corr){ |
| 585 | AliTPCCalibGlobalMisalignment *align = (AliTPCCalibGlobalMisalignment*)corr->GetCorrections()->FindObject("FitAlignTime"); |
| 586 | AliTPCExBTwist *twist = (AliTPCExBTwist*)corr->GetCorrections()->FindObject("FitExBTwistTime"); |
| 587 | if (twist){ |
| 588 | twistX=twist->GetXTwist(); |
| 589 | twistY=twist->GetYTwist(); |
| 590 | //delete twist; |
| 591 | } |
| 592 | if (align && align->GetAlignGlobal()){ |
| 593 | matrixAlign = (TGeoMatrix*) (align->GetAlignGlobal()->Clone()); |
| 594 | //delete align; |
| 595 | } |
| 596 | } |
| 597 | } |
| 598 | (*fPcstream)<<"dcs"<< |
| 599 | "alignTime.="<<matrixAlign<< |
| 600 | "twistX="<<twistX<< |
| 601 | "twistY="<<twistY; |
| 12f69174 |
602 | } |
| 603 | |
| 604 | void AliTPCcalibSummary::ProcessDriftCE(Int_t run,Int_t timeStamp){ |
| 605 | // |
| 606 | // dump drift calibration data CE |
| 607 | // |
| 608 | TObjArray *arrT=fCalibDB->GetCErocTtime(); |
| 609 | AliTPCParam *param=fCalibDB->GetParameters(); |
| 610 | static TVectorD tdriftCE(74); |
| 611 | static TVectorD tndriftCE(74); |
| 612 | static TVectorD vdriftCE(74); |
| 613 | static TVectorD tcdriftCE(74); |
| 614 | static TVectorD tddriftCE(74); |
| 661f340b |
615 | static Double_t ltime0A=0.; |
| 616 | static Double_t ltime0C=0.; |
| 12f69174 |
617 | // |
| 618 | // |
| 619 | // |
| 620 | ltime0A = fDButil->GetLaserTime0(run,timeStamp,36000,0); |
| 621 | ltime0C = fDButil->GetLaserTime0(run,timeStamp,36000,1); |
| 622 | // |
| 623 | for (Int_t i=0; i<arrT->GetEntries();i++){ |
| 624 | tdriftCE[i]=0; |
| 625 | vdriftCE[i]=0; |
| 626 | TGraph *graph = (TGraph*)arrT->At(i); |
| 627 | if (!graph) continue; |
| 628 | tdriftCE[i]=AliTPCcalibDButil::EvalGraphConst(graph,timeStamp); |
| 629 | Double_t deltaT,gry; |
| 630 | AliTPCcalibDButil::GetNearest(graph,timeStamp,deltaT,gry); |
| 631 | tndriftCE[i]=graph->GetN(); |
| 632 | tcdriftCE[i]=gry; |
| 633 | tddriftCE[i]=deltaT; |
| 634 | if (i%36<18){ |
| 635 | vdriftCE[i] =(param->GetZLength(i)/(tdriftCE[i]*param->GetTSample()*(1.-ltime0A)-param->GetL1Delay()))/param->GetDriftV(); |
| 636 | }else{ |
| 637 | vdriftCE[i] =(param->GetZLength(i)/(tdriftCE[i]*param->GetTSample()*(1.-ltime0A)-param->GetL1Delay()))/param->GetDriftV(); |
| 638 | } |
| 639 | } |
| 640 | // export values |
| 641 | (*fPcstream)<<"dcs"<< |
| 642 | "tdriftCE.="<<&tdriftCE<< // arrival time |
| 643 | "vdriftCE.="<<&vdriftCE<< // derived drift velocity per chamber |
| 644 | "tndriftCE.="<<&tndriftCE<< // number of points (chambers) |
| 645 | "tcdriftCE.="<<&tcdriftCE<< // constant evaluation - nearest point used |
| 646 | "tddriftCE.="<<&tddriftCE<< // distance to closest measuement |
| 647 | "ltime0A="<<ltime0A<< // laser offset expected in reconstruction |
| 648 | "ltime0C="<<ltime0C; // laser offset expected in reconstruction |
| 649 | } |
| 650 | |
| 651 | |
| 652 | void AliTPCcalibSummary::ProcessDriftAll(Int_t run,Int_t timeStamp){ |
| 653 | // |
| 654 | // dump drift calibration data all calibrations form DB util |
| 655 | // test of utils |
| 656 | static Double_t vdriftCEA=0, vdriftCEC=0, vdriftCEM=0; |
| 657 | static Double_t vdriftLTA=0, vdriftLTC=0, vdriftLTM=0; |
| 78f17711 |
658 | static Double_t vdriftLTAon=0, vdriftLTCon=0, vdriftLTMon=0; |
| 12f69174 |
659 | static Double_t vdriftITS=0; |
| 660 | static Double_t vdriftP=0; |
| 78f17711 |
661 | static Double_t dcea=0, dcec=0, dcem=0, dla=0,dlc=0,dlm=0, dlaon=0,dlcon=0,dlmon=0, dp=0; |
| 12f69174 |
662 | static Double_t dits=0; |
| 661f340b |
663 | static Double_t ltime0A=0.; |
| 664 | static Double_t ltime0C=0.; |
| 665 | static Double_t ctime0=0.; |
| 12f69174 |
666 | static Double_t vdrift1=0; |
| 667 | vdrift1= fCalibDB->GetVDriftCorrectionTime(timeStamp,run,0,1); |
| 668 | vdriftP = fDButil->GetVDriftTPC(dp, run, timeStamp, 86400, 3600,0); |
| 669 | ctime0 = AliTPCcalibDButil::GetTriggerOffsetTPC(run,timeStamp, 36000, 3600,0); |
| 670 | // |
| 671 | vdriftCEA= fDButil->GetVDriftTPCCE(dcea,run,timeStamp,36000,0); |
| 672 | vdriftCEC= fDButil->GetVDriftTPCCE(dcec,run,timeStamp,36000,1); |
| 673 | vdriftCEM= fDButil->GetVDriftTPCCE(dcem,run,timeStamp,36000,2); |
| 674 | // |
| 675 | vdriftLTA= fDButil->GetVDriftTPCLaserTracks(dla,run,timeStamp,36000,0); |
| 676 | vdriftLTC= fDButil->GetVDriftTPCLaserTracks(dlc,run,timeStamp,36000,1); |
| 677 | vdriftLTM= fDButil->GetVDriftTPCLaserTracks(dlm,run,timeStamp,36000,2); |
| 678 | // |
| 78f17711 |
679 | vdriftLTAon= fDButil->GetVDriftTPCLaserTracksOnline(dlaon,run,timeStamp,36000,0); |
| 680 | vdriftLTCon= fDButil->GetVDriftTPCLaserTracksOnline(dlcon,run,timeStamp,36000,1); |
| 681 | vdriftLTMon= fDButil->GetVDriftTPCLaserTracksOnline(dlmon,run,timeStamp,36000,2); |
| 682 | // |
| 12f69174 |
683 | vdriftITS= fDButil->GetVDriftTPCITS(dits, run,timeStamp); |
| 684 | // |
| 685 | ltime0A = fDButil->GetLaserTime0(run,timeStamp,36000,0); |
| 686 | ltime0C = fDButil->GetLaserTime0(run,timeStamp,36000,1); |
| 687 | |
| 688 | (*fPcstream)<<"dcs"<< |
| 689 | // |
| 690 | "vdriftCEA="<<vdriftCEA<< // drift velocity CE |
| 691 | "vdriftCEC="<<vdriftCEC<< |
| 692 | "vdriftCEM="<<vdriftCEM<< |
| 693 | "dcea="<<dcea<< |
| 694 | "dcec="<<dcec<< |
| 695 | "dcem="<<dcem<< |
| 696 | "vdriftLTA="<<vdriftLTA<< // drift velocity laser tracks |
| 697 | "vdriftLTC="<<vdriftLTC<< |
| 698 | "vdriftLTM="<<vdriftLTM<< |
| 699 | "dla="<<dla<< |
| 700 | "dlc="<<dlc<< |
| 701 | "dlm="<<dlm<< |
| 78f17711 |
702 | "vdriftLTAon="<<vdriftLTAon<< // drift velocity laser tracks and CE from online algorithm |
| 703 | "vdriftLTCon="<<vdriftLTCon<< |
| 704 | "vdriftLTMon="<<vdriftLTMon<< |
| 705 | "dlaOn="<<dlaon<< |
| 706 | "dlcOn="<<dlcon<< |
| 707 | "dlmOn="<<dlmon<< |
| 12f69174 |
708 | // |
| 709 | // |
| 710 | "vdriftITS="<<vdriftITS<< |
| 711 | "dits="<<dits<< |
| 712 | "ctime0="<<ctime0<< |
| 713 | "vdriftP="<<vdriftP<< // drift velocity comsic |
| 714 | "dp="<<dp<< |
| 715 | "vdrift1="<<vdrift1; // combined drift velocity |
| 716 | |
| 717 | } |
| 718 | |
| 719 | |
| 720 | |
| 721 | void AliTPCcalibSummary::ProcessKryptonTime(Int_t run, Int_t timeStamp){ |
| 722 | // |
| 723 | // Dumping krypton calibration results |
| 724 | // |
| 725 | static TObjArray * krArray=0; |
| 726 | if (!krArray) { |
| 727 | AliCDBEntry* entry = AliCDBManager::Instance()->Get("TPC/Calib/TimeGainKrypton", run); |
| 728 | if (entry){ |
| 729 | krArray = (TObjArray*)entry->GetObject(); |
| 730 | } |
| 731 | } |
| 732 | static TVectorD krMean(74); |
| 733 | static TVectorD krErr(74); |
| 734 | static TVectorD krDist(74); |
| 735 | TGraphErrors *gr=0; |
| 736 | Double_t deltaT=0,gry=0; |
| 737 | if (krArray){ |
| 738 | for (Int_t isec=0; isec<72; isec++){ |
| 739 | krMean[isec]=0; |
| 740 | krDist[isec]=0; |
| 741 | krErr[isec]=0; |
| 742 | gr=(TGraphErrors*)krArray->At(isec); |
| 743 | if (gr) { |
| 5647625c |
744 | krMean[isec]=AliTPCcalibDButil::EvalGraphConst(gr,timeStamp); |
| 12f69174 |
745 | AliTPCcalibDButil::GetNearest(gr, timeStamp,deltaT,gry); |
| 746 | krDist[isec]=deltaT; |
| 747 | } |
| 748 | if (72+isec<krArray->GetEntries()) { |
| 749 | gr=(TGraphErrors*)krArray->At(72+isec); |
| 5647625c |
750 | if (gr) krErr[isec]=AliTPCcalibDButil::EvalGraphConst(gr,timeStamp); |
| 12f69174 |
751 | } |
| 752 | } |
| 753 | krMean[72]= TMath::Median(36,krMean.GetMatrixArray()); |
| 754 | krMean[73]= TMath::Median(36,&(krMean.GetMatrixArray()[36])); |
| 755 | krErr[72]= TMath::Median(36,krErr.GetMatrixArray()); |
| 756 | krErr[73]= TMath::Median(36,&(krErr.GetMatrixArray()[36])); |
| 757 | } |
| 758 | (*fPcstream)<<"dcs"<< |
| 759 | "krMean.="<<&krMean<< |
| 760 | "krErr.="<<&krErr<< |
| 761 | "krDist.="<<&krDist; |
| 762 | } |
| 763 | |
| 764 | void AliTPCcalibSummary::ProcessCTP(Int_t irun, Int_t timeStamp){ |
| 765 | // |
| 766 | // |
| 767 | // |
| 768 | static TClonesArray *pcarray = new TClonesArray("AliCTPInputTimeParams",1); |
| 769 | static AliCTPTimeParams *ctpParams =0; |
| 770 | ctpParams = fCalibDB->GetCTPTimeParams(); // |
| 771 | const TObjArray *arr = ctpParams->GetInputTimeParams(); |
| 772 | pcarray->ExpandCreateFast(TMath::Max(arr->GetEntries(),1)); |
| 773 | for (Int_t i=0; i<arr->GetEntries(); i++){ |
| 774 | new ((*pcarray)[i]) AliCTPInputTimeParams(*((AliCTPInputTimeParams*)arr->At(i))); |
| 775 | } |
| 776 | (*fPcstream)<<"ctp"<< |
| 777 | "run="<<irun<< |
| 778 | "time="<<timeStamp<< |
| 779 | "ctpP.="<<ctpParams<< |
| 780 | "ctpArr="<<pcarray<< |
| 781 | "\n"; |
| 782 | (*fPcstream)<<"dcs"<< |
| 783 | "ctpP.="<<ctpParams<< |
| 784 | "ctpArr="<<pcarray; |
| 785 | } |
| 786 | |
| 787 | void AliTPCcalibSummary::ProcessGain(Int_t irun, Int_t timeStamp){ |
| 788 | // |
| 789 | // Dump gain related information to the tree |
| 790 | // |
| 791 | static Float_t gainCosmic = 0; |
| 792 | static Float_t gainMIP = 0; |
| 5647625c |
793 | static Float_t attachMIP = 0; |
| 794 | static Double_t dMIP=0; |
| 795 | Double_t dummy=0; |
| 506ed125 |
796 | static TVectorD vGainGraphIROC(36); |
| 797 | static TVectorD vGainGraphOROCmed(36); |
| 798 | static TVectorD vGainGraphOROClong(36); |
| 799 | static TVectorD vGainGraphIROCErr(36); |
| 800 | static TVectorD vGainGraphOROCmedErr(36); |
| 801 | static TVectorD vGainGraphOROClongErr(36); |
| 802 | |
| 661f340b |
803 | vGainGraphIROC.Zero(); |
| 804 | vGainGraphOROCmed.Zero(); |
| 805 | vGainGraphOROClong.Zero(); |
| 806 | vGainGraphIROCErr.Zero(); |
| 807 | vGainGraphOROCmedErr.Zero(); |
| 808 | vGainGraphOROClongErr.Zero(); |
| 809 | |
| 506ed125 |
810 | TGraphErrors grDummy; |
| 12f69174 |
811 | TObjArray * gainSplines = fCalibDB->GetTimeGainSplinesRun(irun); |
| 812 | if (gainSplines) { |
| 813 | TGraphErrors * graphMIP = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_GAIN_BEAM_ALL"); |
| 814 | TGraphErrors * graphCosmic = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_GAIN_COSMIC_ALL"); |
| 5647625c |
815 | TGraphErrors * graphAttach = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_ATTACHMENT_BEAM_ALL"); |
| 79d561df |
816 | // |
| 506ed125 |
817 | TGraphErrors * graphGainIROC = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_CHAMBERGAIN_SHORT_BEAM_ALL"); |
| 79d561df |
818 | TGraphErrors * graphGainOROCMedium = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_CHAMBERGAIN_MEDIUM_BEAM_ALL"); |
| 506ed125 |
819 | TGraphErrors * graphGainOROCLong = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_CHAMBERGAIN_LONG_BEAM_ALL"); |
| 820 | |
| 821 | if (graphGainIROC && graphGainOROCMedium && graphGainOROCLong) { |
| 822 | Double_t x=0,y=0; |
| 823 | for (Int_t i=0; i<36; ++i){ |
| 824 | graphGainIROC->GetPoint(i,x,y); |
| 825 | vGainGraphIROC(i)=y; |
| 826 | graphGainOROCMedium->GetPoint(i,x,y); |
| 827 | vGainGraphOROCmed(i)=y; |
| 828 | graphGainOROCLong->GetPoint(i,x,y); |
| 829 | vGainGraphOROClong(i)=y; |
| 830 | //errors |
| 831 | vGainGraphIROCErr(i) = graphGainIROC->GetEY()[i]; |
| 832 | vGainGraphOROCmedErr(i) = graphGainOROCMedium->GetEY()[i]; |
| 833 | vGainGraphOROClongErr(i) = graphGainOROCLong->GetEY()[i]; |
| 834 | } |
| 835 | } |
| 836 | |
| 12f69174 |
837 | if (graphMIP) gainMIP = AliTPCcalibDButil::EvalGraphConst(graphMIP,timeStamp); |
| 838 | if (graphCosmic) gainCosmic = AliTPCcalibDButil::EvalGraphConst(graphCosmic,timeStamp); |
| 5647625c |
839 | if (graphAttach) attachMIP = AliTPCcalibDButil::EvalGraphConst(graphAttach,timeStamp); |
| 506ed125 |
840 | if (graphMIP) AliTPCcalibDButil::GetNearest(graphMIP, timeStamp, dMIP,dummy); |
| 12f69174 |
841 | } |
| 506ed125 |
842 | |
| 12f69174 |
843 | // time dependence of gain |
| 844 | (*fPcstream)<<"dcs"<< |
| 506ed125 |
845 | "rocGainIROC.=" << &vGainGraphIROC << |
| 846 | "rocGainOROCMedium.=" << &vGainGraphOROCmed << |
| 847 | "rocGainOROCLong.=" << &vGainGraphOROClong << |
| 848 | "rocGainErrIROC.=" << &vGainGraphIROCErr << |
| 849 | "rocGainErrOROCMedium.=" << &vGainGraphOROCmedErr << |
| 850 | "rocGainErrOROCLong.=" << &vGainGraphOROClongErr << |
| 851 | "gainMIP=" << gainMIP << |
| 852 | "attachMIP=" << attachMIP << |
| 853 | "dMIP=" << dMIP << |
| 854 | "gainCosmic=" << gainCosmic; |
| 12f69174 |
855 | } |
| 856 | |
| 857 | |
| 858 | void AliTPCcalibSummary::ProcessAlign(Int_t run, Int_t timeStamp){ |
| 859 | // |
| 860 | // Proccess alignment |
| 861 | // |
| 862 | TString grnames[12]={"ALIGN_ITS", "ALIGN_ITSP", "ALIGN_ITSM", "ALIGN_ITSB", |
| 863 | "ALIGN_TRD", "ALIGN_TRDP", "ALIGN_TRDM","ALIGN_TRDB", |
| 864 | "ALIGN_TOF", "ALIGN_TOFP", "ALIGN_TOFM","ALIGN_TOFB"}; |
| 865 | TString grpar[9]={"DELTAPSI", "DELTATHETA", "DELTAPHI", |
| 866 | "DELTAX", "DELTAY", "DELTAZ", |
| 867 | "DRIFTVD", "T0", "VDGY"}; |
| 868 | static Double_t values[12*9]; |
| 869 | static Double_t errs[12*9]; |
| 870 | |
| 871 | TObjArray *array =fCalibDB->GetTimeVdriftSplineRun(run); |
| 872 | TGraphErrors *gr=0; |
| 873 | for (Int_t idet=0; idet<12; idet++){ |
| 874 | for (Int_t ipar=0; ipar<9; ipar++){ |
| 875 | TString grName=grnames[idet]; |
| 876 | grName+="_TPC_"; |
| 877 | grName+=grpar[ipar]; |
| 878 | if (array){ |
| 879 | gr = (TGraphErrors*)array->FindObject(grName.Data()); |
| 880 | } |
| 881 | values[9*idet+ipar]=0; |
| 882 | errs[9*idet+ipar]=0; |
| 5647625c |
883 | if (gr) values[9*idet+ipar]=AliTPCcalibDButil::EvalGraphConst(gr,timeStamp); |
| 12f69174 |
884 | (*fPcstream)<<"dcs"<< |
| 885 | Form("%s=",grName.Data())<<values[9*idet+ipar]; |
| 886 | (*fPcstream)<<"align"<< |
| 887 | Form("%s=",grName.Data())<<values[9*idet+ipar]; |
| 888 | } |
| 889 | } |
| 890 | (*fPcstream)<<"align"<< |
| 891 | "time="<<timeStamp<< |
| 892 | "run="<<run<< |
| 893 | "\n"; |
| 894 | } |
| 895 | |
| 896 | |
| af6a50bb |
897 | void AliTPCcalibSummary::ProcessDriftCERef(){ |
| 898 | // |
| 899 | // Get fit of residuals if CE in respect with reference |
| 900 | // data |
| 901 | // |
| 902 | static TVectorD sec(72); |
| 903 | static TVectorD vec0(72); |
| 904 | static TVectorD vecLy(72); |
| 905 | static TVectorD vecLx(72); |
| 906 | static TVectorD vecChi2(72); |
| 907 | static TVectorD vecN(72); |
| 908 | // |
| 909 | static TVectorD vecA0(72); |
| 910 | static TVectorD vecALy(72); |
| 911 | static TVectorD vecALx(72); |
| 912 | static TVectorD vecAChi2(72); |
| 913 | // |
| 5647625c |
914 | static TVectorD vecASide(4); |
| 915 | static TVectorD vecCSide(4); |
| af6a50bb |
916 | static Bool_t isCalc=kFALSE; |
| 917 | |
| 918 | TFile f("calPads.root"); |
| 919 | TFile fref("calPadsRef.root"); |
| 920 | TTree * tree = (TTree*)f.Get("calPads"); |
| 921 | TTree * treeRef = (TTree*)fref.Get("calPads"); |
| 922 | tree->AddFriend(treeRef,"R"); |
| 923 | tree->SetAlias("inCE","((CEQmean.fElements>35)&&abs(CETmean.fElements)<1.5&&abs(CETrms.fElements/1.2-1)<0.2)"); // outlyerTrms |
| 924 | tree->SetAlias("inCER","((R.CEQmean.fElements>35)&&abs(R.CETmean.fElements)<1.5&&abs(R.CETrms.fElements/1.2-1)<0.2)"); // outlyerTrms |
| 925 | // |
| 926 | if (!isCalc){ |
| 927 | // make fits only once |
| 928 | TStatToolkit toolkit; |
| 929 | Double_t chi2=0; |
| 930 | Int_t npoints=0; |
| 931 | TVectorD param; |
| 932 | TMatrixD covar; |
| 933 | tree->SetAlias("dt","CETmean.fElements-R.CETmean.fElements"); |
| 934 | TCut cutAll ="inCE&&inCER&&abs(CETmean.fElements-R.CETmean.fElements)<0.5"; |
| 935 | TString fstringG=""; // global part |
| 936 | fstringG+="ly.fElements++"; |
| 937 | fstringG+="(lx.fElements-134.)++"; |
| 938 | for (Int_t isec=0; isec<72; isec++){ |
| 5647625c |
939 | TStatToolkit::FitPlane(tree,"0.264*dt", fstringG.Data(),Form("sector==%d",isec)+cutAll, chi2,npoints,param,covar,-1,0, 10000000, kFALSE); |
| af6a50bb |
940 | if (npoints<3) continue; |
| 941 | printf("Sector=%d\n",isec); |
| 942 | vec0[isec]=param[0]; |
| 943 | vecLy[isec]=param[1]; |
| 944 | vecLx[isec]=param[2]; |
| 945 | sec[isec]=isec; |
| 946 | vecN[isec]=npoints; |
| 5647625c |
947 | vecChi2[isec]=TMath::Sqrt(chi2/npoints); |
| af6a50bb |
948 | |
| 5647625c |
949 | TStatToolkit::FitPlane(tree,"0.264*CETmean.fElements", fstringG.Data(),Form("sector==%d",isec)+cutAll, chi2,npoints,param,covar,-1,0, 10000000, kFALSE); |
| af6a50bb |
950 | if (npoints<3) continue; |
| 951 | printf("Sector=%d\n",isec); |
| 952 | vecA0[isec]=param[0]; |
| 953 | vecALy[isec]=param[1]; |
| 954 | vecALx[isec]=param[2]; |
| 955 | vecAChi2[isec]=TMath::Sqrt(chi2/npoints); |
| af6a50bb |
956 | } |
| 957 | isCalc=kTRUE; |
| 5647625c |
958 | // |
| 959 | TString fstringRef=""; // global fit |
| 960 | fstringRef+="gx.fElements++"; |
| 961 | fstringRef+="gy.fElements++"; |
| 962 | fstringRef+="lx.fElements++"; |
| 963 | TStatToolkit::FitPlane(tree,"0.264*dt", fstringG.Data(),"(sector%36)<18"+cutAll, chi2,npoints,vecASide,covar,-1,0, 10000000, kFALSE); |
| 964 | TStatToolkit::FitPlane(tree,"0.264*dt", fstringG.Data(),"(sector%36)>=18"+cutAll, chi2,npoints,vecCSide,covar,-1,0, 10000000, kFALSE); |
| 965 | |
| af6a50bb |
966 | } |
| 967 | (*fPcstream)<<"dcs"<< // CE information |
| 968 | "CETSector.="<<&sec<< // sector numbers |
| 5647625c |
969 | "CETRefA.="<<&vecASide<< // diff to reference A side |
| 970 | "CETRefC.="<<&vecCSide<< // diff to reference C side |
| 971 | // // fit in respect to reference data |
| af6a50bb |
972 | "CETRef0.="<<&vec0<< // offset change |
| 973 | "CETRefY.="<<&vecLy<< // slope y change - rad |
| 974 | "CETRefX.="<<&vecLx<< // slope x change - rad |
| 975 | "CETRefChi2.="<<&vecChi2<< // chi2 (rms in cm) |
| 976 | "CETRefN.="<<&vecN<< //number of accepted points |
| 977 | // // fit in respect per mean per side |
| 978 | "CET0.="<<&vecA0<< // offset change |
| 979 | "CETY.="<<&vecALy<< // slope y change - rad |
| 980 | "CETX.="<<&vecALx<< // slope x change - rad |
| 981 | "CETChi2.="<<&vecAChi2; // chi2 (rms in cm) |
| 982 | } |
| 12f69174 |
983 | |
| af6a50bb |
984 | void AliTPCcalibSummary::ProcessPulserRef(){ |
| 985 | // |
| 986 | // Get fit of residuals if Pulser in respect with reference |
| 987 | // data |
| 988 | // |
| 989 | static TVectorD sec(72); |
| 990 | static TVectorD vec0(72); |
| 991 | static TVectorD vecLy(72); |
| 992 | static TVectorD vecLx(72); |
| 993 | static TVectorD vecChi2(72); |
| 994 | static TVectorD vecN(72); |
| 995 | // |
| 996 | static TVectorD vecA0(72); |
| 997 | static TVectorD vecALy(72); |
| 998 | static TVectorD vecALx(72); |
| 999 | static TVectorD vecAChi2(72); |
| 1000 | static Bool_t isCalc=kFALSE; |
| 1001 | |
| 1002 | TFile f("calPads.root"); |
| 1003 | TFile fref("calPadsRef.root"); |
| 1004 | TTree * tree = (TTree*)f.Get("calPads"); |
| 1005 | TTree * treeRef = (TTree*)fref.Get("calPads"); |
| 1006 | tree->AddFriend(treeRef,"R"); |
| 1007 | |
| 1008 | tree->SetAlias("inPulser","(abs(PulserTmean.fElements-PulserTmean_Median)<1.5&&abs(PulserTrms.fElements-PulserTrms_Median)<0.2)"); // outlyerTrms |
| 1009 | tree->SetAlias("inPulserR","(abs(R.PulserTmean.fElements-R.PulserTmean_Median)<1.5&&abs(R.PulserTrms.fElements-R.PulserTrms_Median)<0.2)"); // outlyerTrms |
| 1010 | // |
| 1011 | if (!isCalc){ |
| 1012 | // make fits only once |
| 1013 | TStatToolkit toolkit; |
| 1014 | Double_t chi2=0; |
| 1015 | Int_t npoints=0; |
| 1016 | TVectorD param; |
| 1017 | TMatrixD covar; |
| 1018 | tree->SetAlias("dt","PulserTmean.fElements-R.PulserTmean.fElements"); |
| 1019 | TCut cutAll ="inPulser&&inPulserR"; |
| 1020 | TString fstringG=""; // global part |
| 1021 | fstringG+="ly.fElements++"; |
| 1022 | fstringG+="(lx.fElements-134.)++"; |
| 1023 | for (Int_t isec=0; isec<72; isec++){ |
| 1024 | TStatToolkit::FitPlane(tree,"dt", fstringG.Data(),Form("sector==%d",isec)+cutAll, chi2,npoints,param,covar,-1,0, 10000000, kFALSE); |
| 1025 | if (npoints<3) continue; |
| 1026 | printf("Setor=%d\n",isec); |
| 1027 | vec0[isec]=param[0]; |
| 1028 | vecLy[isec]=param[1]; |
| 1029 | vecLx[isec]=param[2]; |
| 1030 | sec[isec]=isec; |
| 1031 | vecN[isec]=npoints; |
| 1032 | |
| 1033 | TStatToolkit::FitPlane(tree,"PulserTmean.fElements", fstringG.Data(),Form("sector==%d",isec)+cutAll, chi2,npoints,param,covar,-1,0, 10000000, kFALSE); |
| 1034 | if (npoints<3) continue; |
| 1035 | printf("Setor=%d\n",isec); |
| 1036 | vecA0[isec]=param[0]; |
| 1037 | vecALy[isec]=param[1]; |
| 1038 | vecALx[isec]=param[2]; |
| 1039 | vecAChi2[isec]=TMath::Sqrt(chi2/npoints); |
| 1040 | } |
| 5647625c |
1041 | |
| af6a50bb |
1042 | isCalc=kTRUE; |
| 1043 | } |
| 1044 | (*fPcstream)<<"dcs"<< // Pulser information |
| 1045 | "PulserTSector.="<<&sec<< // sector numbers |
| 1046 | // // fit in respect to reference |
| 1047 | "PulserTRef0.="<<&vec0<< // offset change |
| 1048 | "PulserTRefY.="<<&vecLy<< // slope y change - rad |
| 1049 | "PulserTRefX.="<<&vecLx<< // slope x change - rad |
| 1050 | "PulserTRefChi2.="<<&vecChi2<< // chi2 (rms in cm) |
| 1051 | "PulserTRefN.="<<&vecN<< //number of accepted points |
| 1052 | // // fit in respect per mean per side |
| 1053 | "PulserT0.="<<&vecA0<< // offset change |
| 1054 | "PulserTY.="<<&vecALy<< // slope y change - rad |
| 1055 | "PulserTX.="<<&vecALx<< // slope x change - rad |
| 1056 | "PulserTChi2.="<<&vecAChi2; // chi2 (rms in cm) |
| 1057 | } |
| 1058 | |
| a3b590cf |
1059 | void AliTPCcalibSummary::ProcessCurrent(Int_t irun, Int_t itime){ |
| 1060 | // |
| 1061 | // Dump current |
| 1062 | // |
| 1063 | //variables to export |
| 1064 | // |
| 1065 | static TObjArray *currentArray=new TObjArray(72); // current graphs |
| 1066 | static TObjArray *currentArray2=new TObjArray(72); // current graphs to export |
| 1067 | // |
| 1068 | static TVectorD currentIROC(36); // current snapshots |
| 1069 | static TVectorD currentOROC(36); |
| 1070 | static TVectorF sector(72); // |
| 1071 | static Double_t medcurIROC = 0; |
| 1072 | static Double_t medcurOROC = 0; |
| 1073 | // |
| 1074 | static TVectorF minROC(72); // current mean +-5 minutes |
| 1075 | static TVectorF maxROC(72); |
| 1076 | static TVectorF meanROC(72); |
| 1077 | static TVectorF medianROC(72); |
| 1078 | static Double_t meanIIROC=0; |
| 1079 | static Double_t meanIOROC=0; |
| 1080 | static Double_t medianIIROC=0; |
| 1081 | static Double_t medianIOROC=0; |
| 1082 | // |
| 1083 | AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(irun); |
| 1084 | // |
| 1085 | for(Int_t j=1; j<36; j++) currentIROC[j-1] = fCalibDB->GetChamberHighVoltage(irun, j,itime,-1,kTRUE); |
| 1086 | for(Int_t j=36; j<72; j++) currentOROC[j-36] = fCalibDB->GetChamberHighVoltage(irun, j,itime,-1,kTRUE); |
| 1087 | medcurIROC = TMath::Median(36, currentIROC.GetMatrixArray()); |
| 1088 | medcurOROC = TMath::Median(36, currentOROC.GetMatrixArray()); |
| 1089 | |
| 1090 | |
| 1091 | if (currentArray->At(0)==0){ |
| 1092 | for (Int_t isec=0; isec<72; isec++){ |
| 1093 | TString sensorName=""; |
| 1094 | const char* sideName=(isec%36<18) ? "A":"C"; |
| 1095 | if (isec<36){ |
| 1096 | //IROC |
| 1097 | sensorName=Form("TPC_ANODE_I_%s%02d_IMEAS",sideName,isec%18); |
| 1098 | }else{ |
| 1099 | //OROC |
| 1100 | sensorName=Form("TPC_ANODE_O_%s%02d_0_IMEAS",sideName,isec%18); |
| 1101 | } |
| 1102 | |
| 1103 | AliDCSSensor *sensor = 0; |
| 1104 | if (voltageArray) sensor= voltageArray->GetSensor(sensorName); |
| 1105 | TGraph *gr=0; |
| 1106 | if (!sensor) gr=new TGraph(1); |
| 1107 | else{ |
| 1108 | if (!sensor->GetGraph()) gr=new TGraph(1); |
| 1109 | else{ |
| 1110 | gr=sensor->GetGraph(); |
| 1111 | Double_t startTime=sensor->GetStartTime(); |
| 1112 | Double_t * time = new Double_t[gr->GetN()]; |
| 1113 | for (Int_t ip=0; ip<gr->GetN(); ip++){ time[ip]= (gr->GetX()[ip]*3600.)+startTime;} |
| 1114 | gr=new TGraph(gr->GetN(), time, gr->GetY()); |
| 1115 | delete [] time; |
| 1116 | } |
| 1117 | } |
| 1118 | gr->Sort(); |
| 1119 | currentArray->AddAt(gr, isec); |
| 1120 | currentArray->AddAt(gr->Clone(), isec); |
| 1121 | } |
| 1122 | } |
| 1123 | |
| 1124 | |
| 1125 | for (Int_t isec=0; isec<72; isec++){ |
| 1126 | sector[isec]=isec; |
| 1127 | TGraph * gr = (TGraph*)currentArray->At(isec); |
| 1128 | TGraph * graph2 = (TGraph*)currentArray2->At(isec); |
| 1129 | Int_t firstBin= TMath::BinarySearch(gr->GetN(), gr->GetX(), itime-300.)-2; |
| 1130 | Int_t lastBin= TMath::BinarySearch(gr->GetN(), gr->GetX(), itime+300.)+2; |
| 1131 | if (firstBin<0) firstBin=0; |
| 1132 | if (lastBin>=gr->GetN()) lastBin=gr->GetN()-1; |
| 1133 | // |
| 1134 | if (firstBin<lastBin){ |
| 1135 | // |
| 1136 | minROC[isec]=TMath::MinElement(lastBin-firstBin, &(gr->GetY()[firstBin])); |
| 1137 | maxROC[isec]=TMath::MaxElement(lastBin-firstBin, &(gr->GetY()[firstBin])); |
| 1138 | meanROC[isec]=TMath::Mean(lastBin-firstBin, &(gr->GetY()[firstBin])); |
| 1139 | medianROC[isec]=TMath::Median(lastBin-firstBin, &(gr->GetY()[firstBin])); |
| 1140 | graph2 = new TGraph(lastBin-firstBin, &(gr->GetX()[firstBin]), &(gr->GetY()[firstBin])); |
| 1141 | delete currentArray2->At(isec); |
| 1142 | currentArray2->AddAt(graph2,isec); |
| 1143 | } |
| 1144 | (*fPcstream)<<"dcs"<< // current information |
| 1145 | Form("current%d.=",isec)<<graph2; |
| 1146 | } |
| 1147 | meanIIROC=TMath::Mean(36, &(meanROC.GetMatrixArray()[0])); |
| 1148 | meanIOROC=TMath::Mean(36, &(meanROC.GetMatrixArray()[36])); |
| 1149 | medianIIROC=TMath::Median(36, &(meanROC.GetMatrixArray()[0])); |
| 1150 | medianIOROC=TMath::Median(36, &(meanROC.GetMatrixArray()[36])); |
| 1151 | // |
| 1152 | (*fPcstream)<<"dcs"<< // current information |
| 1153 | "isec.="<<§or<< //sector number |
| 1154 | "IIROC.="<<¤tIROC<< // current sample at given moment |
| 1155 | "IOROC.="<<¤tOROC<< // current sample at given moment |
| 1156 | "medianIIROC="<<medcurIROC<< // median at given moment |
| 1157 | "medianIOROC="<<medcurOROC<< // median at given moment |
| 1158 | // |
| 1159 | "minIROC.="<<&minROC<< // minimum in +-5 min |
| 1160 | "maxIROC.="<<&maxROC<< // maximum in +-5 min |
| 1161 | "meanIROC.="<<&meanROC<< // mean in +-5 min |
| 1162 | "medianIROC.="<<&medianROC<< // median in +-5 min |
| 1163 | "meanIIROC5="<<meanIIROC<< // mean current in IROC +-5 minutes |
| 1164 | "meanIOROC5="<<meanIOROC<< // mean current in OROC |
| 1165 | "medianIIROC5="<<medianIIROC<< // median current in IROC |
| 1166 | "medianIOROC5="<<medianIOROC; // medianan current in OROC |
| 1167 | |
| 1168 | |
| 1169 | (*fPcstream)<<"current"<< // current information |
| 1170 | "time="<<itime<< |
| 1171 | "isec.="<<§or<< //sector number |
| 1172 | "IIROC.="<<¤tIROC<< // current sample at given moment |
| 1173 | "IOROC.="<<¤tOROC<< // current sample at given moment |
| 1174 | "medianIIROC="<<medcurIROC<< // median at given moment |
| 1175 | "medianIOROC="<<medcurOROC<< // median at given moment |
| 1176 | // |
| 1177 | "minIROC.="<<&minROC<< // minimum in +-5 min |
| 1178 | "maxIROC.="<<&maxROC<< // maximum in +-5 min |
| 1179 | "meanIROC.="<<&meanROC<< // mean in +-5 min |
| 1180 | "medianIROC.="<<&medianROC<< // median in +-5 min |
| 1181 | "meanIIROC5="<<meanIIROC<< // mean current in IROC +-5 minutes |
| 1182 | "meanIOROC5="<<meanIOROC<< // mean current in OROC |
| 1183 | "medianIIROC5="<<medianIIROC<< // median current in IROC |
| 1184 | "medianIOROC5="<<medianIOROC<< // medianan current in OROC |
| 1185 | "\n"; |
| 1186 | |
| 1187 | } |
| af6a50bb |
1188 | |
| 1189 | |
| 1190 | |
| 1191 | |
| 1192 | // TCanvas * DrawCEDiff(TTree * tree){ |
| 1193 | |
| 1194 | // TCanvas *canvasIO = new TCanvas("canvasCEIO","canvasCEIO"); |
| 1195 | // canvasIO->Divide(6,6); |
| 1196 | // for (Int_t isec=0; isec<36; isec++){ |
| 1197 | // canvasIO->cd(isec+1); |
| 1198 | // dcs->Draw(Form("CET0.fElements[%d]-CET0.fElements[%d]",isec+36,isec),Form("abs(CETRef0.fElements[%d])<0.3",isec),""); |
| 1199 | // printf("%d\t%f\t%f\n",isec,dcs->GetHistogram()->GetMean(),dcs->GetHistogram()->GetRMS()); |
| 1200 | // } |
| 1201 | |
| 1202 | // } |
git://git.uio.no / u / mrichter / AliRoot.git / blame