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