Fixed warnings
[u/mrichter/AliRoot.git] / TPC / AliTPCcalibDB.cxx
CommitLineData
c5bbaa2c 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16
17///////////////////////////////////////////////////////////////////////////////
18// //
19// Class providing the calibration parameters by accessing the CDB //
20// //
21// Request an instance with AliTPCcalibDB::Instance() //
22// If a new event is processed set the event number with SetRun //
1ac191a6 23// Then request the calibration data ////
f5344549 24//
25//
1ac191a6 26// Calibration data:
8cd9634d 27// 0.) Altro mapping
28// Simulation - not yet
29// Reconstruction - AliTPCclustererMI::Digits2Clusters(AliRawReader* rawReader)
30//
1ac191a6 31// 1.) pad by pad calibration - AliTPCCalPad
f5344549 32//
1ac191a6 33// a.) fPadGainFactor
34// Simulation: AliTPCDigitizer::ExecFast - Multiply by gain
35// Reconstruction : AliTPCclustererMI::Digits2Clusters - Divide by gain
f5344549 36//
1ac191a6 37// b.) fPadNoise -
38// Simulation: AliTPCDigitizer::ExecFast
39// Reconstruction: AliTPCclustererMI::FindClusters(AliTPCCalROC * noiseROC)
8cd9634d 40// Noise depending cut on clusters charge (n sigma)
f5344549 41// c.) fPedestal:
42// Simulation: Not used yet - To be impleneted - Rounding to the nearest integer
43// Reconstruction: Used in AliTPCclustererMI::Digits2Clusters(AliRawReader* rawReader)
44// if data taken without zero suppression
45// Currently switch in fRecoParam->GetCalcPedestal();
46//
47// d.) fPadTime0
48// Simulation: applied in the AliTPC::MakeSector - adding offset
49// Reconstruction: AliTPCTransform::Transform() - remove offset
50// AliTPCTransform::Transform() - to be called
51// in AliTPCtracker::Transform()
8cd9634d 52//
53//
54// 2.) Space points transformation:
55//
56// a.) General coordinate tranformation - AliTPCtransform (see $ALICE_ROOT/TPC/AliTPCtransform.cxx)
57// Created on fly - use the other calibration components
58// Unisochronity - (substract time0 - pad by pad)
59// Drift velocity - Currently common drift velocity - functionality of AliTPCParam
60// ExB effect
61// Simulation - Not used directly (the effects are applied one by one (see AliTPC::MakeSector)
62// Reconstruction -
63// AliTPCclustererMI::AddCluster
64// AliTPCtrackerMI::Transform
65// b.) ExB effect calibration -
66// classes (base class AliTPCExB, implementation- AliTPCExBExact.h AliTPCExBFirst.h)
67// a.a) Simulation: applied in the AliTPC::MakeSector -
68// calib->GetExB()->CorrectInverse(dxyz0,dxyz1);
69// a.b) Reconstruction -
70//
71// in AliTPCtransform::Correct() - called calib->GetExB()->Correct(dxyz0,dxyz1)
72//
96305e49 73// 3.) cluster error, shape and Q parameterization
74//
75//
8cd9634d 76//
c5bbaa2c 77///////////////////////////////////////////////////////////////////////////////
78
418bbcaf 79#include <iostream>
80#include <fstream>
81
c5bbaa2c 82
83#include <AliCDBManager.h>
c5bbaa2c 84#include <AliCDBEntry.h>
949d8707 85#include <AliCDBId.h>
c5bbaa2c 86#include <AliLog.h>
3ac615eb 87#include <AliMagF.h>
7fff7612 88#include <AliSplineFit.h>
f14d21a1 89#include <AliCTPTimeParams.h>
c5bbaa2c 90
91#include "AliTPCcalibDB.h"
949d8707 92#include "AliTPCdataQA.h"
817766d5 93#include "AliTPCcalibDButil.h"
d6834f5f 94#include "AliTPCAltroMapping.h"
418bbcaf 95#include "AliTPCExB.h"
c5bbaa2c 96
97#include "AliTPCCalROC.h"
98#include "AliTPCCalPad.h"
54472e4f 99#include "AliTPCSensorTempArray.h"
bf85fe4d 100#include "AliGRPObject.h"
418bbcaf 101#include "AliTPCTransform.h"
f6b5fa33 102#include "AliTPCmapper.h"
d6834f5f 103
418bbcaf 104class AliCDBStorage;
105class AliTPCCalDet;
86df2b3a 106//
107//
108
86df2b3a 109#include "TFile.h"
110#include "TKey.h"
43a74775 111#include "TGraphErrors.h"
86df2b3a 112
113#include "TObjArray.h"
114#include "TObjString.h"
115#include "TString.h"
7390f655 116#include "TDirectory.h"
f6b5fa33 117#include "TArrayI.h"
86df2b3a 118#include "AliTPCCalPad.h"
0fe7645c 119#include "AliTPCCalibPulser.h"
86df2b3a 120#include "AliTPCCalibPedestal.h"
121#include "AliTPCCalibCE.h"
3ac615eb 122#include "AliTPCExBFirst.h"
bf85fe4d 123#include "AliTPCTempMap.h"
da6c0bc9 124#include "AliTPCCalibVdrift.h"
6e7d7dc4 125#include "AliTPCCalibRaw.h"
43a74775 126#include "AliTPCParam.h"
86df2b3a 127
5312f439 128#include "AliTPCPreprocessorOnline.h"
86df2b3a 129
c5bbaa2c 130
131ClassImp(AliTPCcalibDB)
132
133AliTPCcalibDB* AliTPCcalibDB::fgInstance = 0;
134Bool_t AliTPCcalibDB::fgTerminated = kFALSE;
3ac615eb 135TObjArray AliTPCcalibDB::fgExBArray; // array of ExB corrections
c5bbaa2c 136
137
138//_ singleton implementation __________________________________________________
139AliTPCcalibDB* AliTPCcalibDB::Instance()
140{
141 //
142 // Singleton implementation
143 // Returns an instance of this class, it is created if neccessary
144 //
145
146 if (fgTerminated != kFALSE)
147 return 0;
148
149 if (fgInstance == 0)
150 fgInstance = new AliTPCcalibDB();
151
152 return fgInstance;
153}
154
155void AliTPCcalibDB::Terminate()
156{
157 //
158 // Singleton implementation
159 // Deletes the instance of this class and sets the terminated flag, instances cannot be requested anymore
160 // This function can be called several times.
161 //
162
163 fgTerminated = kTRUE;
164
165 if (fgInstance != 0)
166 {
167 delete fgInstance;
168 fgInstance = 0;
169 }
170}
171
172//_____________________________________________________________________________
e4dce695 173AliTPCcalibDB::AliTPCcalibDB():
9389f9a4 174 TObject(),
e4dce695 175 fRun(-1),
f5344549 176 fTransform(0),
481f877b 177 fExB(0),
e4dce695 178 fPadGainFactor(0),
9f6e9f81 179 fDedxGainFactor(0),
e4dce695 180 fPadTime0(0),
2293155b 181 fDistortionMap(0),
e4dce695 182 fPadNoise(0),
183 fPedestals(0),
6e7d7dc4 184 fCalibRaw(0),
949d8707 185 fDataQA(0),
5312f439 186 fALTROConfigData(0),
187 fPulserData(0),
188 fCEData(0),
e4dce695 189 fTemperature(0),
d6834f5f 190 fMapping(0),
96305e49 191 fParam(0),
a2c3785e 192 fClusterParam(0),
193 fTimeGainSplines(0),
194 fTimeGainSplinesArray(100000),
da6c0bc9 195 fGRPArray(100000), //! array of GRPs - per run - JUST for calibration studies
0231c65f 196 fGRPMaps(100000), //! array of GRPs - per run - JUST for calibration studies
da6c0bc9 197 fGoofieArray(100000), //! array of GOOFIE values -per run - Just for calibration studies
e2914767 198 fVoltageArray(100000),
da6c0bc9 199 fTemperatureArray(100000), //! array of temperature sensors - per run - Just for calibration studies
200 fVdriftArray(100000), //! array of v drift interfaces
5e1215d4 201 fDriftCorrectionArray(100000), //! array of drift correction
1e722a63 202 fRunList(100000), //! run list - indicates try to get the run param
f14d21a1 203 fDButil(0),
204 fCTPTimeParams(0)
c5bbaa2c 205{
206 //
207 // constructor
208 //
54472e4f 209 //
c5bbaa2c 210 Update(); // temporary
211}
212
9389f9a4 213AliTPCcalibDB::AliTPCcalibDB(const AliTPCcalibDB& ):
214 TObject(),
215 fRun(-1),
216 fTransform(0),
217 fExB(0),
218 fPadGainFactor(0),
9f6e9f81 219 fDedxGainFactor(0),
9389f9a4 220 fPadTime0(0),
2293155b 221 fDistortionMap(0),
9389f9a4 222 fPadNoise(0),
223 fPedestals(0),
6e7d7dc4 224 fCalibRaw(0),
949d8707 225 fDataQA(0),
5312f439 226 fALTROConfigData(0),
227 fPulserData(0),
228 fCEData(0),
9389f9a4 229 fTemperature(0),
230 fMapping(0),
9389f9a4 231 fParam(0),
bf85fe4d 232 fClusterParam(0),
a2c3785e 233 fTimeGainSplines(0),
234 fTimeGainSplinesArray(100000),
bf85fe4d 235 fGRPArray(0), //! array of GRPs - per run - JUST for calibration studies
0231c65f 236 fGRPMaps(0), //! array of GRPs - per run - JUST for calibration studies
bf85fe4d 237 fGoofieArray(0), //! array of GOOFIE values -per run - Just for calibration studies
e2914767 238 fVoltageArray(0),
bf85fe4d 239 fTemperatureArray(0), //! array of temperature sensors - per run - Just for calibration studies
da6c0bc9 240 fVdriftArray(0), //! array of v drift interfaces
5e1215d4 241 fDriftCorrectionArray(0), //! array of v drift interfaces
1e722a63 242 fRunList(0), //! run list - indicates try to get the run param
f14d21a1 243 fDButil(0),
244 fCTPTimeParams(0)
9389f9a4 245{
246 //
247 // Copy constructor invalid -- singleton implementation
248 //
249 Error("copy constructor","invalid -- singleton implementation");
250}
251
252AliTPCcalibDB& AliTPCcalibDB::operator= (const AliTPCcalibDB& )
253{
254//
255// Singleton implementation - no assignment operator
256//
257 Error("operator =", "assignment operator not implemented");
258 return *this;
259}
260
261
262
c5bbaa2c 263//_____________________________________________________________________________
264AliTPCcalibDB::~AliTPCcalibDB()
265{
266 //
267 // destructor
268 //
68751c2c 269
c5bbaa2c 270}
271
272
273//_____________________________________________________________________________
274AliCDBEntry* AliTPCcalibDB::GetCDBEntry(const char* cdbPath)
275{
276 //
277 // Retrieves an entry with path <cdbPath> from the CDB.
278 //
279 char chinfo[1000];
280
68751c2c 281 AliCDBEntry* entry = AliCDBManager::Instance()->Get(cdbPath, fRun);
c5bbaa2c 282 if (!entry)
283 {
284 sprintf(chinfo,"AliTPCcalibDB: Failed to get entry:\t%s ", cdbPath);
285 AliError(chinfo);
286 return 0;
287 }
288 return entry;
289}
290
291
292//_____________________________________________________________________________
293void AliTPCcalibDB::SetRun(Long64_t run)
294{
295 //
296 // Sets current run number. Calibration data is read from the corresponding file.
297 //
298 if (fRun == run)
299 return;
a2c3785e 300 fRun = run;
c5bbaa2c 301 Update();
302}
303
304
305
306void AliTPCcalibDB::Update(){
a2c3785e 307 //
a8f8b6a1 308 AliCDBEntry * entry=0;
68751c2c 309 Bool_t cdbCache = AliCDBManager::Instance()->GetCacheFlag(); // save cache status
310 AliCDBManager::Instance()->SetCacheFlag(kTRUE); // activate CDB cache
1e722a63 311 fDButil = new AliTPCcalibDButil;
c5bbaa2c 312 //
313 entry = GetCDBEntry("TPC/Calib/PadGainFactor");
314 if (entry){
68751c2c 315 //if (fPadGainFactor) delete fPadGainFactor;
c5bbaa2c 316 entry->SetOwner(kTRUE);
317 fPadGainFactor = (AliTPCCalPad*)entry->GetObject();
2293155b 318 }else{
319 AliFatal("TPC - Missing calibration entry")
c5bbaa2c 320 }
321 //
3af3fbc4 322 entry = GetCDBEntry("TPC/Calib/TimeGain");
323 if (entry){
324 //if (fTimeGainSplines) delete fTimeGainSplines;
325 entry->SetOwner(kTRUE);
326 fTimeGainSplines = (TObjArray*)entry->GetObject();
2293155b 327 }else{
328 AliFatal("TPC - Missing calibration entry")
3af3fbc4 329 }
330 //
9f6e9f81 331 entry = GetCDBEntry("TPC/Calib/GainFactorDedx");
332 if (entry){
333 entry->SetOwner(kTRUE);
334 fDedxGainFactor = (AliTPCCalPad*)entry->GetObject();
2293155b 335 }else{
336 AliFatal("TPC - Missing calibration entry")
9f6e9f81 337 }
338 //
c5bbaa2c 339 entry = GetCDBEntry("TPC/Calib/PadTime0");
340 if (entry){
68751c2c 341 //if (fPadTime0) delete fPadTime0;
c5bbaa2c 342 entry->SetOwner(kTRUE);
343 fPadTime0 = (AliTPCCalPad*)entry->GetObject();
2293155b 344 }else{
345 AliFatal("TPC - Missing calibration entry")
c5bbaa2c 346 }
2293155b 347
348 entry = GetCDBEntry("TPC/Calib/Distortion");
349 if (entry){
350 //if (fPadTime0) delete fPadTime0;
351 entry->SetOwner(kTRUE);
352 fDistortionMap =(TObjArray*)entry->GetObject();
353 }else{
354 //AliFatal("TPC - Missing calibration entry")
355 }
356
357
c5bbaa2c 358 //
c5bbaa2c 359 //
360 entry = GetCDBEntry("TPC/Calib/PadNoise");
361 if (entry){
68751c2c 362 //if (fPadNoise) delete fPadNoise;
c5bbaa2c 363 entry->SetOwner(kTRUE);
364 fPadNoise = (AliTPCCalPad*)entry->GetObject();
2293155b 365 }else{
366 AliFatal("TPC - Missing calibration entry")
c5bbaa2c 367 }
8477f500 368
369 entry = GetCDBEntry("TPC/Calib/Pedestals");
370 if (entry){
371 //if (fPedestals) delete fPedestals;
372 entry->SetOwner(kTRUE);
373 fPedestals = (AliTPCCalPad*)entry->GetObject();
374 }
375
54472e4f 376 entry = GetCDBEntry("TPC/Calib/Temperature");
377 if (entry){
378 //if (fTemperature) delete fTemperature;
379 entry->SetOwner(kTRUE);
380 fTemperature = (AliTPCSensorTempArray*)entry->GetObject();
381 }
382
8477f500 383 entry = GetCDBEntry("TPC/Calib/Parameters");
384 if (entry){
54472e4f 385 //if (fPadNoise) delete fPadNoise;
8477f500 386 entry->SetOwner(kTRUE);
a778f7e3 387 fParam = (AliTPCParam*)(entry->GetObject()->Clone());
2293155b 388 }else{
389 AliFatal("TPC - Missing calibration entry")
8477f500 390 }
391
96305e49 392 entry = GetCDBEntry("TPC/Calib/ClusterParam");
393 if (entry){
96305e49 394 entry->SetOwner(kTRUE);
395 fClusterParam = (AliTPCClusterParam*)(entry->GetObject()->Clone());
2293155b 396 }else{
397 AliFatal("TPC - Missing calibration entry")
96305e49 398 }
399
5312f439 400 //ALTRO configuration data
401 entry = GetCDBEntry("TPC/Calib/AltroConfig");
402 if (entry){
403 entry->SetOwner(kTRUE);
404 fALTROConfigData=(TObjArray*)(entry->GetObject());
2293155b 405 }else{
406 AliFatal("TPC - Missing calibration entry")
5312f439 407 }
408
409 //Calibration Pulser data
410 entry = GetCDBEntry("TPC/Calib/Pulser");
411 if (entry){
412 entry->SetOwner(kTRUE);
413 fPulserData=(TObjArray*)(entry->GetObject());
414 }
415
416 //CE data
417 entry = GetCDBEntry("TPC/Calib/CE");
418 if (entry){
419 entry->SetOwner(kTRUE);
420 fCEData=(TObjArray*)(entry->GetObject());
421 }
6e7d7dc4 422 //RAW calibration data
56ce896d 423 // entry = GetCDBEntry("TPC/Calib/Raw");
5312f439 424
d6834f5f 425 entry = GetCDBEntry("TPC/Calib/Mapping");
426 if (entry){
427 //if (fPadNoise) delete fPadNoise;
428 entry->SetOwner(kTRUE);
429 TObjArray * array = dynamic_cast<TObjArray*>(entry->GetObject());
430 if (array && array->GetEntriesFast()==6){
431 fMapping = new AliTPCAltroMapping*[6];
432 for (Int_t i=0; i<6; i++){
5312f439 433 fMapping[i] = dynamic_cast<AliTPCAltroMapping*>(array->At(i));
d6834f5f 434 }
435 }
436 }
437
2293155b 438 //CTP calibration data
f14d21a1 439 entry = GetCDBEntry("GRP/CTP/CTPtiming");
440 if (entry){
4a880881 441 //entry->SetOwner(kTRUE);
f14d21a1 442 fCTPTimeParams=dynamic_cast<AliCTPTimeParams*>(entry->GetObject());
2293155b 443 }else{
444 AliFatal("TPC - Missing calibration entry")
445 }
3ac615eb 446 //
f5344549 447 if (!fTransform) {
448 fTransform=new AliTPCTransform();
bfec3eeb 449 fTransform->SetCurrentRun(AliCDBManager::Instance()->GetRun());
f5344549 450 }
8477f500 451
c5bbaa2c 452 //
68751c2c 453 AliCDBManager::Instance()->SetCacheFlag(cdbCache); // reset original CDB cache
c5bbaa2c 454}
e4dce695 455
56ce896d 456void AliTPCcalibDB::UpdateNonRec(){
457 //
458 // Update/Load the parameters which are important for QA studies
459 // and not used yet for the reconstruction
460 //
461 //RAW calibration data
462 AliCDBEntry * entry=0;
463 entry = GetCDBEntry("TPC/Calib/Raw");
464 if (entry){
465 entry->SetOwner(kTRUE);
466 TObjArray *arr=(TObjArray*)(entry->GetObject());
467 if (arr) fCalibRaw=(AliTPCCalibRaw*)arr->At(0);
468 }
469 //QA calibration data
470 entry = GetCDBEntry("TPC/Calib/QA");
471 if (entry){
472 entry->SetOwner(kTRUE);
473 fDataQA=dynamic_cast<AliTPCdataQA*>(entry->GetObject());
474 }
2293155b 475 // High voltage
476 entry = AliCDBManager::Instance()->Get("TPC/Calib/HighVoltage",fRun);
477 if (entry) {
478 fVoltageArray.AddAt(entry->GetObject(),fRun);
479 }
480
56ce896d 481}
482
86df2b3a 483
484
485void AliTPCcalibDB::CreateObjectList(const Char_t *filename, TObjArray *calibObjects)
486{
418bbcaf 487//
488// Create calibration objects and read contents from OCDB
489//
86df2b3a 490 if ( calibObjects == 0x0 ) return;
491 ifstream in;
492 in.open(filename);
493 if ( !in.is_open() ){
494 fprintf(stderr,"Error: cannot open list file '%s'", filename);
495 return;
496 }
497
498 AliTPCCalPad *calPad=0x0;
499
500 TString sFile;
501 sFile.ReadFile(in);
502 in.close();
503
504 TObjArray *arrFileLine = sFile.Tokenize("\n");
505
506 TIter nextLine(arrFileLine);
507
508 TObjString *sObjLine=0x0;
2c632057 509 while ( (sObjLine = (TObjString*)nextLine()) ){
86df2b3a 510 TString sLine(sObjLine->GetString());
511
512 TObjArray *arrNextCol = sLine.Tokenize("\t");
513
514 TObjString *sObjType = (TObjString*)(arrNextCol->At(0));
515 TObjString *sObjFileName = (TObjString*)(arrNextCol->At(1));
516
517 if ( !sObjType || ! sObjFileName ) continue;
518 TString sType(sObjType->GetString());
519 TString sFileName(sObjFileName->GetString());
520 printf("%s\t%s\n",sType.Data(),sFileName.Data());
521
522 TFile *fIn = TFile::Open(sFileName);
523 if ( !fIn ){
524 fprintf(stderr,"File not found: '%s'", sFileName.Data());
525 continue;
526 }
527
528 if ( sType == "CE" ){
529 AliTPCCalibCE *ce = (AliTPCCalibCE*)fIn->Get("AliTPCCalibCE");
530
531 calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadT0());
532 calPad->SetNameTitle("CETmean","CETmean");
533 calibObjects->Add(calPad);
534
535 calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadQ());
536 calPad->SetNameTitle("CEQmean","CEQmean");
537 calibObjects->Add(calPad);
538
539 calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadRMS());
540 calPad->SetNameTitle("CETrms","CETrms");
541 calibObjects->Add(calPad);
542
543 } else if ( sType == "Pulser") {
0fe7645c 544 AliTPCCalibPulser *sig = (AliTPCCalibPulser*)fIn->Get("AliTPCCalibPulser");
86df2b3a 545
546 calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadT0());
547 calPad->SetNameTitle("PulserTmean","PulserTmean");
548 calibObjects->Add(calPad);
549
550 calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadQ());
551 calPad->SetNameTitle("PulserQmean","PulserQmean");
552 calibObjects->Add(calPad);
553
554 calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadRMS());
555 calPad->SetNameTitle("PulserTrms","PulserTrms");
556 calibObjects->Add(calPad);
557
558 } else if ( sType == "Pedestals") {
559 AliTPCCalibPedestal *ped = (AliTPCCalibPedestal*)fIn->Get("AliTPCCalibPedestal");
560
561 calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadPedestal());
562 calPad->SetNameTitle("Pedestals","Pedestals");
563 calibObjects->Add(calPad);
564
565 calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadRMS());
566 calPad->SetNameTitle("Noise","Noise");
567 calibObjects->Add(calPad);
568
569 } else {
570 fprintf(stderr,"Undefined Type: '%s'",sType.Data());
571
572 }
573 delete fIn;
574 }
575}
576
577
578
579void AliTPCcalibDB::MakeTree(const char * fileName, TObjArray * array, const char * mapFileName, AliTPCCalPad* outlierPad, Float_t ltmFraction) {
580 //
581 // Write a tree with all available information
418bbcaf 582 // if mapFileName is specified, the Map information are also written to the tree
86df2b3a 583 // pads specified in outlierPad are not used for calculating statistics
584 // - the same function as AliTPCCalPad::MakeTree -
585 //
586 AliTPCROC* tpcROCinstance = AliTPCROC::Instance();
587
588 TObjArray* mapIROCs = 0;
589 TObjArray* mapOROCs = 0;
590 TVectorF *mapIROCArray = 0;
591 TVectorF *mapOROCArray = 0;
592 Int_t mapEntries = 0;
593 TString* mapNames = 0;
594
595 if (mapFileName) {
596 TFile mapFile(mapFileName, "read");
597
598 TList* listOfROCs = mapFile.GetListOfKeys();
599 mapEntries = listOfROCs->GetEntries()/2;
600 mapIROCs = new TObjArray(mapEntries*2);
601 mapOROCs = new TObjArray(mapEntries*2);
602 mapIROCArray = new TVectorF[mapEntries];
603 mapOROCArray = new TVectorF[mapEntries];
604
605 mapNames = new TString[mapEntries];
606 for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
418bbcaf 607 TString nameROC(((TKey*)(listOfROCs->At(ivalue*2)))->GetName());
608 nameROC.Remove(nameROC.Length()-4, 4);
609 mapIROCs->AddAt((AliTPCCalROC*)mapFile.Get((nameROC + "IROC").Data()), ivalue);
610 mapOROCs->AddAt((AliTPCCalROC*)mapFile.Get((nameROC + "OROC").Data()), ivalue);
611 mapNames[ivalue].Append(nameROC);
86df2b3a 612 }
613
614 for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
615 mapIROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(0));
616 mapOROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(36));
617
618 for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(0); ichannel++)
619 (mapIROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapIROCs->At(ivalue)))->GetValue(ichannel);
620 for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(36); ichannel++)
621 (mapOROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapOROCs->At(ivalue)))->GetValue(ichannel);
622 }
623
624 } // if (mapFileName)
625
626 TTreeSRedirector cstream(fileName);
627 Int_t arrayEntries = array->GetEntries();
628
629 TString* names = new TString[arrayEntries];
630 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
631 names[ivalue].Append(((AliTPCCalPad*)array->At(ivalue))->GetName());
632
633 for (UInt_t isector = 0; isector < tpcROCinstance->GetNSectors(); isector++) {
634 //
635 // get statistic for given sector
636 //
637 TVectorF median(arrayEntries);
638 TVectorF mean(arrayEntries);
639 TVectorF rms(arrayEntries);
640 TVectorF ltm(arrayEntries);
641 TVectorF ltmrms(arrayEntries);
642 TVectorF medianWithOut(arrayEntries);
643 TVectorF meanWithOut(arrayEntries);
644 TVectorF rmsWithOut(arrayEntries);
645 TVectorF ltmWithOut(arrayEntries);
646 TVectorF ltmrmsWithOut(arrayEntries);
647
648 TVectorF *vectorArray = new TVectorF[arrayEntries];
649 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
650 vectorArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
651
652 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
653 AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
654 AliTPCCalROC* calROC = calPad->GetCalROC(isector);
655 AliTPCCalROC* outlierROC = 0;
656 if (outlierPad) outlierROC = outlierPad->GetCalROC(isector);
657 if (calROC) {
658 median[ivalue] = calROC->GetMedian();
659 mean[ivalue] = calROC->GetMean();
660 rms[ivalue] = calROC->GetRMS();
661 Double_t ltmrmsValue = 0;
662 ltm[ivalue] = calROC->GetLTM(&ltmrmsValue, ltmFraction);
663 ltmrms[ivalue] = ltmrmsValue;
664 if (outlierROC) {
665 medianWithOut[ivalue] = calROC->GetMedian(outlierROC);
666 meanWithOut[ivalue] = calROC->GetMean(outlierROC);
667 rmsWithOut[ivalue] = calROC->GetRMS(outlierROC);
668 ltmrmsValue = 0;
669 ltmWithOut[ivalue] = calROC->GetLTM(&ltmrmsValue, ltmFraction, outlierROC);
670 ltmrmsWithOut[ivalue] = ltmrmsValue;
671 }
672 }
673 else {
674 median[ivalue] = 0.;
675 mean[ivalue] = 0.;
676 rms[ivalue] = 0.;
677 ltm[ivalue] = 0.;
678 ltmrms[ivalue] = 0.;
679 medianWithOut[ivalue] = 0.;
680 meanWithOut[ivalue] = 0.;
681 rmsWithOut[ivalue] = 0.;
682 ltmWithOut[ivalue] = 0.;
683 ltmrmsWithOut[ivalue] = 0.;
684 }
685 }
686
687 //
688 // fill vectors of variable per pad
689 //
690 TVectorF *posArray = new TVectorF[8];
691 for (Int_t ivalue = 0; ivalue < 8; ivalue++)
692 posArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
693
694 Float_t posG[3] = {0};
695 Float_t posL[3] = {0};
696 Int_t ichannel = 0;
697 for (UInt_t irow = 0; irow < tpcROCinstance->GetNRows(isector); irow++) {
698 for (UInt_t ipad = 0; ipad < tpcROCinstance->GetNPads(isector, irow); ipad++) {
699 tpcROCinstance->GetPositionLocal(isector, irow, ipad, posL);
700 tpcROCinstance->GetPositionGlobal(isector, irow, ipad, posG);
701 posArray[0][ichannel] = irow;
702 posArray[1][ichannel] = ipad;
703 posArray[2][ichannel] = posL[0];
704 posArray[3][ichannel] = posL[1];
705 posArray[4][ichannel] = posG[0];
706 posArray[5][ichannel] = posG[1];
707 posArray[6][ichannel] = (Int_t)(ipad - (Double_t)(tpcROCinstance->GetNPads(isector, irow))/2);
708 posArray[7][ichannel] = ichannel;
709
710 // loop over array containing AliTPCCalPads
711 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
712 AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
713 AliTPCCalROC* calROC = calPad->GetCalROC(isector);
714 if (calROC)
715 (vectorArray[ivalue])[ichannel] = calROC->GetValue(irow, ipad);
716 else
717 (vectorArray[ivalue])[ichannel] = 0;
718 }
719 ichannel++;
720 }
721 }
722
723 cstream << "calPads" <<
724 "sector=" << isector;
725
726 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
727 cstream << "calPads" <<
728 (Char_t*)((names[ivalue] + "_Median=").Data()) << median[ivalue] <<
729 (Char_t*)((names[ivalue] + "_Mean=").Data()) << mean[ivalue] <<
730 (Char_t*)((names[ivalue] + "_RMS=").Data()) << rms[ivalue] <<
731 (Char_t*)((names[ivalue] + "_LTM=").Data()) << ltm[ivalue] <<
732 (Char_t*)((names[ivalue] + "_RMS_LTM=").Data()) << ltmrms[ivalue];
733 if (outlierPad) {
734 cstream << "calPads" <<
735 (Char_t*)((names[ivalue] + "_Median_OutlierCutted=").Data()) << medianWithOut[ivalue] <<
736 (Char_t*)((names[ivalue] + "_Mean_OutlierCutted=").Data()) << meanWithOut[ivalue] <<
737 (Char_t*)((names[ivalue] + "_RMS_OutlierCutted=").Data()) << rmsWithOut[ivalue] <<
738 (Char_t*)((names[ivalue] + "_LTM_OutlierCutted=").Data()) << ltmWithOut[ivalue] <<
739 (Char_t*)((names[ivalue] + "_RMS_LTM_OutlierCutted=").Data()) << ltmrmsWithOut[ivalue];
740 }
741 }
742
743 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
744 cstream << "calPads" <<
745 (Char_t*)((names[ivalue] + ".=").Data()) << &vectorArray[ivalue];
746 }
747
748 if (mapFileName) {
749 for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
750 if (isector < 36)
751 cstream << "calPads" <<
752 (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapIROCArray[ivalue];
753 else
754 cstream << "calPads" <<
755 (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapOROCArray[ivalue];
756 }
757 }
758
759 cstream << "calPads" <<
760 "row.=" << &posArray[0] <<
761 "pad.=" << &posArray[1] <<
762 "lx.=" << &posArray[2] <<
763 "ly.=" << &posArray[3] <<
764 "gx.=" << &posArray[4] <<
765 "gy.=" << &posArray[5] <<
766 "rpad.=" << &posArray[6] <<
767 "channel.=" << &posArray[7];
768
769 cstream << "calPads" <<
770 "\n";
771
772 delete[] posArray;
773 delete[] vectorArray;
774 }
775
776
777 delete[] names;
778 if (mapFileName) {
779 delete mapIROCs;
780 delete mapOROCs;
781 delete[] mapIROCArray;
782 delete[] mapOROCArray;
783 delete[] mapNames;
784 }
785}
3ac615eb 786
f14d21a1 787Int_t AliTPCcalibDB::GetRCUTriggerConfig() const
788{
789 //
790 // return the RCU trigger configuration register
791 //
792 TMap *map=GetRCUconfig();
793 if (!map) return -1;
794 TVectorF *v=(TVectorF*)map->GetValue("TRGCONF_TRG_MODE");
795 Float_t mode=-1;
796 for (Int_t i=0; i<v->GetNrows(); ++i){
797 Float_t newmode=v->GetMatrixArray()[i];
798 if (newmode>-1){
799 if (mode>-1&&newmode!=mode) AliWarning("Found different RCU trigger configurations!!!");
800 mode=newmode;
801 }
802 }
803 return (Int_t)mode;
804}
805
806Bool_t AliTPCcalibDB::IsTrgL0()
807{
808 //
809 // return if the FEE readout was triggered on L0
810 //
811 Int_t mode=GetRCUTriggerConfig();
812 if (mode<0) return kFALSE;
7fe54a9b 813 return (mode==1);
f14d21a1 814}
3ac615eb 815
f14d21a1 816Bool_t AliTPCcalibDB::IsTrgL1()
817{
818 //
819 // return if the FEE readout was triggered on L1
820 //
821 Int_t mode=GetRCUTriggerConfig();
822 if (mode<0) return kFALSE;
7fe54a9b 823 return (mode==0);
f14d21a1 824}
3ac615eb 825
826void AliTPCcalibDB::RegisterExB(Int_t index, Float_t bz, Bool_t bdelete){
827 //
828 // Register static ExB correction map
829 // index - registration index - used for visualization
830 // bz - bz field in kGaus
831
0a997b33 832 // Float_t factor = bz/(-5.); // default b filed in Cheb with minus sign
833 Float_t factor = bz/(5.); // default b filed in Cheb with minus sign
834 // was chenged in the Revision ???? (Ruben can you add here number)
3ac615eb 835
4642ac4b 836 AliMagF* bmap = new AliMagF("MapsExB","MapsExB", factor,TMath::Sign(1.f,factor),AliMagF::k5kG);
3ac615eb 837
838 AliTPCExBFirst *exb = new AliTPCExBFirst(bmap,0.88*2.6400e+04,50,50,50);
839 AliTPCExB::SetInstance(exb);
840
841 if (bdelete){
842 delete bmap;
843 }else{
844 AliTPCExB::RegisterField(index,bmap);
845 }
846 if (index>=fgExBArray.GetEntries()) fgExBArray.Expand((index+1)*2+11);
847 fgExBArray.AddAt(exb,index);
848}
849
850
851AliTPCExB* AliTPCcalibDB::GetExB(Float_t bz, Bool_t deleteB) {
852 //
853 // bz filed in KGaus not in tesla
854 // Get ExB correction map
855 // if doesn't exist - create it
856 //
857 Int_t index = TMath::Nint(5+bz);
858 if (index>fgExBArray.GetEntries()) fgExBArray.Expand((index+1)*2+11);
859 if (!fgExBArray.At(index)) AliTPCcalibDB::RegisterExB(index,bz,deleteB);
860 return (AliTPCExB*)fgExBArray.At(index);
861}
862
863
864void AliTPCcalibDB::SetExBField(Float_t bz){
865 //
866 // Set magnetic filed for ExB correction
867 //
868 fExB = GetExB(bz,kFALSE);
869}
bf85fe4d 870
0a997b33 871void AliTPCcalibDB::SetExBField(const AliMagF* bmap){
872 //
873 // Set magnetic field for ExB correction
874 //
875 AliTPCExBFirst *exb = new AliTPCExBFirst(bmap,0.88*2.6400e+04,50,50,50);
876 AliTPCExB::SetInstance(exb);
877 fExB=exb;
878}
879
bf85fe4d 880
881
5e1215d4 882
883
884void AliTPCcalibDB::UpdateRunInformations( Int_t run, Bool_t force){
bf85fe4d 885 //
886 // - > Don't use it for reconstruction - Only for Calibration studies
887 //
b96c3aef 888 if (run<=0) return;
bf85fe4d 889 AliCDBEntry * entry = 0;
cc65e4f5 890 if (run>= fRunList.fN){
bf85fe4d 891 fRunList.Set(run*2+1);
da6c0bc9 892 fGRPArray.Expand(run*2+1);
0231c65f 893 fGRPMaps.Expand(run*2+1);
e2914767 894 fGoofieArray.Expand(run*2+1);
895 fVoltageArray.Expand(run*2+1);
da6c0bc9 896 fTemperatureArray.Expand(run*2+1);
897 fVdriftArray.Expand(run*2+1);
5e1215d4 898 fDriftCorrectionArray.Expand(run*2+1);
a2c3785e 899 fTimeGainSplinesArray.Expand(run*2+1);
cc65e4f5 900 //
901 //
902 fALTROConfigData->Expand(run*2+1); // ALTRO configuration data
903 fPulserData->Expand(run*2+1); // Calibration Pulser data
904 fCEData->Expand(run*2+1); // CE data
d32e8676 905 if (!fTimeGainSplines) fTimeGainSplines = new TObjArray(run*2+1);
cc65e4f5 906 fTimeGainSplines->Expand(run*2+1); // Array of AliSplineFits: at 0 MIP position in
bf85fe4d 907 }
cc65e4f5 908 if (fRunList[run]>0 &&force==kFALSE) return;
1e722a63 909
910 fRunList[run]=1; // sign as used
911
5e1215d4 912 //
bf85fe4d 913 entry = AliCDBManager::Instance()->Get("GRP/GRP/Data",run);
0231c65f 914 if (entry) {
915 AliGRPObject * grpRun = dynamic_cast<AliGRPObject*>(entry->GetObject());
916 if (!grpRun){
917 TMap* map = dynamic_cast<TMap*>(entry->GetObject());
918 if (map){
e2914767 919 //grpRun = new AliGRPObject;
920 //grpRun->ReadValuesFromMap(map);
921 grpRun = MakeGRPObjectFromMap(map);
922
0231c65f 923 fGRPMaps.AddAt(map,run);
924 }
925 }
926 fGRPArray.AddAt(grpRun,run);
927 }
bf85fe4d 928 entry = AliCDBManager::Instance()->Get("TPC/Calib/Goofie",run);
5e1215d4 929 if (entry){
930 fGoofieArray.AddAt(entry->GetObject(),run);
931 }
e2914767 932 //
2293155b 933
e2914767 934 //
a2c3785e 935 entry = AliCDBManager::Instance()->Get("TPC/Calib/TimeGain",run);
5e1215d4 936 if (entry) {
937 fTimeGainSplinesArray.AddAt(entry->GetObject(),run);
2293155b 938 }else{
939 AliFatal("TPC - Missing calibration entry TimeGain")
5e1215d4 940 }
941 //
942 entry = AliCDBManager::Instance()->Get("TPC/Calib/TimeDrift",run);
943 if (entry) {
944 fDriftCorrectionArray.AddAt(entry->GetObject(),run);
2293155b 945 }else{
946 AliFatal("TPC - Missing calibration entry TimeDrift")
5e1215d4 947 }
a2c3785e 948 //
bf85fe4d 949 entry = AliCDBManager::Instance()->Get("TPC/Calib/Temperature",run);
5e1215d4 950 if (entry) {
951 fTemperatureArray.AddAt(entry->GetObject(),run);
952 }
1e722a63 953 //apply fDButil filters
954
955 fDButil->UpdateFromCalibDB();
956 if (fTemperature) fDButil->FilterTemperature(fTemperature);
da6c0bc9 957
bfec3eeb 958 AliDCSSensor * press = GetPressureSensor(run,0);
da6c0bc9 959 AliTPCSensorTempArray * temp = GetTemperatureSensor(run);
1e722a63 960 Bool_t accept=kTRUE;
961 if (temp) {
962 accept = fDButil->FilterTemperature(temp)>0.1;
963 }
964 if (press) {
965 const Double_t kMinP=950.;
966 const Double_t kMaxP=1050.;
967 const Double_t kMaxdP=10.;
968 const Double_t kSigmaCut=4.;
969 fDButil->FilterSensor(press,kMinP,kMaxP,kMaxdP,kSigmaCut);
970 if (press->GetFit()==0) accept=kFALSE;
971 }
972 if (press && temp &&accept){
da6c0bc9 973 AliTPCCalibVdrift * vdrift = new AliTPCCalibVdrift(temp, press,0);
974 fVdriftArray.AddAt(vdrift,run);
975 }
1e722a63 976 fDButil->FilterCE(120., 3., 4.,0);
977 fDButil->FilterTracks(run, 10.,0);
bf85fe4d 978}
979
980
981Float_t AliTPCcalibDB::GetGain(Int_t sector, Int_t row, Int_t pad){
982 //
983 //
984 AliTPCCalPad *calPad = Instance()->fDedxGainFactor;;
985 if (!calPad) return 0;
986 return calPad->GetCalROC(sector)->GetValue(row,pad);
987}
988
7390f655 989AliSplineFit* AliTPCcalibDB::GetVdriftSplineFit(const char* name, Int_t run){
990 //
991 //
992 //
993 TObjArray *arr=GetTimeVdriftSplineRun(run);
994 if (!arr) return 0;
995 return dynamic_cast<AliSplineFit*>(arr->FindObject(name));
996}
997
2cb269df 998AliSplineFit* AliTPCcalibDB::CreateVdriftSplineFit(const char* graphName, Int_t run){
999 //
1000 // create spline fit from the drift time graph in TimeDrift
1001 //
1002 TObjArray *arr=GetTimeVdriftSplineRun(run);
1003 if (!arr) return 0;
1004 TGraph *graph=dynamic_cast<TGraph*>(arr->FindObject(graphName));
1005 if (!graph) return 0;
1006 AliSplineFit *fit = new AliSplineFit();
1007 fit->SetGraph(graph);
1008 fit->SetMinPoints(graph->GetN()+1);
1009 fit->InitKnots(graph,2,0,0.001);
1010 fit->SplineFit(0);
1011 return fit;
1012}
8de77f00 1013
1014AliGRPObject *AliTPCcalibDB::GetGRP(Int_t run){
1015 //
1016 // Get GRP object for given run
1017 //
1018 AliGRPObject * grpRun = dynamic_cast<AliGRPObject *>((Instance()->fGRPArray).At(run));
1019 if (!grpRun) {
5e1215d4 1020 Instance()->UpdateRunInformations(run);
8de77f00 1021 grpRun = dynamic_cast<AliGRPObject *>(Instance()->fGRPArray.At(run));
1022 if (!grpRun) return 0;
1023 }
1024 return grpRun;
1025}
1026
0231c65f 1027TMap * AliTPCcalibDB::GetGRPMap(Int_t run){
1028 //
1029 //
1030 //
1031 TMap * grpRun = dynamic_cast<TMap *>((Instance()->fGRPMaps).At(run));
1032 if (!grpRun) {
5e1215d4 1033 Instance()->UpdateRunInformations(run);
0231c65f 1034 grpRun = dynamic_cast<TMap *>(Instance()->fGRPMaps.At(run));
1035 if (!grpRun) return 0;
1036 }
1037 return grpRun;
1038}
8de77f00 1039
1040
da6c0bc9 1041AliDCSSensor * AliTPCcalibDB::GetPressureSensor(Int_t run, Int_t type){
bf85fe4d 1042 //
0231c65f 1043 // Get Pressure sensor
bfec3eeb 1044 // run = run number
1045 // type = 0 - Cavern pressure
1046 // 1 - Suface pressure
0231c65f 1047 // First try to get if trom map - if existing (Old format of data storing)
bf85fe4d 1048 //
bfec3eeb 1049
1050
0231c65f 1051 TMap *map = GetGRPMap(run);
1052 if (map){
1053 AliDCSSensor * sensor = 0;
1054 TObject *osensor=0;
1055 if (type==0) osensor = ((*map)("fCavernPressure"));
1056 if (type==1) osensor = ((*map)("fP2Pressure"));
1057 sensor =dynamic_cast<AliDCSSensor *>(osensor);
1058 if (sensor) return sensor;
1059 }
1060 //
1061 // If not map try to get it from the GRPObject
1062 //
1063 AliGRPObject * grpRun = dynamic_cast<AliGRPObject *>(fGRPArray.At(run));
bf85fe4d 1064 if (!grpRun) {
5e1215d4 1065 UpdateRunInformations(run);
efdbb95a 1066 grpRun = dynamic_cast<AliGRPObject *>(fGRPArray.At(run));
bf85fe4d 1067 if (!grpRun) return 0;
1068 }
1069 AliDCSSensor * sensor = grpRun->GetCavernAtmosPressure();
da6c0bc9 1070 if (type==1) sensor = grpRun->GetSurfaceAtmosPressure();
1071 return sensor;
bf85fe4d 1072}
1073
1074AliTPCSensorTempArray * AliTPCcalibDB::GetTemperatureSensor(Int_t run){
1075 //
1076 // Get temperature sensor array
1077 //
1078 AliTPCSensorTempArray * tempArray = (AliTPCSensorTempArray *)fTemperatureArray.At(run);
1079 if (!tempArray) {
5e1215d4 1080 UpdateRunInformations(run);
bf85fe4d 1081 tempArray = (AliTPCSensorTempArray *)fTemperatureArray.At(run);
1082 }
1083 return tempArray;
1084}
1085
a2c3785e 1086
1087TObjArray * AliTPCcalibDB::GetTimeGainSplinesRun(Int_t run){
bf85fe4d 1088 //
1089 // Get temperature sensor array
1090 //
a2c3785e 1091 TObjArray * gainSplines = (TObjArray *)fTimeGainSplinesArray.At(run);
1092 if (!gainSplines) {
5e1215d4 1093 UpdateRunInformations(run);
a2c3785e 1094 gainSplines = (TObjArray *)fTimeGainSplinesArray.At(run);
bf85fe4d 1095 }
a2c3785e 1096 return gainSplines;
bf85fe4d 1097}
1098
7390f655 1099TObjArray * AliTPCcalibDB::GetTimeVdriftSplineRun(Int_t run){
1100 //
1101 // Get drift spline array
1102 //
1103 TObjArray * driftSplines = (TObjArray *)fDriftCorrectionArray.At(run);
1104 if (!driftSplines) {
1105 UpdateRunInformations(run);
1106 driftSplines = (TObjArray *)fDriftCorrectionArray.At(run);
1107 }
1108 return driftSplines;
1109}
1110
e2914767 1111AliDCSSensorArray * AliTPCcalibDB::GetVoltageSensors(Int_t run){
1112 //
1113 // Get temperature sensor array
1114 //
1115 AliDCSSensorArray * voltageArray = (AliDCSSensorArray *)fVoltageArray.At(run);
1116 if (!voltageArray) {
5e1215d4 1117 UpdateRunInformations(run);
e2914767 1118 voltageArray = (AliDCSSensorArray *)fVoltageArray.At(run);
1119 }
1120 return voltageArray;
1121}
1122
99895a4f 1123AliDCSSensorArray * AliTPCcalibDB::GetGoofieSensors(Int_t run){
1124 //
1125 // Get temperature sensor array
1126 //
1127 AliDCSSensorArray * goofieArray = (AliDCSSensorArray *)fGoofieArray.At(run);
1128 if (!goofieArray) {
5e1215d4 1129 UpdateRunInformations(run);
99895a4f 1130 goofieArray = (AliDCSSensorArray *)fGoofieArray.At(run);
1131 }
1132 return goofieArray;
1133}
1134
1135
1136
da6c0bc9 1137AliTPCCalibVdrift * AliTPCcalibDB::GetVdrift(Int_t run){
1138 //
1139 // Get the interface to the the vdrift
1140 //
1141 AliTPCCalibVdrift * vdrift = (AliTPCCalibVdrift*)fVdriftArray.At(run);
1142 if (!vdrift) {
5e1215d4 1143 UpdateRunInformations(run);
da6c0bc9 1144 vdrift= (AliTPCCalibVdrift*)fVdriftArray.At(run);
1145 }
1146 return vdrift;
1147}
1148
892226be 1149Float_t AliTPCcalibDB::GetCEdriftTime(Int_t run, Int_t sector, Double_t timeStamp, Int_t *entries)
1150{
1151 //
1152 // GetCE drift time information for 'sector'
1153 // sector 72 is the mean drift time of the A-Side
1154 // sector 73 is the mean drift time of the C-Side
1155 // it timestamp==-1 return mean value
1156 //
1157 AliTPCcalibDB::Instance()->SetRun(run);
1158 TGraph *gr=AliTPCcalibDB::Instance()->GetCErocTgraph(sector);
1159 if (!gr||sector<0||sector>73) {
1160 if (entries) *entries=0;
1161 return 0.;
1162 }
1163 Float_t val=0.;
1164 if (timeStamp==-1.){
1165 val=gr->GetMean(2);
1166 }else{
1167 for (Int_t ipoint=0;ipoint<gr->GetN();++ipoint){
1168 Double_t x,y;
1169 gr->GetPoint(ipoint,x,y);
1170 if (x<timeStamp) continue;
1171 val=y;
1172 break;
1173 }
1174 }
1175 return val;
1176}
1177
1178Float_t AliTPCcalibDB::GetCEchargeTime(Int_t run, Int_t sector, Double_t timeStamp, Int_t *entries)
1179{
1180 //
1181 // GetCE mean charge for 'sector'
1182 // it timestamp==-1 return mean value
1183 //
1184 AliTPCcalibDB::Instance()->SetRun(run);
1185 TGraph *gr=AliTPCcalibDB::Instance()->GetCErocQgraph(sector);
1186 if (!gr||sector<0||sector>71) {
1187 if (entries) *entries=0;
1188 return 0.;
1189 }
1190 Float_t val=0.;
1191 if (timeStamp==-1.){
1192 val=gr->GetMean(2);
1193 }else{
1194 for (Int_t ipoint=0;ipoint<gr->GetN();++ipoint){
1195 Double_t x,y;
1196 gr->GetPoint(ipoint,x,y);
1197 if (x<timeStamp) continue;
1198 val=y;
1199 break;
1200 }
1201 }
1202 return val;
1203}
1204
7fff7612 1205Float_t AliTPCcalibDB::GetDCSSensorValue(AliDCSSensorArray *arr, Int_t timeStamp, const char * sensorName, Int_t sigDigits)
1206{
1207 //
1208 // Get Value for a DCS sensor 'sensorName', run 'run' at time 'timeStamp'
1209 //
1210 Float_t val=0;
1211 const TString sensorNameString(sensorName);
1212 AliDCSSensor *sensor = arr->GetSensor(sensorNameString);
1213 if (!sensor) return val;
892226be 1214 //use the dcs graph if possible
1215 TGraph *gr=sensor->GetGraph();
1216 if (gr){
1217 for (Int_t ipoint=0;ipoint<gr->GetN();++ipoint){
1218 Double_t x,y;
1219 gr->GetPoint(ipoint,x,y);
7390f655 1220 Int_t time=TMath::Nint(sensor->GetStartTime()+x*3600); //time in graph is hours
892226be 1221 if (time<timeStamp) continue;
1222 val=y;
1223 break;
1224 }
1225 //if val is still 0, test if if the requested time if within 5min of the first/last
1226 //data point. If this is the case return the firs/last entry
1227 //the timestamps might not be syncronised for all calibration types, sometimes a 'pre'
1228 //and 'pos' period is requested. Especially to the HV this is not the case!
1229 //first point
1230 if (val==0 ){
1231 Double_t x,y;
1232 gr->GetPoint(0,x,y);
7390f655 1233 Int_t time=TMath::Nint(sensor->GetStartTime()+x*3600); //time in graph is hours
892226be 1234 if ((time-timeStamp)<5*60) val=y;
1235 }
1236 //last point
1237 if (val==0 ){
1238 Double_t x,y;
1239 gr->GetPoint(gr->GetN()-1,x,y);
7390f655 1240 Int_t time=TMath::Nint(sensor->GetStartTime()+x*3600); //time in graph is hours
892226be 1241 if ((timeStamp-time)<5*60) val=y;
1242 }
1243 } else {
1244 val=sensor->GetValue(timeStamp);
1245 }
7fff7612 1246 if (sigDigits>=0){
1247 val=(Float_t)TMath::Floor(val * TMath::Power(10., sigDigits) + .5) / TMath::Power(10., sigDigits);
1248 }
1249 return val;
1250}
1251
1252Float_t AliTPCcalibDB::GetDCSSensorMeanValue(AliDCSSensorArray *arr, const char * sensorName, Int_t sigDigits)
1253{
1254 //
1255 // Get mean Value for a DCS sensor 'sensorName' during run 'run'
1256 //
1257 Float_t val=0;
1258 const TString sensorNameString(sensorName);
1259 AliDCSSensor *sensor = arr->GetSensor(sensorNameString);
1260 if (!sensor) return val;
892226be 1261
1262 //use dcs graph if it exists
1263 TGraph *gr=sensor->GetGraph();
1264 if (gr){
1265 val=gr->GetMean(2);
1266 } else {
1267 //if we don't have the dcs graph, try to get some meaningful information
1268 if (!sensor->GetFit()) return val;
1269 Int_t nKnots=sensor->GetFit()->GetKnots();
1270 Double_t tMid=(sensor->GetEndTime()-sensor->GetStartTime())/2.;
1271 for (Int_t iKnot=0;iKnot<nKnots;++iKnot){
1272 if (sensor->GetFit()->GetX()[iKnot]>tMid/3600.) break;
1273 val=(Float_t)sensor->GetFit()->GetY0()[iKnot];
1274 }
7fff7612 1275 }
7fff7612 1276 if (sigDigits>=0){
1277 val/=10;
1278 val=(Float_t)TMath::Floor(val * TMath::Power(10., sigDigits) + .5) / TMath::Power(10., sigDigits);
1279 val*=10;
1280 }
1281 return val;
1282}
bf85fe4d 1283
7fff7612 1284Float_t AliTPCcalibDB::GetChamberHighVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits) {
e2914767 1285 //
1286 // return the chamber HV for given run and time: 0-35 IROC, 36-72 OROC
7fff7612 1287 // if timeStamp==-1 return mean value
1288 //
1289 Float_t val=0;
1290 TString sensorName="";
1291 TTimeStamp stamp(timeStamp);
1292 AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run);
1293 if (!voltageArray || (sector<0) || (sector>71)) return val;
1294 Char_t sideName='A';
1295 if ((sector/18)%2==1) sideName='C';
1296 if (sector<36){
1297 //IROC
1298 sensorName=Form("TPC_ANODE_I_%c%02d_VMEAS",sideName,sector%18);
1299 }else{
1300 //OROC
1301 sensorName=Form("TPC_ANODE_O_%c%02d_0_VMEAS",sideName,sector%18);
1302 }
1303 if (timeStamp==-1){
1304 val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits);
1305 } else {
1306 val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits);
1307 }
1308 return val;
1309}
1310Float_t AliTPCcalibDB::GetSkirtVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
1311{
1312 //
1313 // Get the skirt voltage for 'run' at 'timeStamp' and 'sector': 0-35 IROC, 36-72 OROC
1314 // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
1315 // if timeStamp==-1 return the mean value for the run
1316 //
1317 Float_t val=0;
1318 TString sensorName="";
1319 TTimeStamp stamp(timeStamp);
1320 AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run);
1321 if (!voltageArray || (sector<0) || (sector>71)) return val;
1322 Char_t sideName='A';
1323 if ((sector/18)%2==1) sideName='C';
1324 sensorName=Form("TPC_SKIRT_%c_VMEAS",sideName);
1325 if (timeStamp==-1){
1326 val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits);
1327 } else {
1328 val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits);
1329 }
1330 return val;
1331}
1332
1333Float_t AliTPCcalibDB::GetCoverVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
1334{
1335 //
1336 // Get the cover voltage for run 'run' at time 'timeStamp'
1337 // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
1338 // if timeStamp==-1 return the mean value for the run
e2914767 1339 //
7fff7612 1340 Float_t val=0;
1341 TString sensorName="";
e2914767 1342 TTimeStamp stamp(timeStamp);
1343 AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run);
7fff7612 1344 if (!voltageArray || (sector<0) || (sector>71)) return val;
1345 Char_t sideName='A';
1346 if ((sector/18)%2==1) sideName='C';
1347 if (sector<36){
1348 //IROC
1349 sensorName=Form("TPC_COVER_I_%c_VMEAS",sideName);
1350 }else{
1351 //OROC
1352 sensorName=Form("TPC_COVER_O_%c_VMEAS",sideName);
1353 }
1354 if (timeStamp==-1){
1355 val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits);
1356 } else {
1357 val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits);
1358 }
1359 return val;
1360}
1361
1362Float_t AliTPCcalibDB::GetGGoffsetVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
1363{
1364 //
1365 // Get the GG offset voltage for run 'run' at time 'timeStamp'
1366 // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
1367 // if timeStamp==-1 return the mean value for the run
1368 //
1369 Float_t val=0;
1370 TString sensorName="";
1371 TTimeStamp stamp(timeStamp);
1372 AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run);
1373 if (!voltageArray || (sector<0) || (sector>71)) return val;
1374 Char_t sideName='A';
1375 if ((sector/18)%2==1) sideName='C';
1376 if (sector<36){
1377 //IROC
1378 sensorName=Form("TPC_GATE_I_%c_OFF_VMEAS",sideName);
1379 }else{
1380 //OROC
1381 sensorName=Form("TPC_GATE_O_%c_OFF_VMEAS",sideName);
1382 }
1383 if (timeStamp==-1){
1384 val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits);
1385 } else {
1386 val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits);
1387 }
1388 return val;
1389}
1390
1391Float_t AliTPCcalibDB::GetGGnegVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
1392{
1393 //
1394 // Get the GG offset voltage for run 'run' at time 'timeStamp'
1395 // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
1396 // if timeStamp==-1 return the mean value for the run
1397 //
1398 Float_t val=0;
1399 TString sensorName="";
1400 TTimeStamp stamp(timeStamp);
1401 AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run);
1402 if (!voltageArray || (sector<0) || (sector>71)) return val;
1403 Char_t sideName='A';
1404 if ((sector/18)%2==1) sideName='C';
1405 if (sector<36){
1406 //IROC
1407 sensorName=Form("TPC_GATE_I_%c_NEG_VMEAS",sideName);
1408 }else{
1409 //OROC
1410 sensorName=Form("TPC_GATE_O_%c_NEG_VMEAS",sideName);
1411 }
1412 if (timeStamp==-1){
1413 val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits);
1414 } else {
1415 val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits);
1416 }
1417 return val;
1418}
1419
1420Float_t AliTPCcalibDB::GetGGposVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
1421{
1422 //
1423 // Get the GG offset voltage for run 'run' at time 'timeStamp'
1424 // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
1425 // if timeStamp==-1 return the mean value for the run
1426 //
1427 Float_t val=0;
1428 TString sensorName="";
1429 TTimeStamp stamp(timeStamp);
1430 AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run);
1431 if (!voltageArray || (sector<0) || (sector>71)) return val;
1432 Char_t sideName='A';
1433 if ((sector/18)%2==1) sideName='C';
1434 if (sector<36){
1435 //IROC
1436 sensorName=Form("TPC_GATE_I_%c_POS_VMEAS",sideName);
1437 }else{
1438 //OROC
1439 sensorName=Form("TPC_GATE_O_%c_POS_VMEAS",sideName);
1440 }
1441 if (timeStamp==-1){
1442 val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits);
1443 } else {
1444 val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits);
1445 }
1446 return val;
e2914767 1447}
bf85fe4d 1448
da6c0bc9 1449Float_t AliTPCcalibDB::GetPressure(Int_t timeStamp, Int_t run, Int_t type){
bf85fe4d 1450 //
1451 // GetPressure for given time stamp and runt
1452 //
1453 TTimeStamp stamp(timeStamp);
da6c0bc9 1454 AliDCSSensor * sensor = Instance()->GetPressureSensor(run,type);
bf85fe4d 1455 if (!sensor) return 0;
bf85fe4d 1456 return sensor->GetValue(stamp);
1457}
1458
5312f439 1459Float_t AliTPCcalibDB::GetL3Current(Int_t run, Int_t statType){
1460 //
1461 // return L3 current
1462 // stat type is: AliGRPObject::Stats: kMean = 0, kTruncMean = 1, kMedian = 2, kSDMean = 3, kSDMedian = 4
1463 //
1464 Float_t current=-1;
1465 AliGRPObject *grp=AliTPCcalibDB::GetGRP(run);
1466 if (grp) current=grp->GetL3Current((AliGRPObject::Stats)statType);
1467 return current;
1468}
1469
1470Float_t AliTPCcalibDB::GetBz(Int_t run){
1471 //
e6970ab5 1472 // calculate BZ in T from L3 current
5312f439 1473 //
1474 Float_t bz=-1;
1475 Float_t current=AliTPCcalibDB::GetL3Current(run);
e6970ab5 1476 if (current>-1) bz=5*current/30000.*.1;
5312f439 1477 return bz;
1478}
1479
1480Char_t AliTPCcalibDB::GetL3Polarity(Int_t run) {
1481 //
1482 // get l3 polarity from GRP
1483 //
7390f655 1484 Char_t pol=-100;
1485 AliGRPObject *grp=AliTPCcalibDB::GetGRP(run);
1486 if (grp) pol=grp->GetL3Polarity();
1487 return pol;
5312f439 1488}
1489
1490TString AliTPCcalibDB::GetRunType(Int_t run){
1491 //
1492 // return run type from grp
1493 //
7390f655 1494
1495// TString type("UNKNOWN");
1496 AliGRPObject *grp=AliTPCcalibDB::GetGRP(run);
1497 if (grp) return grp->GetRunType();
1498 return "UNKNOWN";
5312f439 1499}
1500
7f7847fe 1501Float_t AliTPCcalibDB::GetValueGoofie(Int_t timeStamp, Int_t run, Int_t type){
1502 //
1503 // GetPressure for given time stamp and runt
1504 //
1505 TTimeStamp stamp(timeStamp);
1506 AliDCSSensorArray* goofieArray = AliTPCcalibDB::Instance()->GetGoofieSensors(run);
1507 if (!goofieArray) return 0;
1508 AliDCSSensor *sensor = goofieArray->GetSensor(type);
1509 return sensor->GetValue(stamp);
1510}
1511
1512
1513
1514
1515
1516
f0269955 1517Bool_t AliTPCcalibDB::GetTemperatureFit(Int_t timeStamp, Int_t run, Int_t side,TVectorD& fit){
1518 //
1519 //
1520 //
1521 TTimeStamp tstamp(timeStamp);
64b48395 1522 AliTPCSensorTempArray* tempArray = Instance()->GetTemperatureSensor(run);
f0269955 1523 if (! tempArray) return kFALSE;
1524 AliTPCTempMap * tempMap = new AliTPCTempMap(tempArray);
1525 TLinearFitter * fitter = tempMap->GetLinearFitter(3,side,tstamp);
1526 if (fitter){
1527 fitter->Eval();
1528 fitter->GetParameters(fit);
1529 }
1530 delete fitter;
1531 delete tempMap;
1532 if (!fitter) return kFALSE;
1533 return kTRUE;
1534}
1535
64b48395 1536Float_t AliTPCcalibDB::GetTemperature(Int_t timeStamp, Int_t run, Int_t side){
1537 //
1538 //
1539 //
12e42756 1540 TVectorD vec(5);
64b48395 1541 if (side==0) {
1542 GetTemperatureFit(timeStamp,run,0,vec);
1543 return vec[0];
1544 }
1545 if (side==1){
1546 GetTemperatureFit(timeStamp,run,0,vec);
1547 return vec[0];
1548 }
57dc06f2 1549 return 0;
64b48395 1550}
bf85fe4d 1551
1552
da6c0bc9 1553Double_t AliTPCcalibDB::GetPTRelative(UInt_t timeSec, Int_t run, Int_t side){
1554 //
1555 // Get relative P/T
1556 // time - absolute time
1557 // run - run number
1558 // side - 0 - A side 1-C side
1559 AliTPCCalibVdrift * vdrift = Instance()->GetVdrift(run);
1560 if (!vdrift) return 0;
1561 return vdrift->GetPTRelative(timeSec,side);
1562}
1563
e2914767 1564AliGRPObject * AliTPCcalibDB::MakeGRPObjectFromMap(TMap *map){
1565 //
1566 // Function to covert old GRP run information from TMap to GRPObject
1567 //
1568 // TMap * map = AliTPCcalibDB::GetGRPMap(52406);
1569 if (!map) return 0;
1570 AliDCSSensor * sensor = 0;
1571 TObject *osensor=0;
1572 osensor = ((*map)("fP2Pressure"));
1573 sensor =dynamic_cast<AliDCSSensor *>(osensor);
1574 //
1575 if (!sensor) return 0;
1576 //
1577 AliDCSSensor * sensor2 = new AliDCSSensor(*sensor);
1578 osensor = ((*map)("fCavernPressure"));
1579 TGraph * gr = new TGraph(2);
1580 gr->GetX()[0]= -100000.;
1581 gr->GetX()[1]= 1000000.;
1582 gr->GetY()[0]= atof(osensor->GetName());
1583 gr->GetY()[1]= atof(osensor->GetName());
1584 sensor2->SetGraph(gr);
1585 sensor2->SetFit(0);
1586
1587
1588 AliGRPObject *grpRun = new AliGRPObject;
1589 grpRun->ReadValuesFromMap(map);
1590 grpRun->SetCavernAtmosPressure(sensor2);
1591 grpRun->SetSurfaceAtmosPressure(sensor);
1592 return grpRun;
1593}
1594
5312f439 1595Bool_t AliTPCcalibDB::CreateGUITree(Int_t run, const char* filename)
1596{
1597 //
1598 // Create a gui tree for run number 'run'
1599 //
e2914767 1600
5312f439 1601 if (!AliCDBManager::Instance()->GetDefaultStorage()){
1602 AliLog::Message(AliLog::kError, "Default Storage not set. Cannot create Calibration Tree!",
1603 MODULENAME(), "AliTPCcalibDB", FUNCTIONNAME(), __FILE__, __LINE__);
1604 return kFALSE;
1605 }
1606 //db instance
1607 AliTPCcalibDB *db=AliTPCcalibDB::Instance();
1608 // retrieve cal pad objects
1609 db->SetRun(run);
949d8707 1610 db->CreateGUITree(filename);
7fe54a9b 1611 return kTRUE;
949d8707 1612}
1613
1614Bool_t AliTPCcalibDB::CreateGUITree(const char* filename){
1615 //
1616 //
1617 //
1618 if (!AliCDBManager::Instance()->GetDefaultStorage()){
1619 AliError("Default Storage not set. Cannot create calibration Tree!");
1620 return kFALSE;
1621 }
56ce896d 1622 UpdateNonRec(); // load all infromation now
1623
5312f439 1624 AliTPCPreprocessorOnline prep;
1625 //noise and pedestals
949d8707 1626 if (GetPedestals()) prep.AddComponent(new AliTPCCalPad(*(GetPedestals())));
1627 if (GetPadNoise() ) prep.AddComponent(new AliTPCCalPad(*(GetPadNoise())));
5312f439 1628 //pulser data
949d8707 1629 if (GetPulserTmean()) prep.AddComponent(new AliTPCCalPad(*(GetPulserTmean())));
1630 if (GetPulserTrms() ) prep.AddComponent(new AliTPCCalPad(*(GetPulserTrms())));
1631 if (GetPulserQmean()) prep.AddComponent(new AliTPCCalPad(*(GetPulserQmean())));
5312f439 1632 //CE data
949d8707 1633 if (GetCETmean()) prep.AddComponent(new AliTPCCalPad(*(GetCETmean())));
1634 if (GetCETrms() ) prep.AddComponent(new AliTPCCalPad(*(GetCETrms())));
1635 if (GetCEQmean()) prep.AddComponent(new AliTPCCalPad(*(GetCEQmean())));
5312f439 1636 //Altro data
949d8707 1637 if (GetALTROAcqStart() ) prep.AddComponent(new AliTPCCalPad(*(GetALTROAcqStart() )));
1638 if (GetALTROZsThr() ) prep.AddComponent(new AliTPCCalPad(*(GetALTROZsThr() )));
1639 if (GetALTROFPED() ) prep.AddComponent(new AliTPCCalPad(*(GetALTROFPED() )));
1640 if (GetALTROAcqStop() ) prep.AddComponent(new AliTPCCalPad(*(GetALTROAcqStop() )));
1641 if (GetALTROMasked() ) prep.AddComponent(new AliTPCCalPad(*(GetALTROMasked() )));
1642 //QA
1643 AliTPCdataQA *dataQA=GetDataQA();
1644 if (dataQA) {
1645 if (dataQA->GetNLocalMaxima())
1646 prep.AddComponent(new AliTPCCalPad(*(dataQA->GetNLocalMaxima())));
1647 if (dataQA->GetMaxCharge())
1648 prep.AddComponent(new AliTPCCalPad(*(dataQA->GetMaxCharge())));
1649 if (dataQA->GetMeanCharge())
1650 prep.AddComponent(new AliTPCCalPad(*(dataQA->GetMeanCharge())));
1651 if (dataQA->GetNoThreshold())
1652 prep.AddComponent(new AliTPCCalPad(*(dataQA->GetNoThreshold())));
1653 if (dataQA->GetNTimeBins())
1654 prep.AddComponent(new AliTPCCalPad(*(dataQA->GetNTimeBins())));
1655 if (dataQA->GetNPads())
1656 prep.AddComponent(new AliTPCCalPad(*(dataQA->GetNPads())));
1657 if (dataQA->GetTimePosition())
1658 prep.AddComponent(new AliTPCCalPad(*(dataQA->GetTimePosition())));
1659 }
1660
5312f439 1661 //
1662 TString file(filename);
949d8707 1663 if (file.IsNull()) file=Form("guiTreeRun_%d.root",fRun);
5312f439 1664 prep.DumpToFile(file.Data());
1665 return kTRUE;
1666}
e2914767 1667
7390f655 1668Bool_t AliTPCcalibDB::CreateRefFile(Int_t run, const char* filename)
1669{
1670 //
1671 // Create a gui tree for run number 'run'
1672 //
1673
1674 if (!AliCDBManager::Instance()->GetDefaultStorage()){
1675 AliLog::Message(AliLog::kError, "Default Storage not set. Cannot create Calibration Tree!",
1676 MODULENAME(), "AliTPCcalibDB", FUNCTIONNAME(), __FILE__, __LINE__);
1677 return kFALSE;
1678 }
1679 TString file(filename);
1680 if (file.IsNull()) file=Form("RefCalPads_%d.root",run);
1681 TDirectory *currDir=gDirectory;
1682 //db instance
1683 AliTPCcalibDB *db=AliTPCcalibDB::Instance();
1684 // retrieve cal pad objects
1685 db->SetRun(run);
1686 //open file
1687 TFile f(file.Data(),"recreate");
1688 //noise and pedestals
1689 db->GetPedestals()->Write("Pedestals");
1690 db->GetPadNoise()->Write("PadNoise");
1691 //pulser data
1692 db->GetPulserTmean()->Write("PulserTmean");
1693 db->GetPulserTrms()->Write("PulserTrms");
1694 db->GetPulserQmean()->Write("PulserQmean");
1695 //CE data
1696 db->GetCETmean()->Write("CETmean");
1697 db->GetCETrms()->Write("CETrms");
1698 db->GetCEQmean()->Write("CEQmean");
1699 //Altro data
1700 db->GetALTROAcqStart() ->Write("ALTROAcqStart");
1701 db->GetALTROZsThr() ->Write("ALTROZsThr");
1702 db->GetALTROFPED() ->Write("ALTROFPED");
1703 db->GetALTROAcqStop() ->Write("ALTROAcqStop");
1704 db->GetALTROMasked() ->Write("ALTROMasked");
1705 //
1706 f.Close();
1707 currDir->cd();
1708 return kTRUE;
1709}
17c90083 1710
1711
1712
817766d5 1713Double_t AliTPCcalibDB::GetVDriftCorrectionTime(Int_t timeStamp, Int_t run, Int_t /*side*/, Int_t mode){
17c90083 1714 //
1715 // Get time dependent drift velocity correction
1716 // multiplication factor vd = vdnom *(1+vdriftcorr)
1717 // Arguments:
1718 // mode determines the algorith how to combine the Laser Track, LaserCE and physics tracks
1719 // timestamp - timestamp
1720 // run - run number
1721 // side - the drift velocity per side (possible for laser and CE)
1722 //
1723 // Notice - Extrapolation outside of calibration range - using constant function
1724 //
817766d5 1725 Double_t result;
1e722a63 1726 // mode 1 automatic mode - according to the distance to the valid calibration
1727 // -
cc65e4f5 1728 Double_t deltaP=0, driftP=0, wP = 0.;
1729 Double_t deltaITS=0,driftITS=0, wITS= 0.;
1730 Double_t deltaLT=0, driftLT=0, wLT = 0.;
1731 Double_t deltaCE=0, driftCE=0, wCE = 0.;
1e722a63 1732 driftP = fDButil->GetVDriftTPC(deltaP,run,timeStamp);
cc65e4f5 1733 driftITS= fDButil->GetVDriftTPCITS(deltaITS,run,timeStamp);
1e722a63 1734 driftCE = fDButil->GetVDriftTPCCE(deltaCE, run,timeStamp,36000,2);
1735 driftLT = fDButil->GetVDriftTPCLaserTracks(deltaLT,run,timeStamp,36000,2);
cc65e4f5 1736 deltaITS = TMath::Abs(deltaITS);
1e722a63 1737 deltaP = TMath::Abs(deltaP);
1738 deltaLT = TMath::Abs(deltaLT);
1739 deltaCE = TMath::Abs(deltaCE);
1740 if (mode==1) {
cc65e4f5 1741 const Double_t kEpsilon=0.00000000001;
1742 const Double_t kdeltaT=360.; // 10 minutes
1743 wITS = 64.*kdeltaT/(deltaITS +kdeltaT);
1744 wLT = 16.*kdeltaT/(deltaLT +kdeltaT);
1745 wP = 0. *kdeltaT/(deltaP +kdeltaT);
1746 wCE = 1. *kdeltaT/(deltaCE +kdeltaT);
1747 //
1748 //
1749 if (TMath::Abs(driftP)<kEpsilon) wP=0; // invalid calibration
1750 if (TMath::Abs(driftITS)<kEpsilon)wITS=0; // invalid calibration
1751 if (TMath::Abs(driftLT)<kEpsilon) wLT=0; // invalid calibration
1e722a63 1752 if (TMath::Abs(driftCE)<kEpsilon) wCE=0; // invalid calibration
cc65e4f5 1753 if (wP+wITS+wLT+wCE<kEpsilon) return 0;
1754 result = (driftP*wP+driftITS*wITS+driftLT*wLT+driftCE*wCE)/(wP+wITS+wLT+wCE);
43a74775 1755 }
817766d5 1756
43a74775 1757 return result;
17c90083 1758}
1759
817766d5 1760Double_t AliTPCcalibDB::GetTime0CorrectionTime(Int_t timeStamp, Int_t run, Int_t /*side*/, Int_t mode){
17c90083 1761 //
43a74775 1762 // Get time dependent time 0 (trigger delay in cm) correction
17c90083 1763 // additive correction time0 = time0+ GetTime0CorrectionTime
1764 // Value etracted combining the vdrift correction using laser tracks and CE and the physics track matchin
1765 // Arguments:
1766 // mode determines the algorith how to combine the Laser Track and physics tracks
1767 // timestamp - timestamp
1768 // run - run number
1769 // side - the drift velocity per side (possible for laser and CE)
1770 //
1771 // Notice - Extrapolation outside of calibration range - using constant function
1772 //
817766d5 1773 Double_t result=0;
cc65e4f5 1774 if (mode==2) {
1775 // TPC-TPC mode
1776 result=fDButil->GetTriggerOffsetTPC(run,timeStamp);
1777 result *=fParam->GetZLength();
1778 }
1779 if (mode==1){
1780 // TPC-ITS mode
1781 Double_t dist=0;
86c39d37 1782 result= -fDButil->GetTime0TPCITS(dist, run, timeStamp)*fParam->GetDriftV()/1000000.;
cc65e4f5 1783 }
817766d5 1784 return result;
43a74775 1785
17c90083 1786}
1787
1788
1789
1790
43a74775 1791Double_t AliTPCcalibDB::GetVDriftCorrectionGy(Int_t timeStamp, Int_t run, Int_t side, Int_t /*mode*/){
17c90083 1792 //
1793 // Get global y correction drift velocity correction factor
1794 // additive factor vd = vdnom*(1+GetVDriftCorrectionGy *gy)
1795 // Value etracted combining the vdrift correction using laser tracks and CE
1796 // Arguments:
1797 // mode determines the algorith how to combine the Laser Track, LaserCE
1798 // timestamp - timestamp
1799 // run - run number
1800 // side - the drift velocity gy correction per side (CE and Laser tracks)
1801 //
1802 // Notice - Extrapolation outside of calibration range - using constant function
a8f8b6a1 1803 //
1804 if (run<=0 && fTransform) run = fTransform->GetCurrentRunNumber();
1805 UpdateRunInformations(run,kFALSE);
43a74775 1806 TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
4429bfef 1807 if (!array) return 0;
43a74775 1808 TGraphErrors *laserA= (TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_A");
1809 TGraphErrors *laserC= (TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_C");
1810
1811 Double_t result=0;
1812 if (laserA && laserC){
1813 result= (laserA->Eval(timeStamp)+laserC->Eval(timeStamp))*0.5;
1814 }
1815 if (laserA && side==0){
1816 result = (laserA->Eval(timeStamp));
1817 }
1818 if (laserC &&side==1){
1819 result = (laserC->Eval(timeStamp));
1820 }
1821 return -result/250.; //normalized before
17c90083 1822}
949d8707 1823
f6b5fa33 1824AliTPCCalPad* AliTPCcalibDB::MakeDeadMap(const char* nameMappingFile) {
1825//
1826// Read list of active DDLs from OCDB entry
1827// Generate and return AliTPCCalPad containing 1 for all pads in active DDLs,
1828// 0 for all pads in non-active DDLs.
1829//
1830 char chinfo[1000];
1831
1832 TFile *fileMapping = new TFile(nameMappingFile, "read");
1833 AliTPCmapper *mapping = (AliTPCmapper*) fileMapping->Get("tpcMapping");
1834 if (!mapping) {
1835 sprintf(chinfo,"Failed to get mapping object from %s. ...\n", nameMappingFile);
1836 AliError (chinfo);
1837 return 0;
1838 }
1839
1840 AliTPCCalPad *deadMap = new AliTPCCalPad("deadMap","deadMap");
1841 if (!deadMap) {
1842 AliError("Failed to allocate dead map AliTPCCalPad");
1843 return 0;
1844 }
1845
1846 /// get list of active DDLs from OCDB entry
1847 Int_t idDDL=0;
1848 if (!fALTROConfigData ) {
1849 AliError("No ALTRO config OCDB entry available");
1850 return 0;
1851 }
1852 TMap *activeDDL = (TMap*)fALTROConfigData->FindObject("DDLArray");
1853 TObjString *ddlArray=0;
1854 if (activeDDL) {
1855 ddlArray = (TObjString*)activeDDL->GetValue("DDLArray");
1856 if (!ddlArray) {
1857 AliError("Empty list of active DDLs in OCDB entry");
1858 return 0;
1859 }
1860 } else {
1861 AliError("List of active DDLs not available in OCDB entry");
1862 return 0;
1863 }
1864 TString arrDDL=ddlArray->GetString();
1865 Int_t offset = mapping->GetTpcDdlOffset();
1866 Double_t active;
1867 for (Int_t i=0; i<mapping->GetNumDdl(); i++) {
1868 idDDL= i+offset;
1869 Int_t patch = mapping->GetPatchFromEquipmentID(idDDL);
1870 Int_t roc=mapping->GetRocFromEquipmentID(idDDL);
1871 AliTPCCalROC *calRoc=deadMap->GetCalROC(roc);
1872 if (calRoc) {
1873 for ( Int_t branch = 0; branch < 2; branch++ ) {
1874 for ( Int_t fec = 0; fec < mapping->GetNfec(patch, branch); fec++ ) {
1875 for ( Int_t altro = 0; altro < 8; altro++ ) {
1876 for ( Int_t channel = 0; channel < 16; channel++ ) {
1877 Int_t hwadd = mapping->CodeHWAddress(branch, fec, altro, channel);
1878 Int_t row = mapping->GetPadRow(patch, hwadd); // row in a ROC (IROC or OROC)
1879// Int_t globalrow = mapping.GetGlobalPadRow(patch, hwadd); // row in full sector (IROC plus OROC)
1880 Int_t pad = mapping->GetPad(patch, hwadd);
1881 active=TString(arrDDL[i]).Atof();
1882 calRoc->SetValue(row,pad,active);
1883 } // end channel for loop
1884 } // end altro for loop
1885 } // end fec for loop
1886 } // end branch for loop
1887 } // valid calROC
1888 } // end loop on active DDLs
1889 return deadMap;
1890}
f14d21a1 1891
1892