Tail cancelation
[u/mrichter/AliRoot.git] / TPC / Base / 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
829455ad 29// Reconstruction - AliTPCclusterer::Digits2Clusters(AliRawReader* rawReader)
8cd9634d 30//
1ac191a6 31// 1.) pad by pad calibration - AliTPCCalPad
f5344549 32//
1ac191a6 33// a.) fPadGainFactor
34// Simulation: AliTPCDigitizer::ExecFast - Multiply by gain
829455ad 35// Reconstruction : AliTPCclusterer::Digits2Clusters - Divide by gain
f5344549 36//
1ac191a6 37// b.) fPadNoise -
38// Simulation: AliTPCDigitizer::ExecFast
829455ad 39// Reconstruction: AliTPCclusterer::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
829455ad 43// Reconstruction: Used in AliTPCclusterer::Digits2Clusters(AliRawReader* rawReader)
f5344549 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
829455ad 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 -
829455ad 63// AliTPCclusterer::AddCluster
64// AliTPCtracker::Transform
8cd9634d 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
9a836cc2 91#include "TGraphErrors.h"
c5bbaa2c 92#include "AliTPCcalibDB.h"
949d8707 93#include "AliTPCdataQA.h"
817766d5 94#include "AliTPCcalibDButil.h"
d6834f5f 95#include "AliTPCAltroMapping.h"
418bbcaf 96#include "AliTPCExB.h"
c5bbaa2c 97
98#include "AliTPCCalROC.h"
99#include "AliTPCCalPad.h"
54472e4f 100#include "AliTPCSensorTempArray.h"
bf85fe4d 101#include "AliGRPObject.h"
418bbcaf 102#include "AliTPCTransform.h"
f6b5fa33 103#include "AliTPCmapper.h"
d6834f5f 104
418bbcaf 105class AliCDBStorage;
106class AliTPCCalDet;
86df2b3a 107//
108//
109
86df2b3a 110#include "TFile.h"
111#include "TKey.h"
43a74775 112#include "TGraphErrors.h"
86df2b3a 113
114#include "TObjArray.h"
115#include "TObjString.h"
116#include "TString.h"
7390f655 117#include "TDirectory.h"
f6b5fa33 118#include "TArrayI.h"
86df2b3a 119#include "AliTPCCalPad.h"
0fe7645c 120#include "AliTPCCalibPulser.h"
86df2b3a 121#include "AliTPCCalibPedestal.h"
122#include "AliTPCCalibCE.h"
3ac615eb 123#include "AliTPCExBFirst.h"
bf85fe4d 124#include "AliTPCTempMap.h"
da6c0bc9 125#include "AliTPCCalibVdrift.h"
6e7d7dc4 126#include "AliTPCCalibRaw.h"
43a74775 127#include "AliTPCParam.h"
cf5b0aa0 128#include "AliTPCCorrection.h"
3f3549a3 129#include "AliTPCComposedCorrection.h"
5312f439 130#include "AliTPCPreprocessorOnline.h"
661f340b 131#include "AliTimeStamp.h"
132#include "AliTriggerRunScalers.h"
133#include "AliTriggerScalers.h"
134#include "AliTriggerScalersRecord.h"
c5bbaa2c 135
136ClassImp(AliTPCcalibDB)
137
138AliTPCcalibDB* AliTPCcalibDB::fgInstance = 0;
139Bool_t AliTPCcalibDB::fgTerminated = kFALSE;
3ac615eb 140TObjArray AliTPCcalibDB::fgExBArray; // array of ExB corrections
c5bbaa2c 141
142
143//_ singleton implementation __________________________________________________
144AliTPCcalibDB* AliTPCcalibDB::Instance()
145{
146 //
147 // Singleton implementation
8de4c8a6 148 // Returns an instance of this class, it is created if necessary
c5bbaa2c 149 //
150
151 if (fgTerminated != kFALSE)
152 return 0;
153
154 if (fgInstance == 0)
155 fgInstance = new AliTPCcalibDB();
156
157 return fgInstance;
158}
159
160void AliTPCcalibDB::Terminate()
161{
162 //
163 // Singleton implementation
164 // Deletes the instance of this class and sets the terminated flag, instances cannot be requested anymore
165 // This function can be called several times.
166 //
167
168 fgTerminated = kTRUE;
169
170 if (fgInstance != 0)
171 {
172 delete fgInstance;
173 fgInstance = 0;
174 }
175}
176
177//_____________________________________________________________________________
e4dce695 178AliTPCcalibDB::AliTPCcalibDB():
9389f9a4 179 TObject(),
e4dce695 180 fRun(-1),
f5344549 181 fTransform(0),
481f877b 182 fExB(0),
e4dce695 183 fPadGainFactor(0),
8de4c8a6 184 fActiveChannelMap(0),
9f6e9f81 185 fDedxGainFactor(0),
e4dce695 186 fPadTime0(0),
2293155b 187 fDistortionMap(0),
cf5b0aa0 188 fComposedCorrection(0),
0b736a46 189 fComposedCorrectionArray(0),
e4dce695 190 fPadNoise(0),
191 fPedestals(0),
6e7d7dc4 192 fCalibRaw(0),
949d8707 193 fDataQA(0),
5312f439 194 fALTROConfigData(0),
4bef51b7 195 fIonTailArray(0),
5312f439 196 fPulserData(0),
197 fCEData(0),
661f340b 198 fHVsensors(),
199 fGrRunState(0x0),
e4dce695 200 fTemperature(0),
d6834f5f 201 fMapping(0),
96305e49 202 fParam(0),
a2c3785e 203 fClusterParam(0),
0736ecae 204 fRecoParamList(0),
a2c3785e 205 fTimeGainSplines(0),
6b5e0bab 206 fTimeGainSplinesArray(1),
207 fGRPArray(1), //! array of GRPs - per run - JUST for calibration studies
208 fGRPMaps(1), //! array of GRPs - per run - JUST for calibration studies
209 fGoofieArray(1), //! array of GOOFIE values -per run - Just for calibration studies
210 fVoltageArray(1),
211 fTemperatureArray(1), //! array of temperature sensors - per run - Just for calibration studies
212 fVdriftArray(1), //! array of v drift interfaces
213 fDriftCorrectionArray(1), //! array of drift correction
214 fRunList(1), //! run list - indicates try to get the run param
3f3549a3 215 fBHasAlignmentOCDB(kFALSE), // Flag - has the alignment on the composed correction ?
f14d21a1 216 fDButil(0),
88a69e6f 217 fCTPTimeParams(0),
218 fMode(-1)
c5bbaa2c 219{
220 //
221 // constructor
222 //
54472e4f 223 //
534fd34a 224 fgInstance=this;
661f340b 225 for (Int_t i=0;i<72;++i){
226 fChamberHVStatus[i]=kTRUE;
227 fChamberHVmedian[i]=-1;
228 fCurrentNominalVoltage[i]=0.;
229 fChamberHVgoodFraction[i]=0.;
230 }
c5bbaa2c 231 Update(); // temporary
2b4c6ff5 232 fTimeGainSplinesArray.SetOwner(); //own the keys
233 fGRPArray.SetOwner(); //own the keys
234 fGRPMaps.SetOwner(); //own the keys
235 fGoofieArray.SetOwner(); //own the keys
236 fVoltageArray.SetOwner(); //own the keys
237 fTemperatureArray.SetOwner(); //own the keys
238 fVdriftArray.SetOwner(); //own the keys
239 fDriftCorrectionArray.SetOwner(); //own the keys
9a836cc2 240 fIonTailArray->SetOwner(); //own the keys
c5bbaa2c 241}
242
9389f9a4 243AliTPCcalibDB::AliTPCcalibDB(const AliTPCcalibDB& ):
244 TObject(),
245 fRun(-1),
246 fTransform(0),
247 fExB(0),
248 fPadGainFactor(0),
8de4c8a6 249 fActiveChannelMap(0),
9f6e9f81 250 fDedxGainFactor(0),
9389f9a4 251 fPadTime0(0),
2293155b 252 fDistortionMap(0),
cf5b0aa0 253 fComposedCorrection(0),
0b736a46 254 fComposedCorrectionArray(0),
9389f9a4 255 fPadNoise(0),
256 fPedestals(0),
6e7d7dc4 257 fCalibRaw(0),
949d8707 258 fDataQA(0),
5312f439 259 fALTROConfigData(0),
4bef51b7 260 fIonTailArray(0),
5312f439 261 fPulserData(0),
262 fCEData(0),
661f340b 263 fHVsensors(),
264 fGrRunState(0x0),
9389f9a4 265 fTemperature(0),
266 fMapping(0),
9389f9a4 267 fParam(0),
bf85fe4d 268 fClusterParam(0),
0736ecae 269 fRecoParamList(0),
a2c3785e 270 fTimeGainSplines(0),
6b5e0bab 271 fTimeGainSplinesArray(1),
bf85fe4d 272 fGRPArray(0), //! array of GRPs - per run - JUST for calibration studies
0231c65f 273 fGRPMaps(0), //! array of GRPs - per run - JUST for calibration studies
bf85fe4d 274 fGoofieArray(0), //! array of GOOFIE values -per run - Just for calibration studies
e2914767 275 fVoltageArray(0),
bf85fe4d 276 fTemperatureArray(0), //! array of temperature sensors - per run - Just for calibration studies
da6c0bc9 277 fVdriftArray(0), //! array of v drift interfaces
5647625c 278 fDriftCorrectionArray(0), //! array of v drift corrections
1e722a63 279 fRunList(0), //! run list - indicates try to get the run param
3f3549a3 280 fBHasAlignmentOCDB(kFALSE), // Flag - has the alignment on the composed correction ?
f14d21a1 281 fDButil(0),
88a69e6f 282 fCTPTimeParams(0),
283 fMode(-1)
9389f9a4 284{
285 //
286 // Copy constructor invalid -- singleton implementation
287 //
661f340b 288 Error("copy constructor","invalid -- singleton implementation");
289 for (Int_t i=0;i<72;++i){
290 fChamberHVStatus[i]=kTRUE;
291 fChamberHVmedian[i]=-1;
292 fCurrentNominalVoltage[i]=0.;
293 fChamberHVgoodFraction[i]=0.;
294 }
2b4c6ff5 295 fTimeGainSplinesArray.SetOwner(); //own the keys
296 fGRPArray.SetOwner(); //own the keys
297 fGRPMaps.SetOwner(); //own the keys
298 fGoofieArray.SetOwner(); //own the keys
299 fVoltageArray.SetOwner(); //own the keys
300 fTemperatureArray.SetOwner(); //own the keys
301 fVdriftArray.SetOwner(); //own the keys
302 fDriftCorrectionArray.SetOwner(); //own the keys
9a836cc2 303 fIonTailArray->SetOwner(); //own the keys
9389f9a4 304}
305
306AliTPCcalibDB& AliTPCcalibDB::operator= (const AliTPCcalibDB& )
307{
308//
309// Singleton implementation - no assignment operator
310//
311 Error("operator =", "assignment operator not implemented");
312 return *this;
313}
314
315
316
c5bbaa2c 317//_____________________________________________________________________________
318AliTPCcalibDB::~AliTPCcalibDB()
319{
320 //
321 // destructor
322 //
9a836cc2 323 delete fIonTailArray;
8de4c8a6 324 delete fActiveChannelMap;
661f340b 325 delete fGrRunState;
c5bbaa2c 326}
8b63d99c 327AliTPCCalPad* AliTPCcalibDB::GetDistortionMap(Int_t i) const {
328 //
329 // get distortion map - due E field distortions
330 //
331 return (fDistortionMap) ? (AliTPCCalPad*)fDistortionMap->At(i):0;
332}
c5bbaa2c 333
0736ecae 334AliTPCRecoParam* AliTPCcalibDB::GetRecoParam(Int_t i) const {
335 return (fRecoParamList) ? (AliTPCRecoParam*)fRecoParamList->At(i):0;
336}
337
c5bbaa2c 338//_____________________________________________________________________________
339AliCDBEntry* AliTPCcalibDB::GetCDBEntry(const char* cdbPath)
340{
341 //
342 // Retrieves an entry with path <cdbPath> from the CDB.
343 //
344 char chinfo[1000];
345
68751c2c 346 AliCDBEntry* entry = AliCDBManager::Instance()->Get(cdbPath, fRun);
c5bbaa2c 347 if (!entry)
348 {
4aa37f93 349 snprintf(chinfo,1000,"AliTPCcalibDB: Failed to get entry:\t%s ", cdbPath);
c5bbaa2c 350 AliError(chinfo);
351 return 0;
352 }
353 return entry;
354}
355
356
357//_____________________________________________________________________________
358void AliTPCcalibDB::SetRun(Long64_t run)
359{
360 //
361 // Sets current run number. Calibration data is read from the corresponding file.
362 //
363 if (fRun == run)
364 return;
a2c3785e 365 fRun = run;
c5bbaa2c 366 Update();
367}
368
369
370
371void AliTPCcalibDB::Update(){
92fb7d95 372 //
373 // cache the OCDB entries for simulation, reconstruction, calibration
374 //
375 //
a8f8b6a1 376 AliCDBEntry * entry=0;
68751c2c 377 Bool_t cdbCache = AliCDBManager::Instance()->GetCacheFlag(); // save cache status
378 AliCDBManager::Instance()->SetCacheFlag(kTRUE); // activate CDB cache
1e722a63 379 fDButil = new AliTPCcalibDButil;
c5bbaa2c 380 //
8e6dc09b 381 fRun = AliCDBManager::Instance()->GetRun();
5647625c 382
c5bbaa2c 383 entry = GetCDBEntry("TPC/Calib/PadGainFactor");
384 if (entry){
68751c2c 385 //if (fPadGainFactor) delete fPadGainFactor;
c5bbaa2c 386 entry->SetOwner(kTRUE);
387 fPadGainFactor = (AliTPCCalPad*)entry->GetObject();
2293155b 388 }else{
13242232 389 AliFatal("TPC - Missing calibration entry TPC/Calib/PadGainFactor");
c5bbaa2c 390 }
391 //
3af3fbc4 392 entry = GetCDBEntry("TPC/Calib/TimeGain");
393 if (entry){
394 //if (fTimeGainSplines) delete fTimeGainSplines;
395 entry->SetOwner(kTRUE);
396 fTimeGainSplines = (TObjArray*)entry->GetObject();
2293155b 397 }else{
13242232 398 AliFatal("TPC - Missing calibration entry TPC/Calib/Timegain");
3af3fbc4 399 }
400 //
9f6e9f81 401 entry = GetCDBEntry("TPC/Calib/GainFactorDedx");
402 if (entry){
403 entry->SetOwner(kTRUE);
404 fDedxGainFactor = (AliTPCCalPad*)entry->GetObject();
2293155b 405 }else{
13242232 406 AliFatal("TPC - Missing calibration entry TPC/Calib/gainFactordEdx");
9f6e9f81 407 }
408 //
c5bbaa2c 409 entry = GetCDBEntry("TPC/Calib/PadTime0");
410 if (entry){
68751c2c 411 //if (fPadTime0) delete fPadTime0;
c5bbaa2c 412 entry->SetOwner(kTRUE);
413 fPadTime0 = (AliTPCCalPad*)entry->GetObject();
2293155b 414 }else{
13242232 415 AliFatal("TPC - Missing calibration entry");
c5bbaa2c 416 }
2293155b 417
8b63d99c 418 entry = GetCDBEntry("TPC/Calib/Distortion");
2293155b 419 if (entry){
420 //if (fPadTime0) delete fPadTime0;
421 entry->SetOwner(kTRUE);
8b63d99c 422 fDistortionMap =dynamic_cast<TObjArray*>(entry->GetObject());
2293155b 423 }else{
424 //AliFatal("TPC - Missing calibration entry")
425 }
426
427
c5bbaa2c 428 //
c5bbaa2c 429 //
430 entry = GetCDBEntry("TPC/Calib/PadNoise");
431 if (entry){
68751c2c 432 //if (fPadNoise) delete fPadNoise;
c5bbaa2c 433 entry->SetOwner(kTRUE);
434 fPadNoise = (AliTPCCalPad*)entry->GetObject();
2293155b 435 }else{
13242232 436 AliFatal("TPC - Missing calibration entry");
c5bbaa2c 437 }
8477f500 438
439 entry = GetCDBEntry("TPC/Calib/Pedestals");
440 if (entry){
441 //if (fPedestals) delete fPedestals;
442 entry->SetOwner(kTRUE);
443 fPedestals = (AliTPCCalPad*)entry->GetObject();
444 }
445
54472e4f 446 entry = GetCDBEntry("TPC/Calib/Temperature");
447 if (entry){
448 //if (fTemperature) delete fTemperature;
449 entry->SetOwner(kTRUE);
450 fTemperature = (AliTPCSensorTempArray*)entry->GetObject();
451 }
452
8477f500 453 entry = GetCDBEntry("TPC/Calib/Parameters");
454 if (entry){
54472e4f 455 //if (fPadNoise) delete fPadNoise;
8477f500 456 entry->SetOwner(kTRUE);
2baa7fb5 457 fParam = (AliTPCParam*)(entry->GetObject());
2293155b 458 }else{
13242232 459 AliFatal("TPC - Missing calibration entry TPC/Calib/Parameters");
8477f500 460 }
461
96305e49 462 entry = GetCDBEntry("TPC/Calib/ClusterParam");
463 if (entry){
96305e49 464 entry->SetOwner(kTRUE);
2baa7fb5 465 fClusterParam = (AliTPCClusterParam*)(entry->GetObject());
2293155b 466 }else{
13242232 467 AliFatal("TPC - Missing calibration entry");
96305e49 468 }
469
0736ecae 470 entry = GetCDBEntry("TPC/Calib/RecoParam");
471 if (entry){
c8558d35 472 //PH entry->SetOwner(kTRUE);
0736ecae 473 fRecoParamList = dynamic_cast<TObjArray*>(entry->GetObject());
474
475 }else{
476 AliFatal("TPC - Missing calibration entry TPC/Calib/RecoParam");
477 }
478
479
5312f439 480 //ALTRO configuration data
481 entry = GetCDBEntry("TPC/Calib/AltroConfig");
482 if (entry){
483 entry->SetOwner(kTRUE);
484 fALTROConfigData=(TObjArray*)(entry->GetObject());
2293155b 485 }else{
13242232 486 AliFatal("TPC - Missing calibration entry");
5312f439 487 }
488
489 //Calibration Pulser data
490 entry = GetCDBEntry("TPC/Calib/Pulser");
491 if (entry){
492 entry->SetOwner(kTRUE);
493 fPulserData=(TObjArray*)(entry->GetObject());
494 }
495
9a836cc2 496 //Calibration ION tail data
832977ba 497 entry = GetCDBEntry("TPC/Calib/IonTail");
498 if (entry){
499 delete fIonTailArray; fIonTailArray=NULL;
500 entry->SetOwner(kTRUE);
501 fIonTailArray=(TObjArray*)(entry->GetObject());
502 }
503
5312f439 504 //CE data
505 entry = GetCDBEntry("TPC/Calib/CE");
506 if (entry){
507 entry->SetOwner(kTRUE);
508 fCEData=(TObjArray*)(entry->GetObject());
509 }
6e7d7dc4 510 //RAW calibration data
56ce896d 511 // entry = GetCDBEntry("TPC/Calib/Raw");
8de4c8a6 512
d6834f5f 513 entry = GetCDBEntry("TPC/Calib/Mapping");
514 if (entry){
515 //if (fPadNoise) delete fPadNoise;
516 entry->SetOwner(kTRUE);
517 TObjArray * array = dynamic_cast<TObjArray*>(entry->GetObject());
518 if (array && array->GetEntriesFast()==6){
519 fMapping = new AliTPCAltroMapping*[6];
520 for (Int_t i=0; i<6; i++){
5312f439 521 fMapping[i] = dynamic_cast<AliTPCAltroMapping*>(array->At(i));
d6834f5f 522 }
523 }
524 }
525
2293155b 526 //CTP calibration data
f14d21a1 527 entry = GetCDBEntry("GRP/CTP/CTPtiming");
528 if (entry){
4a880881 529 //entry->SetOwner(kTRUE);
f14d21a1 530 fCTPTimeParams=dynamic_cast<AliCTPTimeParams*>(entry->GetObject());
2293155b 531 }else{
13242232 532 AliError("TPC - Missing calibration entry");
2293155b 533 }
be67055b 534 //TPC space point correction data
535 entry = GetCDBEntry("TPC/Calib/Correction");
536 if (entry){
537 //entry->SetOwner(kTRUE);
538 fComposedCorrection=dynamic_cast<AliTPCCorrection*>(entry->GetObject());
0b736a46 539 if (fComposedCorrection) fComposedCorrection->Init();
540 fComposedCorrectionArray=dynamic_cast<TObjArray*>(entry->GetObject());
541 if (fComposedCorrectionArray){
542 for (Int_t i=0; i<fComposedCorrectionArray->GetEntries(); i++){
3f3549a3 543 AliTPCComposedCorrection* composedCorrection= dynamic_cast<AliTPCComposedCorrection*>(fComposedCorrectionArray->At(i));
544 if (composedCorrection) {
545 composedCorrection->Init();
546 if (composedCorrection->GetCorrections()){
547 if (composedCorrection->GetCorrections()->FindObject("FitAlignTPC")){
548 fBHasAlignmentOCDB=kTRUE;
549 }
550 }
551 }
0b736a46 552 }
3f3549a3 553 }
be67055b 554 }else{
13242232 555 AliError("TPC - Missing calibration entry- TPC/Calib/Correction");
88a69e6f 556 }
557 //RCU trigger config mode
558 fMode=GetRCUTriggerConfig();
3ac615eb 559 //
f5344549 560 if (!fTransform) {
561 fTransform=new AliTPCTransform();
bfec3eeb 562 fTransform->SetCurrentRun(AliCDBManager::Instance()->GetRun());
f5344549 563 }
8477f500 564
661f340b 565 // Chamber HV data
566 // needs to be called before InitDeadMap
567 UpdateChamberHighVoltageData();
568
ba63ff39 569 // Create Dead Channel Map
570 InitDeadMap();
571
c5bbaa2c 572 //
68751c2c 573 AliCDBManager::Instance()->SetCacheFlag(cdbCache); // reset original CDB cache
c5bbaa2c 574}
e4dce695 575
56ce896d 576void AliTPCcalibDB::UpdateNonRec(){
577 //
578 // Update/Load the parameters which are important for QA studies
579 // and not used yet for the reconstruction
580 //
581 //RAW calibration data
582 AliCDBEntry * entry=0;
583 entry = GetCDBEntry("TPC/Calib/Raw");
584 if (entry){
585 entry->SetOwner(kTRUE);
41a5d739 586 TObjArray *arr=dynamic_cast<TObjArray*>(entry->GetObject());
56ce896d 587 if (arr) fCalibRaw=(AliTPCCalibRaw*)arr->At(0);
41a5d739 588 else fCalibRaw = (AliTPCCalibRaw*)(entry->GetObject());
56ce896d 589 }
590 //QA calibration data
591 entry = GetCDBEntry("TPC/Calib/QA");
592 if (entry){
593 entry->SetOwner(kTRUE);
594 fDataQA=dynamic_cast<AliTPCdataQA*>(entry->GetObject());
595 }
2293155b 596 // High voltage
2b4c6ff5 597 if (fRun>=0 && !fVoltageArray.GetValue(Form("%i",fRun))){
14301155 598 entry = AliCDBManager::Instance()->Get("TPC/Calib/HighVoltage",fRun);
599 if (entry) {
2b4c6ff5 600 fVoltageArray.Add(new TObjString(Form("%i",fRun)),entry->GetObject());
14301155 601 }
2293155b 602 }
603
56ce896d 604}
605
9a836cc2 606void AliTPCcalibDB::GetTailcancelationGraphs(Int_t sector, TGraphErrors ** graphRes, Float_t * indexAmpGraphs){
607
608//
609// Read OCDB entry object of Iontail (TObjArray of TGraphErrors of TRFs)
610// Naming of the TRF objects is: "gr_<chamber_type>_<voltage>_<laser_track_angle>_<distance_to_COG>" --> "gr_iroc_1240_1_1"
611//
612
613 Int_t run = fTransform->GetCurrentRunNumber();
614 SetRun(run);
615 Float_t rocVoltage = AliTPCcalibDB::GetChamberHighVoltage(run,sector, -1); // Get the voltage from OCDB with a getter (old function)
616// Float_t rocVoltage=GetChamberHighVoltageMedian(sector); // Get the voltage from OCDB, new function from Jens
617
618 Int_t nominalVoltage = (sector<36) ? 1240 : 1470 ; // nominal voltage of 2012 when the TRF functions were produced
619 Int_t tempVoltage = 0;
620 Int_t trackAngle = 4; // (1=first, 2=second, 3=third, 4=first+second, 5=all tracks) note: 3rd is distorted by low freq
621 TString rocType = (sector<36) ? "iroc" : "oroc";
622 const Int_t ngraph=fIonTailArray->GetLast();
623
624 // create array of voltages in order to select the proper TRF with closest voltage
625 Int_t voltages[ngraph]; // array of voltages
626 for (Int_t i=0; i<ngraph; i++){
627 voltages[i]=0;
628 }
629
630 // loop over response functions in the TObjarray
631 Int_t nvoltages=0;
632 for (Int_t i=0;i<=ngraph;i++){
633
634 // read the TRF object name in order to select proper TRF for the given sector
635 TString objname(fIonTailArray->At(i)->GetName());
636 TObjArray *objArr = objname.Tokenize("_");
637
638 // select the roc type (IROC or OROC) and the trackAngle
639 if (!objname.Contains(rocType)) {delete objArr; continue;}
640 if ((atoi(static_cast<TObjString*>(objArr->At(3))->GetName())!=trackAngle) ) {delete objArr; continue;}
641
642 // Create the voltage array for proper voltage value selection
643 voltages[nvoltages]=atoi(static_cast<TObjString*>(objArr->At(2))->GetName());
644 nvoltages++;
645 delete objArr;
646 }
647
648 // find closest voltage value to ROC voltage (among the TRF' voltage array --> to select proper t.r.f.)
649 Int_t ampIndex = 0;
650 Int_t diffVoltage = TMath::Abs(rocVoltage - voltages[0]);
651 for (Int_t k=0;k<ngraph;k++) {
652 if (diffVoltage > TMath::Abs(rocVoltage-voltages[k]) && voltages[k]!=0)
653 {
654 diffVoltage = TMath::Abs(rocVoltage-voltages[k]);
655 ampIndex = k;
656 }
657 }
658 tempVoltage = voltages[ampIndex]; // use closest voltage to current voltage
659 //tempVoltage = *std::max_element(voltages, voltages + nvoltages); // use maximum voltage and apply voltage scaling
660 if (run<140000) tempVoltage = nominalVoltage; // for 2010 data
661 std::cout << " run = "<< run << " sector = " << sector << " voltage = " << rocVoltage << " tempVolt = " << tempVoltage << std::endl;
662
663 // assign TGraphErrors
664 Int_t igraph=0;
665 for (Int_t i=0; i<=ngraph; i++){
666
667 // read TRFs for TObjArray and select the roc type (IROC or OROC) and the trackAngle
668 TGraphErrors * trfObj = static_cast<TGraphErrors*>(fIonTailArray->At(i));
669 TString objname(trfObj->GetName());
670 TObjArray *objArr1 = objname.Tokenize("_");
671
672 // TRF eleminations
673 if (!objname.Contains(rocType)) {delete objArr1; continue;} // choose roc type
674 if ((atoi(static_cast<TObjString*>(objArr1->At(3))->GetName())!=trackAngle) ) {delete objArr1; continue;} // choose angle
675 if ((atoi(static_cast<TObjString*>(objArr1->At(2))->GetName())!=tempVoltage) ) {delete objArr1; continue;} // choose voltage
676
677 // Apply Voltage scaling
678 Int_t objVoltage = atoi(static_cast<TObjString*>(objArr1->At(2))->GetName());
679 Double_t voltageScaled = Double_t(objVoltage)/Double_t(rocVoltage);
680 const Int_t N = TMath::Nint(voltageScaled*trfObj->GetN())-1;
681 Double_t x[1000] = {0};
682 Double_t y[1000] = {0};
683 Double_t errx[1000] = {0};
684 Double_t erry[1000] = {0};
685 Int_t k =0;
686 for (Int_t j=0; j<N; j++){
687 k = TMath::Nint(j*(voltageScaled));
688 x[j]=k;
689 if(j<trfObj->GetN()) {
690 y[j]=(1./voltageScaled)*trfObj->GetY()[j];
691 } else {
692 k++;
693 y[j]=0;
694 }
695 }
86df2b3a 696
9a836cc2 697 // fill arrays for proper position and amplitude selections
698 indexAmpGraphs[igraph] = (static_cast<TObjString*>(objArr1->At(4))->GetString().Atof())/10.;
699 delete graphRes[igraph];
700 graphRes[igraph] = new TGraphErrors(1000,x,y,errx,erry);
701 // smooth voltage scaled graph
702 for (Int_t m=1; m<N;m++){
703 if (graphRes[igraph]->GetY()[m]==0) graphRes[igraph]->GetY()[m] = graphRes[igraph]->GetY()[m-1];
704 }
705 igraph++;
706
707 delete objArr1;
708 }
709}
86df2b3a 710
711void AliTPCcalibDB::CreateObjectList(const Char_t *filename, TObjArray *calibObjects)
712{
418bbcaf 713//
714// Create calibration objects and read contents from OCDB
715//
86df2b3a 716 if ( calibObjects == 0x0 ) return;
717 ifstream in;
718 in.open(filename);
719 if ( !in.is_open() ){
720 fprintf(stderr,"Error: cannot open list file '%s'", filename);
721 return;
722 }
723
724 AliTPCCalPad *calPad=0x0;
725
726 TString sFile;
727 sFile.ReadFile(in);
728 in.close();
729
730 TObjArray *arrFileLine = sFile.Tokenize("\n");
731
732 TIter nextLine(arrFileLine);
733
734 TObjString *sObjLine=0x0;
2c632057 735 while ( (sObjLine = (TObjString*)nextLine()) ){
86df2b3a 736 TString sLine(sObjLine->GetString());
737
738 TObjArray *arrNextCol = sLine.Tokenize("\t");
739
740 TObjString *sObjType = (TObjString*)(arrNextCol->At(0));
741 TObjString *sObjFileName = (TObjString*)(arrNextCol->At(1));
09d5920f 742 delete arrNextCol;
743
86df2b3a 744 if ( !sObjType || ! sObjFileName ) continue;
745 TString sType(sObjType->GetString());
746 TString sFileName(sObjFileName->GetString());
661f340b 747// printf("%s\t%s\n",sType.Data(),sFileName.Data());
86df2b3a 748
749 TFile *fIn = TFile::Open(sFileName);
750 if ( !fIn ){
751 fprintf(stderr,"File not found: '%s'", sFileName.Data());
752 continue;
753 }
754
755 if ( sType == "CE" ){
756 AliTPCCalibCE *ce = (AliTPCCalibCE*)fIn->Get("AliTPCCalibCE");
757
758 calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadT0());
759 calPad->SetNameTitle("CETmean","CETmean");
760 calibObjects->Add(calPad);
761
762 calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadQ());
763 calPad->SetNameTitle("CEQmean","CEQmean");
764 calibObjects->Add(calPad);
765
766 calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadRMS());
767 calPad->SetNameTitle("CETrms","CETrms");
768 calibObjects->Add(calPad);
769
770 } else if ( sType == "Pulser") {
0fe7645c 771 AliTPCCalibPulser *sig = (AliTPCCalibPulser*)fIn->Get("AliTPCCalibPulser");
86df2b3a 772
773 calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadT0());
774 calPad->SetNameTitle("PulserTmean","PulserTmean");
775 calibObjects->Add(calPad);
776
777 calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadQ());
778 calPad->SetNameTitle("PulserQmean","PulserQmean");
779 calibObjects->Add(calPad);
780
781 calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadRMS());
782 calPad->SetNameTitle("PulserTrms","PulserTrms");
783 calibObjects->Add(calPad);
784
785 } else if ( sType == "Pedestals") {
786 AliTPCCalibPedestal *ped = (AliTPCCalibPedestal*)fIn->Get("AliTPCCalibPedestal");
787
788 calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadPedestal());
789 calPad->SetNameTitle("Pedestals","Pedestals");
790 calibObjects->Add(calPad);
791
792 calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadRMS());
793 calPad->SetNameTitle("Noise","Noise");
794 calibObjects->Add(calPad);
795
796 } else {
797 fprintf(stderr,"Undefined Type: '%s'",sType.Data());
798
799 }
800 delete fIn;
801 }
09d5920f 802 delete arrFileLine;
86df2b3a 803}
804
ba63ff39 805Int_t AliTPCcalibDB::InitDeadMap() {
806 // Initialize DeadChannel Map
807 // Source of information:
661f340b 808 // - HV (see UpdateChamberHighVoltageData())
ba63ff39 809 // - Altro disabled channels. Noisy channels.
810 // - DDL list
86df2b3a 811
8de4c8a6 812 // check necessary information
661f340b 813 const Int_t run=GetRun();
8de4c8a6 814 if (run<0){
815 AliError("run not set in CDB manager. Cannot create active channel map");
816 return 0;
817 }
661f340b 818 AliDCSSensorArray* voltageArray = GetVoltageSensors(run);
8de4c8a6 819 AliTPCCalPad* altroMap = GetALTROMasked();
820 TMap* mapddl = GetDDLMap();
821
822 if (!voltageArray && !altroMap && !mapddl) {
823 AliError("All necessary information to create the activate channel are map missing.");
824 return 0;
825 }
826
8de4c8a6 827 //=============================================================
828 // Setup DDL map
829
830 Bool_t ddlMap[216]={0};
831 for (Int_t iddl=0; iddl<216; ++iddl) ddlMap[iddl]=1;
832 if (mapddl){
833 TObjString *s = (TObjString*)mapddl->GetValue("DDLArray");
834 if (s){
835 for (Int_t iddl=0; iddl<216; ++iddl) ddlMap[iddl]=TString(s->GetString()(iddl))!="0";
836 }
837 } else {
838 AliError("DDL map missing. ActiveChannelMap can only be created with parts of the information.");
839 }
840 // Setup DDL map done
841 // ============================================================
842
843 //=============================================================
844 // Setup active chnnel map
845 //
846
661f340b 847 if (!fActiveChannelMap) fActiveChannelMap=new AliTPCCalPad("ActiveChannelMap","ActiveChannelMap");
848
8de4c8a6 849 AliTPCmapper map(gSystem->ExpandPathName("$ALICE_ROOT/TPC/mapping/"));
850
851 if (!altroMap) AliError("ALTRO dead channel map missing. ActiveChannelMap can only be created with parts of the information.");
852
853 for (Int_t iROC=0;iROC<AliTPCCalPad::kNsec;++iROC){
854 AliTPCCalROC *roc=fActiveChannelMap->GetCalROC(iROC);
855 if (!roc){
856 AliError(Form("No ROC %d in active channel map",iROC));
857 continue;
858 }
859
860 // check for bad voltage
661f340b 861 // see UpdateChamberHighVoltageData()
862 if (!fChamberHVStatus[iROC]){
8de4c8a6 863 roc->Multiply(0.);
864 continue;
865 }
866
867 AliTPCCalROC *masked=0x0;
868 if (altroMap) masked=altroMap->GetCalROC(iROC);
869
870 for (UInt_t irow=0; irow<roc->GetNrows(); ++irow){
871 for (UInt_t ipad=0; ipad<roc->GetNPads(irow); ++ipad){
872 //per default the channel is on
873 roc->SetValue(irow,ipad,1);
874 // apply altro dead channel mask (inverse logik, it is not active, but inactive channles)
875 if (masked && masked->GetValue(irow, ipad)) roc->SetValue(irow, ipad ,0);
876 // mask channels if a DDL is inactive
877 Int_t ddlId=map.GetEquipmentID(iROC, irow, ipad)-768;
878 if (ddlId>=0 && !ddlMap[ddlId]) roc->SetValue(irow, ipad ,0);
879 }
880 }
881 }
882
883 return 1;
ba63ff39 884}
86df2b3a 885
886void AliTPCcalibDB::MakeTree(const char * fileName, TObjArray * array, const char * mapFileName, AliTPCCalPad* outlierPad, Float_t ltmFraction) {
887 //
888 // Write a tree with all available information
418bbcaf 889 // if mapFileName is specified, the Map information are also written to the tree
86df2b3a 890 // pads specified in outlierPad are not used for calculating statistics
891 // - the same function as AliTPCCalPad::MakeTree -
892 //
893 AliTPCROC* tpcROCinstance = AliTPCROC::Instance();
894
895 TObjArray* mapIROCs = 0;
896 TObjArray* mapOROCs = 0;
897 TVectorF *mapIROCArray = 0;
898 TVectorF *mapOROCArray = 0;
899 Int_t mapEntries = 0;
900 TString* mapNames = 0;
901
902 if (mapFileName) {
903 TFile mapFile(mapFileName, "read");
904
905 TList* listOfROCs = mapFile.GetListOfKeys();
906 mapEntries = listOfROCs->GetEntries()/2;
907 mapIROCs = new TObjArray(mapEntries*2);
908 mapOROCs = new TObjArray(mapEntries*2);
909 mapIROCArray = new TVectorF[mapEntries];
910 mapOROCArray = new TVectorF[mapEntries];
911
912 mapNames = new TString[mapEntries];
913 for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
418bbcaf 914 TString nameROC(((TKey*)(listOfROCs->At(ivalue*2)))->GetName());
915 nameROC.Remove(nameROC.Length()-4, 4);
916 mapIROCs->AddAt((AliTPCCalROC*)mapFile.Get((nameROC + "IROC").Data()), ivalue);
917 mapOROCs->AddAt((AliTPCCalROC*)mapFile.Get((nameROC + "OROC").Data()), ivalue);
918 mapNames[ivalue].Append(nameROC);
86df2b3a 919 }
920
921 for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
922 mapIROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(0));
923 mapOROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(36));
924
925 for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(0); ichannel++)
926 (mapIROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapIROCs->At(ivalue)))->GetValue(ichannel);
927 for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(36); ichannel++)
928 (mapOROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapOROCs->At(ivalue)))->GetValue(ichannel);
929 }
930
931 } // if (mapFileName)
932
933 TTreeSRedirector cstream(fileName);
934 Int_t arrayEntries = array->GetEntries();
935
936 TString* names = new TString[arrayEntries];
937 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
938 names[ivalue].Append(((AliTPCCalPad*)array->At(ivalue))->GetName());
939
940 for (UInt_t isector = 0; isector < tpcROCinstance->GetNSectors(); isector++) {
941 //
942 // get statistic for given sector
943 //
944 TVectorF median(arrayEntries);
945 TVectorF mean(arrayEntries);
946 TVectorF rms(arrayEntries);
947 TVectorF ltm(arrayEntries);
948 TVectorF ltmrms(arrayEntries);
949 TVectorF medianWithOut(arrayEntries);
950 TVectorF meanWithOut(arrayEntries);
951 TVectorF rmsWithOut(arrayEntries);
952 TVectorF ltmWithOut(arrayEntries);
953 TVectorF ltmrmsWithOut(arrayEntries);
954
955 TVectorF *vectorArray = new TVectorF[arrayEntries];
956 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
957 vectorArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
958
959 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
960 AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
961 AliTPCCalROC* calROC = calPad->GetCalROC(isector);
962 AliTPCCalROC* outlierROC = 0;
963 if (outlierPad) outlierROC = outlierPad->GetCalROC(isector);
964 if (calROC) {
965 median[ivalue] = calROC->GetMedian();
966 mean[ivalue] = calROC->GetMean();
967 rms[ivalue] = calROC->GetRMS();
968 Double_t ltmrmsValue = 0;
969 ltm[ivalue] = calROC->GetLTM(&ltmrmsValue, ltmFraction);
970 ltmrms[ivalue] = ltmrmsValue;
971 if (outlierROC) {
972 medianWithOut[ivalue] = calROC->GetMedian(outlierROC);
973 meanWithOut[ivalue] = calROC->GetMean(outlierROC);
974 rmsWithOut[ivalue] = calROC->GetRMS(outlierROC);
975 ltmrmsValue = 0;
976 ltmWithOut[ivalue] = calROC->GetLTM(&ltmrmsValue, ltmFraction, outlierROC);
977 ltmrmsWithOut[ivalue] = ltmrmsValue;
978 }
979 }
980 else {
981 median[ivalue] = 0.;
982 mean[ivalue] = 0.;
983 rms[ivalue] = 0.;
984 ltm[ivalue] = 0.;
985 ltmrms[ivalue] = 0.;
986 medianWithOut[ivalue] = 0.;
987 meanWithOut[ivalue] = 0.;
988 rmsWithOut[ivalue] = 0.;
989 ltmWithOut[ivalue] = 0.;
990 ltmrmsWithOut[ivalue] = 0.;
991 }
992 }
993
994 //
995 // fill vectors of variable per pad
996 //
997 TVectorF *posArray = new TVectorF[8];
998 for (Int_t ivalue = 0; ivalue < 8; ivalue++)
999 posArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
1000
1001 Float_t posG[3] = {0};
1002 Float_t posL[3] = {0};
1003 Int_t ichannel = 0;
1004 for (UInt_t irow = 0; irow < tpcROCinstance->GetNRows(isector); irow++) {
1005 for (UInt_t ipad = 0; ipad < tpcROCinstance->GetNPads(isector, irow); ipad++) {
1006 tpcROCinstance->GetPositionLocal(isector, irow, ipad, posL);
1007 tpcROCinstance->GetPositionGlobal(isector, irow, ipad, posG);
1008 posArray[0][ichannel] = irow;
1009 posArray[1][ichannel] = ipad;
1010 posArray[2][ichannel] = posL[0];
1011 posArray[3][ichannel] = posL[1];
1012 posArray[4][ichannel] = posG[0];
1013 posArray[5][ichannel] = posG[1];
1014 posArray[6][ichannel] = (Int_t)(ipad - (Double_t)(tpcROCinstance->GetNPads(isector, irow))/2);
1015 posArray[7][ichannel] = ichannel;
1016
1017 // loop over array containing AliTPCCalPads
1018 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
1019 AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
1020 AliTPCCalROC* calROC = calPad->GetCalROC(isector);
1021 if (calROC)
1022 (vectorArray[ivalue])[ichannel] = calROC->GetValue(irow, ipad);
1023 else
1024 (vectorArray[ivalue])[ichannel] = 0;
1025 }
1026 ichannel++;
1027 }
1028 }
1029
1030 cstream << "calPads" <<
1031 "sector=" << isector;
1032
1033 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
1034 cstream << "calPads" <<
1035 (Char_t*)((names[ivalue] + "_Median=").Data()) << median[ivalue] <<
1036 (Char_t*)((names[ivalue] + "_Mean=").Data()) << mean[ivalue] <<
1037 (Char_t*)((names[ivalue] + "_RMS=").Data()) << rms[ivalue] <<
1038 (Char_t*)((names[ivalue] + "_LTM=").Data()) << ltm[ivalue] <<
1039 (Char_t*)((names[ivalue] + "_RMS_LTM=").Data()) << ltmrms[ivalue];
1040 if (outlierPad) {
1041 cstream << "calPads" <<
1042 (Char_t*)((names[ivalue] + "_Median_OutlierCutted=").Data()) << medianWithOut[ivalue] <<
1043 (Char_t*)((names[ivalue] + "_Mean_OutlierCutted=").Data()) << meanWithOut[ivalue] <<
1044 (Char_t*)((names[ivalue] + "_RMS_OutlierCutted=").Data()) << rmsWithOut[ivalue] <<
1045 (Char_t*)((names[ivalue] + "_LTM_OutlierCutted=").Data()) << ltmWithOut[ivalue] <<
1046 (Char_t*)((names[ivalue] + "_RMS_LTM_OutlierCutted=").Data()) << ltmrmsWithOut[ivalue];
1047 }
1048 }
1049
1050 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
1051 cstream << "calPads" <<
1052 (Char_t*)((names[ivalue] + ".=").Data()) << &vectorArray[ivalue];
1053 }
1054
1055 if (mapFileName) {
1056 for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
1057 if (isector < 36)
1058 cstream << "calPads" <<
1059 (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapIROCArray[ivalue];
1060 else
1061 cstream << "calPads" <<
1062 (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapOROCArray[ivalue];
1063 }
1064 }
1065
1066 cstream << "calPads" <<
1067 "row.=" << &posArray[0] <<
1068 "pad.=" << &posArray[1] <<
1069 "lx.=" << &posArray[2] <<
1070 "ly.=" << &posArray[3] <<
1071 "gx.=" << &posArray[4] <<
1072 "gy.=" << &posArray[5] <<
1073 "rpad.=" << &posArray[6] <<
1074 "channel.=" << &posArray[7];
1075
1076 cstream << "calPads" <<
1077 "\n";
1078
1079 delete[] posArray;
1080 delete[] vectorArray;
1081 }
1082
1083
1084 delete[] names;
1085 if (mapFileName) {
1086 delete mapIROCs;
1087 delete mapOROCs;
1088 delete[] mapIROCArray;
1089 delete[] mapOROCArray;
1090 delete[] mapNames;
1091 }
1092}
3ac615eb 1093
f14d21a1 1094Int_t AliTPCcalibDB::GetRCUTriggerConfig() const
1095{
1096 //
1097 // return the RCU trigger configuration register
1098 //
1099 TMap *map=GetRCUconfig();
1100 if (!map) return -1;
1101 TVectorF *v=(TVectorF*)map->GetValue("TRGCONF_TRG_MODE");
1102 Float_t mode=-1;
1103 for (Int_t i=0; i<v->GetNrows(); ++i){
1104 Float_t newmode=v->GetMatrixArray()[i];
1105 if (newmode>-1){
1106 if (mode>-1&&newmode!=mode) AliWarning("Found different RCU trigger configurations!!!");
1107 mode=newmode;
1108 }
1109 }
1110 return (Int_t)mode;
1111}
1112
1113Bool_t AliTPCcalibDB::IsTrgL0()
1114{
1115 //
1116 // return if the FEE readout was triggered on L0
1117 //
88a69e6f 1118 if (fMode<0) return kFALSE;
1119 return (fMode==1);
f14d21a1 1120}
3ac615eb 1121
f14d21a1 1122Bool_t AliTPCcalibDB::IsTrgL1()
1123{
1124 //
1125 // return if the FEE readout was triggered on L1
1126 //
88a69e6f 1127 if (fMode<0) return kFALSE;
1128 return (fMode==0);
f14d21a1 1129}
3ac615eb 1130
1131void AliTPCcalibDB::RegisterExB(Int_t index, Float_t bz, Bool_t bdelete){
1132 //
1133 // Register static ExB correction map
1134 // index - registration index - used for visualization
1135 // bz - bz field in kGaus
1136
0a997b33 1137 // Float_t factor = bz/(-5.); // default b filed in Cheb with minus sign
1138 Float_t factor = bz/(5.); // default b filed in Cheb with minus sign
1139 // was chenged in the Revision ???? (Ruben can you add here number)
3ac615eb 1140
4642ac4b 1141 AliMagF* bmap = new AliMagF("MapsExB","MapsExB", factor,TMath::Sign(1.f,factor),AliMagF::k5kG);
3ac615eb 1142
1143 AliTPCExBFirst *exb = new AliTPCExBFirst(bmap,0.88*2.6400e+04,50,50,50);
1144 AliTPCExB::SetInstance(exb);
1145
1146 if (bdelete){
1147 delete bmap;
1148 }else{
1149 AliTPCExB::RegisterField(index,bmap);
1150 }
1151 if (index>=fgExBArray.GetEntries()) fgExBArray.Expand((index+1)*2+11);
1152 fgExBArray.AddAt(exb,index);
1153}
1154
1155
1156AliTPCExB* AliTPCcalibDB::GetExB(Float_t bz, Bool_t deleteB) {
1157 //
1158 // bz filed in KGaus not in tesla
1159 // Get ExB correction map
1160 // if doesn't exist - create it
1161 //
1162 Int_t index = TMath::Nint(5+bz);
1163 if (index>fgExBArray.GetEntries()) fgExBArray.Expand((index+1)*2+11);
1164 if (!fgExBArray.At(index)) AliTPCcalibDB::RegisterExB(index,bz,deleteB);
1165 return (AliTPCExB*)fgExBArray.At(index);
1166}
1167
1168
1169void AliTPCcalibDB::SetExBField(Float_t bz){
1170 //
1171 // Set magnetic filed for ExB correction
1172 //
1173 fExB = GetExB(bz,kFALSE);
1174}
bf85fe4d 1175
0a997b33 1176void AliTPCcalibDB::SetExBField(const AliMagF* bmap){
1177 //
1178 // Set magnetic field for ExB correction
1179 //
1180 AliTPCExBFirst *exb = new AliTPCExBFirst(bmap,0.88*2.6400e+04,50,50,50);
1181 AliTPCExB::SetInstance(exb);
1182 fExB=exb;
1183}
1184
bf85fe4d 1185
1186
5e1215d4 1187void AliTPCcalibDB::UpdateRunInformations( Int_t run, Bool_t force){
bf85fe4d 1188 //
1189 // - > Don't use it for reconstruction - Only for Calibration studies
1190 //
b96c3aef 1191 if (run<=0) return;
2b4c6ff5 1192 TObjString runstr(Form("%i",run));
14301155 1193 fRun=run;
bf85fe4d 1194 AliCDBEntry * entry = 0;
cc65e4f5 1195 if (run>= fRunList.fN){
bf85fe4d 1196 fRunList.Set(run*2+1);
cc65e4f5 1197 //
1198 //
1199 fALTROConfigData->Expand(run*2+1); // ALTRO configuration data
1200 fPulserData->Expand(run*2+1); // Calibration Pulser data
1201 fCEData->Expand(run*2+1); // CE data
d32e8676 1202 if (!fTimeGainSplines) fTimeGainSplines = new TObjArray(run*2+1);
cc65e4f5 1203 fTimeGainSplines->Expand(run*2+1); // Array of AliSplineFits: at 0 MIP position in
bf85fe4d 1204 }
cc65e4f5 1205 if (fRunList[run]>0 &&force==kFALSE) return;
1e722a63 1206
1207 fRunList[run]=1; // sign as used
1208
5e1215d4 1209 //
bf85fe4d 1210 entry = AliCDBManager::Instance()->Get("GRP/GRP/Data",run);
0231c65f 1211 if (entry) {
1212 AliGRPObject * grpRun = dynamic_cast<AliGRPObject*>(entry->GetObject());
1213 if (!grpRun){
1214 TMap* map = dynamic_cast<TMap*>(entry->GetObject());
1215 if (map){
e2914767 1216 //grpRun = new AliGRPObject;
1217 //grpRun->ReadValuesFromMap(map);
1218 grpRun = MakeGRPObjectFromMap(map);
1219
2b4c6ff5 1220 fGRPMaps.Add(new TObjString(runstr),map);
0231c65f 1221 }
1222 }
2b4c6ff5 1223 fGRPArray.Add(new TObjString(runstr),grpRun);
0231c65f 1224 }
bf85fe4d 1225 entry = AliCDBManager::Instance()->Get("TPC/Calib/Goofie",run);
5e1215d4 1226 if (entry){
2b4c6ff5 1227 fGoofieArray.Add(new TObjString(runstr),entry->GetObject());
5e1215d4 1228 }
e2914767 1229 //
2293155b 1230
e2914767 1231 //
a2c3785e 1232 entry = AliCDBManager::Instance()->Get("TPC/Calib/TimeGain",run);
5e1215d4 1233 if (entry) {
2b4c6ff5 1234 fTimeGainSplinesArray.Add(new TObjString(runstr),entry->GetObject());
2293155b 1235 }else{
13242232 1236 AliFatal("TPC - Missing calibration entry TimeGain");
5e1215d4 1237 }
1238 //
1239 entry = AliCDBManager::Instance()->Get("TPC/Calib/TimeDrift",run);
1240 if (entry) {
3f3549a3 1241 TObjArray * timeArray = (TObjArray*)entry->GetObject();
2b4c6ff5 1242 fDriftCorrectionArray.Add(new TObjString(runstr),entry->GetObject());
3f3549a3 1243 AliTPCCorrection * correctionTime = (AliTPCCorrection *)timeArray->FindObject("FitCorrectionTime");
1244 if (correctionTime && fComposedCorrectionArray){
1245 correctionTime->Init();
a8ef8a9c 1246 if (fComposedCorrectionArray->GetEntriesFast()<4) fComposedCorrectionArray->Expand(40);
3f3549a3 1247 fComposedCorrectionArray->AddAt(correctionTime,4); //add time dependent correction to the list of available corrections
1248 }
2293155b 1249 }else{
13242232 1250 AliFatal("TPC - Missing calibration entry TimeDrift");
5e1215d4 1251 }
a2c3785e 1252 //
bf85fe4d 1253 entry = AliCDBManager::Instance()->Get("TPC/Calib/Temperature",run);
5e1215d4 1254 if (entry) {
2b4c6ff5 1255 fTemperatureArray.Add(new TObjString(runstr),entry->GetObject());
5e1215d4 1256 }
8de4c8a6 1257
1258 // High voltage
1259 entry = AliCDBManager::Instance()->Get("TPC/Calib/HighVoltage",run);
2b4c6ff5 1260 if (!fVoltageArray.GetValue(runstr.GetName()) && entry) {
1261 fVoltageArray.Add(new TObjString(runstr),entry->GetObject());
8de4c8a6 1262 }
1263
1e722a63 1264 //apply fDButil filters
1265
1266 fDButil->UpdateFromCalibDB();
1267 if (fTemperature) fDButil->FilterTemperature(fTemperature);
da6c0bc9 1268
bfec3eeb 1269 AliDCSSensor * press = GetPressureSensor(run,0);
da6c0bc9 1270 AliTPCSensorTempArray * temp = GetTemperatureSensor(run);
1e722a63 1271 Bool_t accept=kTRUE;
1272 if (temp) {
1273 accept = fDButil->FilterTemperature(temp)>0.1;
1274 }
1275 if (press) {
7506b1e9 1276 const Double_t kMinP=900.;
1e722a63 1277 const Double_t kMaxP=1050.;
1278 const Double_t kMaxdP=10.;
1279 const Double_t kSigmaCut=4.;
1280 fDButil->FilterSensor(press,kMinP,kMaxP,kMaxdP,kSigmaCut);
1281 if (press->GetFit()==0) accept=kFALSE;
1282 }
5647625c 1283
1e722a63 1284 if (press && temp &&accept){
da6c0bc9 1285 AliTPCCalibVdrift * vdrift = new AliTPCCalibVdrift(temp, press,0);
2b4c6ff5 1286 fVdriftArray.Add(new TObjString(runstr),vdrift);
da6c0bc9 1287 }
5647625c 1288
1e722a63 1289 fDButil->FilterCE(120., 3., 4.,0);
1290 fDButil->FilterTracks(run, 10.,0);
5647625c 1291
bf85fe4d 1292}
1293
1294
1295Float_t AliTPCcalibDB::GetGain(Int_t sector, Int_t row, Int_t pad){
1296 //
92fb7d95 1297 // Get Gain factor for given pad
bf85fe4d 1298 //
1299 AliTPCCalPad *calPad = Instance()->fDedxGainFactor;;
1300 if (!calPad) return 0;
1301 return calPad->GetCalROC(sector)->GetValue(row,pad);
1302}
1303
7390f655 1304AliSplineFit* AliTPCcalibDB::GetVdriftSplineFit(const char* name, Int_t run){
1305 //
92fb7d95 1306 // GetDrift velocity spline fit
7390f655 1307 //
1308 TObjArray *arr=GetTimeVdriftSplineRun(run);
1309 if (!arr) return 0;
1310 return dynamic_cast<AliSplineFit*>(arr->FindObject(name));
1311}
1312
2cb269df 1313AliSplineFit* AliTPCcalibDB::CreateVdriftSplineFit(const char* graphName, Int_t run){
1314 //
1315 // create spline fit from the drift time graph in TimeDrift
1316 //
1317 TObjArray *arr=GetTimeVdriftSplineRun(run);
1318 if (!arr) return 0;
1319 TGraph *graph=dynamic_cast<TGraph*>(arr->FindObject(graphName));
1320 if (!graph) return 0;
1321 AliSplineFit *fit = new AliSplineFit();
1322 fit->SetGraph(graph);
1323 fit->SetMinPoints(graph->GetN()+1);
1324 fit->InitKnots(graph,2,0,0.001);
1325 fit->SplineFit(0);
1326 return fit;
1327}
8de77f00 1328
1329AliGRPObject *AliTPCcalibDB::GetGRP(Int_t run){
1330 //
1331 // Get GRP object for given run
1332 //
2b4c6ff5 1333 AliGRPObject * grpRun = dynamic_cast<AliGRPObject *>((Instance()->fGRPArray).GetValue(Form("%i",run)));
8de77f00 1334 if (!grpRun) {
5e1215d4 1335 Instance()->UpdateRunInformations(run);
2b4c6ff5 1336 grpRun = dynamic_cast<AliGRPObject *>(Instance()->fGRPArray.GetValue(Form("%i",run)));
8de77f00 1337 if (!grpRun) return 0;
1338 }
1339 return grpRun;
1340}
1341
0231c65f 1342TMap * AliTPCcalibDB::GetGRPMap(Int_t run){
1343 //
92fb7d95 1344 // Get GRP map for given run
0231c65f 1345 //
2b4c6ff5 1346 TMap * grpRun = dynamic_cast<TMap *>((Instance()->fGRPMaps).GetValue(Form("%i",run)));
0231c65f 1347 if (!grpRun) {
5e1215d4 1348 Instance()->UpdateRunInformations(run);
2b4c6ff5 1349 grpRun = dynamic_cast<TMap *>(Instance()->fGRPMaps.GetValue(Form("%i",run)));
0231c65f 1350 if (!grpRun) return 0;
1351 }
1352 return grpRun;
1353}
8de77f00 1354
1355
da6c0bc9 1356AliDCSSensor * AliTPCcalibDB::GetPressureSensor(Int_t run, Int_t type){
bf85fe4d 1357 //
0231c65f 1358 // Get Pressure sensor
bfec3eeb 1359 // run = run number
1360 // type = 0 - Cavern pressure
1361 // 1 - Suface pressure
0231c65f 1362 // First try to get if trom map - if existing (Old format of data storing)
bf85fe4d 1363 //
bfec3eeb 1364
1365
0231c65f 1366 TMap *map = GetGRPMap(run);
1367 if (map){
1368 AliDCSSensor * sensor = 0;
1369 TObject *osensor=0;
2cd3a697 1370 if (type==0) osensor = ((*map)("fCavernPressure"));
0231c65f 1371 if (type==1) osensor = ((*map)("fP2Pressure"));
1372 sensor =dynamic_cast<AliDCSSensor *>(osensor);
1373 if (sensor) return sensor;
1374 }
1375 //
1376 // If not map try to get it from the GRPObject
1377 //
2b4c6ff5 1378 AliGRPObject * grpRun = dynamic_cast<AliGRPObject *>(fGRPArray.GetValue(Form("%i",run)));
bf85fe4d 1379 if (!grpRun) {
5e1215d4 1380 UpdateRunInformations(run);
2b4c6ff5 1381 grpRun = dynamic_cast<AliGRPObject *>(fGRPArray.GetValue(Form("%i",run)));
bf85fe4d 1382 if (!grpRun) return 0;
1383 }
2cd3a697 1384 AliDCSSensor * sensor = grpRun->GetCavernAtmosPressure();
da6c0bc9 1385 if (type==1) sensor = grpRun->GetSurfaceAtmosPressure();
1386 return sensor;
bf85fe4d 1387}
1388
1389AliTPCSensorTempArray * AliTPCcalibDB::GetTemperatureSensor(Int_t run){
1390 //
1391 // Get temperature sensor array
1392 //
2b4c6ff5 1393 AliTPCSensorTempArray * tempArray = (AliTPCSensorTempArray *)fTemperatureArray.GetValue(Form("%i",run));
bf85fe4d 1394 if (!tempArray) {
5e1215d4 1395 UpdateRunInformations(run);
2b4c6ff5 1396 tempArray = (AliTPCSensorTempArray *)fTemperatureArray.GetValue(Form("%i",run));
bf85fe4d 1397 }
1398 return tempArray;
1399}
1400
a2c3785e 1401
1402TObjArray * AliTPCcalibDB::GetTimeGainSplinesRun(Int_t run){
bf85fe4d 1403 //
1404 // Get temperature sensor array
1405 //
2b4c6ff5 1406 TObjArray * gainSplines = (TObjArray *)fTimeGainSplinesArray.GetValue(Form("%i",run));
a2c3785e 1407 if (!gainSplines) {
5e1215d4 1408 UpdateRunInformations(run);
2b4c6ff5 1409 gainSplines = (TObjArray *)fTimeGainSplinesArray.GetValue(Form("%i",run));
bf85fe4d 1410 }
a2c3785e 1411 return gainSplines;
bf85fe4d 1412}
1413
7390f655 1414TObjArray * AliTPCcalibDB::GetTimeVdriftSplineRun(Int_t run){
1415 //
1416 // Get drift spline array
1417 //
2b4c6ff5 1418 TObjArray * driftSplines = (TObjArray *)fDriftCorrectionArray.GetValue(Form("%i",run));
7390f655 1419 if (!driftSplines) {
1420 UpdateRunInformations(run);
2b4c6ff5 1421 driftSplines = (TObjArray *)fDriftCorrectionArray.GetValue(Form("%i",run));
7390f655 1422 }
1423 return driftSplines;
1424}
1425
e2914767 1426AliDCSSensorArray * AliTPCcalibDB::GetVoltageSensors(Int_t run){
1427 //
1428 // Get temperature sensor array
1429 //
2b4c6ff5 1430 AliDCSSensorArray * voltageArray = (AliDCSSensorArray *)fVoltageArray.GetValue(Form("%i",run));
e2914767 1431 if (!voltageArray) {
5e1215d4 1432 UpdateRunInformations(run);
2b4c6ff5 1433 voltageArray = (AliDCSSensorArray *)fVoltageArray.GetValue(Form("%i",run));
e2914767 1434 }
1435 return voltageArray;
1436}
1437
99895a4f 1438AliDCSSensorArray * AliTPCcalibDB::GetGoofieSensors(Int_t run){
1439 //
1440 // Get temperature sensor array
1441 //
2b4c6ff5 1442 AliDCSSensorArray * goofieArray = (AliDCSSensorArray *)fGoofieArray.GetValue(Form("%i",run));
99895a4f 1443 if (!goofieArray) {
5e1215d4 1444 UpdateRunInformations(run);
2b4c6ff5 1445 goofieArray = (AliDCSSensorArray *)fGoofieArray.GetValue(Form("%i",run));
99895a4f 1446 }
1447 return goofieArray;
1448}
1449
1450
1451
da6c0bc9 1452AliTPCCalibVdrift * AliTPCcalibDB::GetVdrift(Int_t run){
1453 //
1454 // Get the interface to the the vdrift
1455 //
2b4c6ff5 1456 AliTPCCalibVdrift * vdrift = (AliTPCCalibVdrift*)fVdriftArray.GetValue(Form("%i",run));
da6c0bc9 1457 if (!vdrift) {
5e1215d4 1458 UpdateRunInformations(run);
2b4c6ff5 1459 vdrift= (AliTPCCalibVdrift*)fVdriftArray.GetValue(Form("%i",run));
da6c0bc9 1460 }
1461 return vdrift;
1462}
1463
892226be 1464Float_t AliTPCcalibDB::GetCEdriftTime(Int_t run, Int_t sector, Double_t timeStamp, Int_t *entries)
1465{
1466 //
1467 // GetCE drift time information for 'sector'
1468 // sector 72 is the mean drift time of the A-Side
1469 // sector 73 is the mean drift time of the C-Side
1470 // it timestamp==-1 return mean value
1471 //
1472 AliTPCcalibDB::Instance()->SetRun(run);
1473 TGraph *gr=AliTPCcalibDB::Instance()->GetCErocTgraph(sector);
1474 if (!gr||sector<0||sector>73) {
1475 if (entries) *entries=0;
1476 return 0.;
1477 }
1478 Float_t val=0.;
1479 if (timeStamp==-1.){
1480 val=gr->GetMean(2);
1481 }else{
1482 for (Int_t ipoint=0;ipoint<gr->GetN();++ipoint){
1483 Double_t x,y;
1484 gr->GetPoint(ipoint,x,y);
1485 if (x<timeStamp) continue;
1486 val=y;
1487 break;
1488 }
1489 }
1490 return val;
1491}
1492
1493Float_t AliTPCcalibDB::GetCEchargeTime(Int_t run, Int_t sector, Double_t timeStamp, Int_t *entries)
1494{
1495 //
1496 // GetCE mean charge for 'sector'
1497 // it timestamp==-1 return mean value
1498 //
1499 AliTPCcalibDB::Instance()->SetRun(run);
1500 TGraph *gr=AliTPCcalibDB::Instance()->GetCErocQgraph(sector);
1501 if (!gr||sector<0||sector>71) {
1502 if (entries) *entries=0;
1503 return 0.;
1504 }
1505 Float_t val=0.;
1506 if (timeStamp==-1.){
1507 val=gr->GetMean(2);
1508 }else{
1509 for (Int_t ipoint=0;ipoint<gr->GetN();++ipoint){
1510 Double_t x,y;
1511 gr->GetPoint(ipoint,x,y);
1512 if (x<timeStamp) continue;
1513 val=y;
1514 break;
1515 }
1516 }
1517 return val;
1518}
1519
7fff7612 1520Float_t AliTPCcalibDB::GetDCSSensorValue(AliDCSSensorArray *arr, Int_t timeStamp, const char * sensorName, Int_t sigDigits)
1521{
1522 //
1523 // Get Value for a DCS sensor 'sensorName', run 'run' at time 'timeStamp'
1524 //
1525 Float_t val=0;
1526 const TString sensorNameString(sensorName);
1527 AliDCSSensor *sensor = arr->GetSensor(sensorNameString);
1528 if (!sensor) return val;
892226be 1529 //use the dcs graph if possible
1530 TGraph *gr=sensor->GetGraph();
1531 if (gr){
1532 for (Int_t ipoint=0;ipoint<gr->GetN();++ipoint){
1533 Double_t x,y;
1534 gr->GetPoint(ipoint,x,y);
7390f655 1535 Int_t time=TMath::Nint(sensor->GetStartTime()+x*3600); //time in graph is hours
892226be 1536 if (time<timeStamp) continue;
1537 val=y;
1538 break;
1539 }
1540 //if val is still 0, test if if the requested time if within 5min of the first/last
1541 //data point. If this is the case return the firs/last entry
1542 //the timestamps might not be syncronised for all calibration types, sometimes a 'pre'
1543 //and 'pos' period is requested. Especially to the HV this is not the case!
1544 //first point
1545 if (val==0 ){
1546 Double_t x,y;
1547 gr->GetPoint(0,x,y);
2c949bb2 1548 const Int_t time=TMath::Nint(sensor->GetStartTime()+x*3600); //time in graph is hours
1549 const Int_t dtime=time-timeStamp;
1550 if ( (dtime>0) && (dtime<5*60) ) val=y;
892226be 1551 }
1552 //last point
1553 if (val==0 ){
1554 Double_t x,y;
1555 gr->GetPoint(gr->GetN()-1,x,y);
2c949bb2 1556 const Int_t time=TMath::Nint(sensor->GetStartTime()+x*3600); //time in graph is hours
1557 const Int_t dtime=timeStamp-time;
1558 if ( (dtime>0) && (dtime<5*60) ) val=y;
892226be 1559 }
1560 } else {
1561 val=sensor->GetValue(timeStamp);
1562 }
7fff7612 1563 if (sigDigits>=0){
1564 val=(Float_t)TMath::Floor(val * TMath::Power(10., sigDigits) + .5) / TMath::Power(10., sigDigits);
1565 }
1566 return val;
1567}
1568
1569Float_t AliTPCcalibDB::GetDCSSensorMeanValue(AliDCSSensorArray *arr, const char * sensorName, Int_t sigDigits)
1570{
1571 //
1572 // Get mean Value for a DCS sensor 'sensorName' during run 'run'
1573 //
1574 Float_t val=0;
1575 const TString sensorNameString(sensorName);
1576 AliDCSSensor *sensor = arr->GetSensor(sensorNameString);
1577 if (!sensor) return val;
892226be 1578
1579 //use dcs graph if it exists
1580 TGraph *gr=sensor->GetGraph();
1581 if (gr){
1582 val=gr->GetMean(2);
1583 } else {
1584 //if we don't have the dcs graph, try to get some meaningful information
1585 if (!sensor->GetFit()) return val;
1586 Int_t nKnots=sensor->GetFit()->GetKnots();
1587 Double_t tMid=(sensor->GetEndTime()-sensor->GetStartTime())/2.;
1588 for (Int_t iKnot=0;iKnot<nKnots;++iKnot){
1589 if (sensor->GetFit()->GetX()[iKnot]>tMid/3600.) break;
1590 val=(Float_t)sensor->GetFit()->GetY0()[iKnot];
1591 }
7fff7612 1592 }
7fff7612 1593 if (sigDigits>=0){
60721370 1594 // val/=10;
7fff7612 1595 val=(Float_t)TMath::Floor(val * TMath::Power(10., sigDigits) + .5) / TMath::Power(10., sigDigits);
60721370 1596 // val*=10;
7fff7612 1597 }
1598 return val;
1599}
bf85fe4d 1600
661f340b 1601Bool_t AliTPCcalibDB::IsDataTakingActive(time_t timeStamp)
1602{
1603 if (!fGrRunState) return kFALSE;
1604 Double_t time=Double_t(timeStamp);
1605 Int_t currentPoint=0;
1606 Bool_t currentVal=fGrRunState->GetY()[currentPoint]>0.5;
1607 Bool_t retVal=currentVal;
1608 Double_t currentTime=fGrRunState->GetX()[currentPoint];
1609
1610 while (time>currentTime){
1611 retVal=currentVal;
1612 if (currentPoint==fGrRunState->GetN()) break;
1613 currentVal=fGrRunState->GetY()[currentPoint]>0.5;
1614 currentTime=fGrRunState->GetX()[currentPoint];
1615 ++currentPoint;
1616 }
1617
1618 return retVal;
1619}
1620
1621void AliTPCcalibDB::UpdateChamberHighVoltageData()
1622{
1623 //
1624 // set chamber high voltage data
1625 // 1. Robust median (sampling the hv graphs over time)
1626 // 2. Current nominal voltages (nominal voltage corrected for common HV offset)
1627 // 3. Fraction of good HV values over time (deviation from robust median)
1628 // 4. HV status, based on the above
1629 //
1630
1631 // start and end time of the run
1632 const Int_t run=GetRun();
1633 if (run<0) return;
6282b748 1634
1635 // if no valid run information - return
1636 AliGRPObject* grp = GetGRP(run);
1637 if (!grp) return;
1638
1639 const Int_t startTimeGRP = grp->GetTimeStart();
1640 const Int_t stopTimeGRP = grp->GetTimeEnd();
661f340b 1641
1642 //
1643 // check active state by analysing the scalers
1644 //
1645 // initialise graph with active running
1646 AliCDBEntry *entry = GetCDBEntry("GRP/CTP/Scalers");
a3c96d3f 1647 if (!entry) return;
11981cb2 1648 // entry->SetOwner(kTRUE);
661f340b 1649 AliTriggerRunScalers *sca = (AliTriggerRunScalers*)entry->GetObject();
1650 Int_t nchannels = sca->GetNumClasses(); // number of scaler channels (i.e. trigger classes)
1651 Int_t npoints = sca->GetScalersRecords()->GetEntries(); // number of samples
1652
1653 delete fGrRunState;
1654 fGrRunState=new TGraph;
1655 fGrRunState->SetPoint(fGrRunState->GetN(),Double_t(startTimeGRP)-.001,0);
1656 fGrRunState->SetPoint(fGrRunState->GetN(),Double_t(startTimeGRP),1);
1657 ULong64_t lastSum=0;
1658 Double_t timeLast=0.;
1659 Bool_t active=kTRUE;
1660 for (int i=0; i<npoints; i++) {
1661 AliTriggerScalersRecord *rec = (AliTriggerScalersRecord *) sca->GetScalersRecord(i);
1662 Double_t time = ((AliTimeStamp*) rec->GetTimeStamp())->GetSeconds();
1663 ULong64_t sum=0;
1664 for (int j=0; j<nchannels; j++) sum += ((AliTriggerScalers*) rec->GetTriggerScalers()->At(j))->GetL2CA();
1665 if (TMath::Abs(time-timeLast)<.001 && sum==lastSum ) continue;
1666 if (active && sum==lastSum){
1667 fGrRunState->SetPoint(fGrRunState->GetN(),timeLast-.01,1);
1668 fGrRunState->SetPoint(fGrRunState->GetN(),timeLast,0);
1669 active=kFALSE;
1670 } else if (!active && sum>lastSum ){
1671 fGrRunState->SetPoint(fGrRunState->GetN(),timeLast-.01,0);
1672 fGrRunState->SetPoint(fGrRunState->GetN(),timeLast,1);
1673 active=kTRUE;
1674 }
1675 lastSum=sum;
1676 timeLast=time;
1677 }
1678 fGrRunState->SetPoint(fGrRunState->GetN(),Double_t(stopTimeGRP),active);
1679 fGrRunState->SetPoint(fGrRunState->GetN(),Double_t(stopTimeGRP)+.001,0);
1680
1681
1682
1683 // reset all values
1684 for (Int_t iROC=0;iROC<72;++iROC) {
1685 fChamberHVmedian[iROC] = -1;
1686 fChamberHVgoodFraction[iROC] = 0.;
1687 fCurrentNominalVoltage[iROC] = -999.;
1688 fChamberHVStatus[iROC] = kFALSE;
1689 }
1690
1691 AliDCSSensorArray* voltageArray = GetVoltageSensors(run);
1692 if (!voltageArray) {
1693 AliError("Voltage Array missing. Cannot calculate HV information!");
1694 return;
1695 }
1696
1697 // max HV diffs before a chamber is masked
1698 const Float_t maxVdiff = fParam->GetMaxVoltageDeviation();
1699 const Float_t maxDipVoltage = fParam->GetMaxDipVoltage();
1700 const Float_t maxFracHVbad = fParam->GetMaxFractionHVbad();
1701
1702 const Int_t samplingPeriod=1;
1703
1704 // array with sampled voltages
1705 const Int_t maxSamples=(stopTimeGRP-startTimeGRP)/samplingPeriod + 10*samplingPeriod;
1706 Float_t *vSampled = new Float_t[maxSamples];
1707
1708 // deviation of the median from the nominal voltage
1709 Double_t chamberMedianDeviation[72]={0.};
1710
1711 for (Int_t iROC=0; iROC<72; ++iROC){
1712 chamberMedianDeviation[iROC]=0.;
1713 TString sensorName="";
1714 Char_t sideName='A';
1715 if ((iROC/18)%2==1) sideName='C';
1716 if (iROC<36) sensorName=Form("TPC_ANODE_I_%c%02d_VMEAS",sideName,iROC%18);
1717 else sensorName=Form("TPC_ANODE_O_%c%02d_0_VMEAS",sideName,iROC%18);
1718
1719 AliDCSSensor *sensor = voltageArray->GetSensor(sensorName);
1720
1721 fHVsensors[iROC]=sensor;
1722 if (!sensor) continue;
1723
1724 Int_t nPointsSampled=0;
1725
1726 TGraph *gr=sensor->GetGraph();
1727 if ( gr && gr->GetN()>1 ){
1728 //1. sample voltage over time
1729 // get a robust median
1730 // buffer sampled voltages
1731
1732 // current sampling time
1733 Int_t time=startTimeGRP;
1734
1735 // input graph sampling point
1736 const Int_t nGraph=gr->GetN();
1737 Int_t pointGraph=0;
1738
1739 //initialise graph information
1740 Int_t timeGraph=TMath::Nint(gr->GetX()[pointGraph+1]*3600+sensor->GetStartTime());
1741 Double_t sampledHV=gr->GetY()[pointGraph++];
1742
1743 while (time<stopTimeGRP){
1744 while (timeGraph<=time && pointGraph+1<nGraph){
1745 timeGraph=TMath::Nint(gr->GetX()[pointGraph+1]*3600+sensor->GetStartTime());
1746 sampledHV=gr->GetY()[pointGraph++];
1747 }
1748 time+=samplingPeriod;
1749 if (!IsDataTakingActive(time-samplingPeriod)) continue;
1750 vSampled[nPointsSampled++]=sampledHV;
1751 }
1752
1753 if (nPointsSampled<1) continue;
1754
1755 fChamberHVmedian[iROC]=TMath::Median(nPointsSampled,vSampled);
1756 chamberMedianDeviation[iROC]=fChamberHVmedian[iROC]-fParam->GetNominalVoltage(iROC);
1757
1758 //2. calculate good HV fraction
1759 Int_t ngood=0;
1760 for (Int_t ipoint=0; ipoint<nPointsSampled; ++ipoint) {
1761 if (TMath::Abs(vSampled[ipoint]-fChamberHVmedian[iROC])<maxDipVoltage) ++ngood;
1762 }
1763
1764 fChamberHVgoodFraction[iROC]=Float_t(ngood)/Float_t(nPointsSampled);
1765 } else {
1766 AliError(Form("No Graph or too few points found for HV sensor of ROC %d",iROC));
1767 }
1768 }
1769
1770 delete [] vSampled;
1771 vSampled=0x0;
1772
1773 // get median deviation from all chambers (detect e.g. -50V)
1774 const Double_t medianIROC=TMath::Median( 36, chamberMedianDeviation );
1775 const Double_t medianOROC=TMath::Median( 36, chamberMedianDeviation+36 );
1776
1777 // Define current default voltages
1778 for (Int_t iROC=0;iROC<72/*AliTPCCalPad::kNsec*/;++iROC){
1779 const Float_t averageDeviation=(iROC<36)?medianIROC:medianOROC;
1780 fCurrentNominalVoltage[iROC]=fParam->GetNominalVoltage(iROC)+averageDeviation;
1781 }
1782
1783 //
1784 // Check HV status
1785 //
1786 for (Int_t iROC=0;iROC<72/*AliTPCCalPad::kNsec*/;++iROC){
1787 fChamberHVStatus[iROC]=kTRUE;
1788
1789 //a. Deviation of median from current nominal voltage
1790 // allow larger than nominal voltages
1791 if (fCurrentNominalVoltage[iROC]-fChamberHVmedian[iROC] > maxVdiff) fChamberHVStatus[iROC]=kFALSE;
1792
1793 //b. Fraction of bad hv values
1794 if ( 1-fChamberHVgoodFraction[iROC] > maxFracHVbad ) fChamberHVStatus[iROC]=kFALSE;
1795 }
1796}
1797
2073b7a5 1798Float_t AliTPCcalibDB::GetChamberHighVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits, Bool_t current) {
e2914767 1799 //
1800 // return the chamber HV for given run and time: 0-35 IROC, 36-72 OROC
7fff7612 1801 // if timeStamp==-1 return mean value
1802 //
1803 Float_t val=0;
1804 TString sensorName="";
1805 TTimeStamp stamp(timeStamp);
1806 AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run);
1807 if (!voltageArray || (sector<0) || (sector>71)) return val;
1808 Char_t sideName='A';
1809 if ((sector/18)%2==1) sideName='C';
1810 if (sector<36){
1811 //IROC
1812 sensorName=Form("TPC_ANODE_I_%c%02d_VMEAS",sideName,sector%18);
1813 }else{
1814 //OROC
1815 sensorName=Form("TPC_ANODE_O_%c%02d_0_VMEAS",sideName,sector%18);
1816 }
2073b7a5 1817 if (current){
1818 if (sector<36){
1819 //IROC
1820 sensorName=Form("TPC_ANODE_I_%c%02d_IMEAS",sideName,sector%18);
8de4c8a6 1821 }else{
2073b7a5 1822 //OROC
1823 sensorName=Form("TPC_ANODE_O_%c%02d_0_IMEAS",sideName,sector%18);
1824 }
8de4c8a6 1825
2073b7a5 1826 }
7fff7612 1827 if (timeStamp==-1){
1828 val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits);
1829 } else {
1830 val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits);
1831 }
1832 return val;
1833}
1834Float_t AliTPCcalibDB::GetSkirtVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
1835{
1836 //
1837 // Get the skirt voltage for 'run' at 'timeStamp' and 'sector': 0-35 IROC, 36-72 OROC
1838 // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
1839 // if timeStamp==-1 return the mean value for the run
1840 //
1841 Float_t val=0;
1842 TString sensorName="";
1843 TTimeStamp stamp(timeStamp);
1844 AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run);
1845 if (!voltageArray || (sector<0) || (sector>71)) return val;
1846 Char_t sideName='A';
1847 if ((sector/18)%2==1) sideName='C';
1848 sensorName=Form("TPC_SKIRT_%c_VMEAS",sideName);
1849 if (timeStamp==-1){
1850 val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits);
1851 } else {
1852 val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits);
1853 }
1854 return val;
1855}
1856
1857Float_t AliTPCcalibDB::GetCoverVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
1858{
1859 //
1860 // Get the cover voltage for run 'run' at time 'timeStamp'
1861 // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
1862 // if timeStamp==-1 return the mean value for the run
e2914767 1863 //
7fff7612 1864 Float_t val=0;
1865 TString sensorName="";
e2914767 1866 TTimeStamp stamp(timeStamp);
1867 AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run);
7fff7612 1868 if (!voltageArray || (sector<0) || (sector>71)) return val;
1869 Char_t sideName='A';
1870 if ((sector/18)%2==1) sideName='C';
1871 if (sector<36){
1872 //IROC
1873 sensorName=Form("TPC_COVER_I_%c_VMEAS",sideName);
1874 }else{
1875 //OROC
1876 sensorName=Form("TPC_COVER_O_%c_VMEAS",sideName);
1877 }
1878 if (timeStamp==-1){
1879 val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits);
1880 } else {
1881 val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits);
1882 }
1883 return val;
1884}
1885
1886Float_t AliTPCcalibDB::GetGGoffsetVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
1887{
1888 //
1889 // Get the GG offset voltage for run 'run' at time 'timeStamp'
1890 // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
1891 // if timeStamp==-1 return the mean value for the run
1892 //
1893 Float_t val=0;
1894 TString sensorName="";
1895 TTimeStamp stamp(timeStamp);
1896 AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run);
1897 if (!voltageArray || (sector<0) || (sector>71)) return val;
1898 Char_t sideName='A';
1899 if ((sector/18)%2==1) sideName='C';
1900 if (sector<36){
1901 //IROC
1902 sensorName=Form("TPC_GATE_I_%c_OFF_VMEAS",sideName);
1903 }else{
1904 //OROC
1905 sensorName=Form("TPC_GATE_O_%c_OFF_VMEAS",sideName);
1906 }
1907 if (timeStamp==-1){
1908 val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits);
1909 } else {
1910 val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits);
1911 }
1912 return val;
1913}
1914
1915Float_t AliTPCcalibDB::GetGGnegVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
1916{
1917 //
1918 // Get the GG offset voltage for run 'run' at time 'timeStamp'
1919 // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
1920 // if timeStamp==-1 return the mean value for the run
1921 //
1922 Float_t val=0;
1923 TString sensorName="";
1924 TTimeStamp stamp(timeStamp);
1925 AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run);
1926 if (!voltageArray || (sector<0) || (sector>71)) return val;
1927 Char_t sideName='A';
1928 if ((sector/18)%2==1) sideName='C';
1929 if (sector<36){
1930 //IROC
1931 sensorName=Form("TPC_GATE_I_%c_NEG_VMEAS",sideName);
1932 }else{
1933 //OROC
1934 sensorName=Form("TPC_GATE_O_%c_NEG_VMEAS",sideName);
1935 }
1936 if (timeStamp==-1){
1937 val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits);
1938 } else {
1939 val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits);
1940 }
1941 return val;
1942}
1943
1944Float_t AliTPCcalibDB::GetGGposVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
1945{
1946 //
1947 // Get the GG offset voltage for run 'run' at time 'timeStamp'
1948 // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
1949 // if timeStamp==-1 return the mean value for the run
1950 //
1951 Float_t val=0;
1952 TString sensorName="";
1953 TTimeStamp stamp(timeStamp);
1954 AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run);
1955 if (!voltageArray || (sector<0) || (sector>71)) return val;
1956 Char_t sideName='A';
1957 if ((sector/18)%2==1) sideName='C';
1958 if (sector<36){
1959 //IROC
1960 sensorName=Form("TPC_GATE_I_%c_POS_VMEAS",sideName);
1961 }else{
1962 //OROC
1963 sensorName=Form("TPC_GATE_O_%c_POS_VMEAS",sideName);
1964 }
1965 if (timeStamp==-1){
1966 val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits);
1967 } else {
1968 val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits);
1969 }
1970 return val;
e2914767 1971}
bf85fe4d 1972
da6c0bc9 1973Float_t AliTPCcalibDB::GetPressure(Int_t timeStamp, Int_t run, Int_t type){
bf85fe4d 1974 //
1975 // GetPressure for given time stamp and runt
1976 //
1977 TTimeStamp stamp(timeStamp);
da6c0bc9 1978 AliDCSSensor * sensor = Instance()->GetPressureSensor(run,type);
bf85fe4d 1979 if (!sensor) return 0;
bf85fe4d 1980 return sensor->GetValue(stamp);
1981}
1982
5312f439 1983Float_t AliTPCcalibDB::GetL3Current(Int_t run, Int_t statType){
1984 //
1985 // return L3 current
1986 // stat type is: AliGRPObject::Stats: kMean = 0, kTruncMean = 1, kMedian = 2, kSDMean = 3, kSDMedian = 4
1987 //
1988 Float_t current=-1;
1989 AliGRPObject *grp=AliTPCcalibDB::GetGRP(run);
1990 if (grp) current=grp->GetL3Current((AliGRPObject::Stats)statType);
1991 return current;
1992}
1993
1994Float_t AliTPCcalibDB::GetBz(Int_t run){
1995 //
e6970ab5 1996 // calculate BZ in T from L3 current
5312f439 1997 //
1998 Float_t bz=-1;
1999 Float_t current=AliTPCcalibDB::GetL3Current(run);
e6970ab5 2000 if (current>-1) bz=5*current/30000.*.1;
5312f439 2001 return bz;
2002}
2003
2004Char_t AliTPCcalibDB::GetL3Polarity(Int_t run) {
2005 //
2006 // get l3 polarity from GRP
2007 //
7390f655 2008 Char_t pol=-100;
2009 AliGRPObject *grp=AliTPCcalibDB::GetGRP(run);
2010 if (grp) pol=grp->GetL3Polarity();
2011 return pol;
5312f439 2012}
2013
2014TString AliTPCcalibDB::GetRunType(Int_t run){
2015 //
2016 // return run type from grp
2017 //
7390f655 2018
2019// TString type("UNKNOWN");
2020 AliGRPObject *grp=AliTPCcalibDB::GetGRP(run);
2021 if (grp) return grp->GetRunType();
2022 return "UNKNOWN";
5312f439 2023}
2024
7f7847fe 2025Float_t AliTPCcalibDB::GetValueGoofie(Int_t timeStamp, Int_t run, Int_t type){
2026 //
2027 // GetPressure for given time stamp and runt
2028 //
2029 TTimeStamp stamp(timeStamp);
2030 AliDCSSensorArray* goofieArray = AliTPCcalibDB::Instance()->GetGoofieSensors(run);
2031 if (!goofieArray) return 0;
2032 AliDCSSensor *sensor = goofieArray->GetSensor(type);
2033 return sensor->GetValue(stamp);
2034}
2035
2036
2037
2038
2039
2040
f0269955 2041Bool_t AliTPCcalibDB::GetTemperatureFit(Int_t timeStamp, Int_t run, Int_t side,TVectorD& fit){
2042 //
92fb7d95 2043 // GetTmeparature fit at parameter for given time stamp
f0269955 2044 //
2045 TTimeStamp tstamp(timeStamp);
64b48395 2046 AliTPCSensorTempArray* tempArray = Instance()->GetTemperatureSensor(run);
f0269955 2047 if (! tempArray) return kFALSE;
2048 AliTPCTempMap * tempMap = new AliTPCTempMap(tempArray);
2049 TLinearFitter * fitter = tempMap->GetLinearFitter(3,side,tstamp);
2050 if (fitter){
2051 fitter->Eval();
2052 fitter->GetParameters(fit);
2053 }
2054 delete fitter;
2055 delete tempMap;
2056 if (!fitter) return kFALSE;
2057 return kTRUE;
2058}
2059
64b48395 2060Float_t AliTPCcalibDB::GetTemperature(Int_t timeStamp, Int_t run, Int_t side){
2061 //
92fb7d95 2062 // Get mean temperature
2063 //
12e42756 2064 TVectorD vec(5);
64b48395 2065 if (side==0) {
2066 GetTemperatureFit(timeStamp,run,0,vec);
2067 return vec[0];
2068 }
2069 if (side==1){
2070 GetTemperatureFit(timeStamp,run,0,vec);
2071 return vec[0];
2072 }
57dc06f2 2073 return 0;
64b48395 2074}
bf85fe4d 2075
2076
da6c0bc9 2077Double_t AliTPCcalibDB::GetPTRelative(UInt_t timeSec, Int_t run, Int_t side){
2078 //
2079 // Get relative P/T
2080 // time - absolute time
2081 // run - run number
2082 // side - 0 - A side 1-C side
2083 AliTPCCalibVdrift * vdrift = Instance()->GetVdrift(run);
2084 if (!vdrift) return 0;
2085 return vdrift->GetPTRelative(timeSec,side);
2086}
2087
e2914767 2088AliGRPObject * AliTPCcalibDB::MakeGRPObjectFromMap(TMap *map){
2089 //
2090 // Function to covert old GRP run information from TMap to GRPObject
2091 //
2092 // TMap * map = AliTPCcalibDB::GetGRPMap(52406);
2093 if (!map) return 0;
2094 AliDCSSensor * sensor = 0;
2095 TObject *osensor=0;
2096 osensor = ((*map)("fP2Pressure"));
2097 sensor =dynamic_cast<AliDCSSensor *>(osensor);
2098 //
2099 if (!sensor) return 0;
2100 //
2101 AliDCSSensor * sensor2 = new AliDCSSensor(*sensor);
2cd3a697 2102 osensor = ((*map)("fCavernPressure"));
e2914767 2103 TGraph * gr = new TGraph(2);
2104 gr->GetX()[0]= -100000.;
2105 gr->GetX()[1]= 1000000.;
2106 gr->GetY()[0]= atof(osensor->GetName());
2107 gr->GetY()[1]= atof(osensor->GetName());
2108 sensor2->SetGraph(gr);
2109 sensor2->SetFit(0);
2110
2111
2112 AliGRPObject *grpRun = new AliGRPObject;
2113 grpRun->ReadValuesFromMap(map);
2114 grpRun->SetCavernAtmosPressure(sensor2);
2cd3a697 2115 grpRun->SetCavernAtmosPressure(sensor2);
e2914767 2116 grpRun->SetSurfaceAtmosPressure(sensor);
2117 return grpRun;
2118}
2119
5312f439 2120Bool_t AliTPCcalibDB::CreateGUITree(Int_t run, const char* filename)
2121{
2122 //
2123 // Create a gui tree for run number 'run'
2124 //
e2914767 2125
5312f439 2126 if (!AliCDBManager::Instance()->GetDefaultStorage()){
2127 AliLog::Message(AliLog::kError, "Default Storage not set. Cannot create Calibration Tree!",
2128 MODULENAME(), "AliTPCcalibDB", FUNCTIONNAME(), __FILE__, __LINE__);
2129 return kFALSE;
2130 }
2131 //db instance
2132 AliTPCcalibDB *db=AliTPCcalibDB::Instance();
2133 // retrieve cal pad objects
2134 db->SetRun(run);
949d8707 2135 db->CreateGUITree(filename);
7fe54a9b 2136 return kTRUE;
949d8707 2137}
2138
2139Bool_t AliTPCcalibDB::CreateGUITree(const char* filename){
2140 //
2141 //
2142 //
2143 if (!AliCDBManager::Instance()->GetDefaultStorage()){
2144 AliError("Default Storage not set. Cannot create calibration Tree!");
2145 return kFALSE;
2146 }
56ce896d 2147 UpdateNonRec(); // load all infromation now
2148
5312f439 2149 AliTPCPreprocessorOnline prep;
2150 //noise and pedestals
949d8707 2151 if (GetPedestals()) prep.AddComponent(new AliTPCCalPad(*(GetPedestals())));
2152 if (GetPadNoise() ) prep.AddComponent(new AliTPCCalPad(*(GetPadNoise())));
5312f439 2153 //pulser data
949d8707 2154 if (GetPulserTmean()) prep.AddComponent(new AliTPCCalPad(*(GetPulserTmean())));
2155 if (GetPulserTrms() ) prep.AddComponent(new AliTPCCalPad(*(GetPulserTrms())));
2156 if (GetPulserQmean()) prep.AddComponent(new AliTPCCalPad(*(GetPulserQmean())));
5312f439 2157 //CE data
949d8707 2158 if (GetCETmean()) prep.AddComponent(new AliTPCCalPad(*(GetCETmean())));
2159 if (GetCETrms() ) prep.AddComponent(new AliTPCCalPad(*(GetCETrms())));
2160 if (GetCEQmean()) prep.AddComponent(new AliTPCCalPad(*(GetCEQmean())));
5312f439 2161 //Altro data
949d8707 2162 if (GetALTROAcqStart() ) prep.AddComponent(new AliTPCCalPad(*(GetALTROAcqStart() )));
2163 if (GetALTROZsThr() ) prep.AddComponent(new AliTPCCalPad(*(GetALTROZsThr() )));
2164 if (GetALTROFPED() ) prep.AddComponent(new AliTPCCalPad(*(GetALTROFPED() )));
2165 if (GetALTROAcqStop() ) prep.AddComponent(new AliTPCCalPad(*(GetALTROAcqStop() )));
2166 if (GetALTROMasked() ) prep.AddComponent(new AliTPCCalPad(*(GetALTROMasked() )));
2167 //QA
2168 AliTPCdataQA *dataQA=GetDataQA();
2169 if (dataQA) {
2170 if (dataQA->GetNLocalMaxima())
2171 prep.AddComponent(new AliTPCCalPad(*(dataQA->GetNLocalMaxima())));
2172 if (dataQA->GetMaxCharge())
2173 prep.AddComponent(new AliTPCCalPad(*(dataQA->GetMaxCharge())));
2174 if (dataQA->GetMeanCharge())
2175 prep.AddComponent(new AliTPCCalPad(*(dataQA->GetMeanCharge())));
2176 if (dataQA->GetNoThreshold())
2177 prep.AddComponent(new AliTPCCalPad(*(dataQA->GetNoThreshold())));
2178 if (dataQA->GetNTimeBins())
2179 prep.AddComponent(new AliTPCCalPad(*(dataQA->GetNTimeBins())));
2180 if (dataQA->GetNPads())
2181 prep.AddComponent(new AliTPCCalPad(*(dataQA->GetNPads())));
2182 if (dataQA->GetTimePosition())
2183 prep.AddComponent(new AliTPCCalPad(*(dataQA->GetTimePosition())));
2184 }
2185
5312f439 2186 //
2187 TString file(filename);
2b4c6ff5 2188 if (file.IsNull()) file=Form("guiTreeRun_%i.root",fRun);
5312f439 2189 prep.DumpToFile(file.Data());
2190 return kTRUE;
2191}
e2914767 2192
7390f655 2193Bool_t AliTPCcalibDB::CreateRefFile(Int_t run, const char* filename)
2194{
2195 //
2196 // Create a gui tree for run number 'run'
2197 //
2198
2199 if (!AliCDBManager::Instance()->GetDefaultStorage()){
2200 AliLog::Message(AliLog::kError, "Default Storage not set. Cannot create Calibration Tree!",
2201 MODULENAME(), "AliTPCcalibDB", FUNCTIONNAME(), __FILE__, __LINE__);
2202 return kFALSE;
2203 }
2204 TString file(filename);
2205 if (file.IsNull()) file=Form("RefCalPads_%d.root",run);
2206 TDirectory *currDir=gDirectory;
2207 //db instance
2208 AliTPCcalibDB *db=AliTPCcalibDB::Instance();
2209 // retrieve cal pad objects
2210 db->SetRun(run);
2211 //open file
2212 TFile f(file.Data(),"recreate");
2213 //noise and pedestals
2214 db->GetPedestals()->Write("Pedestals");
2215 db->GetPadNoise()->Write("PadNoise");
2216 //pulser data
2217 db->GetPulserTmean()->Write("PulserTmean");
2218 db->GetPulserTrms()->Write("PulserTrms");
2219 db->GetPulserQmean()->Write("PulserQmean");
2220 //CE data
2221 db->GetCETmean()->Write("CETmean");
2222 db->GetCETrms()->Write("CETrms");
2223 db->GetCEQmean()->Write("CEQmean");
2224 //Altro data
2225 db->GetALTROAcqStart() ->Write("ALTROAcqStart");
2226 db->GetALTROZsThr() ->Write("ALTROZsThr");
2227 db->GetALTROFPED() ->Write("ALTROFPED");
2228 db->GetALTROAcqStop() ->Write("ALTROAcqStop");
2229 db->GetALTROMasked() ->Write("ALTROMasked");
2230 //
2231 f.Close();
2232 currDir->cd();
2233 return kTRUE;
2234}
17c90083 2235
2236
2237
817766d5 2238Double_t AliTPCcalibDB::GetVDriftCorrectionTime(Int_t timeStamp, Int_t run, Int_t /*side*/, Int_t mode){
17c90083 2239 //
2240 // Get time dependent drift velocity correction
2241 // multiplication factor vd = vdnom *(1+vdriftcorr)
2242 // Arguments:
2243 // mode determines the algorith how to combine the Laser Track, LaserCE and physics tracks
2244 // timestamp - timestamp
2245 // run - run number
2246 // side - the drift velocity per side (possible for laser and CE)
2247 //
2248 // Notice - Extrapolation outside of calibration range - using constant function
2249 //
b7c5eb40 2250 Double_t result=0;
1e722a63 2251 // mode 1 automatic mode - according to the distance to the valid calibration
2252 // -
cc65e4f5 2253 Double_t deltaP=0, driftP=0, wP = 0.;
2254 Double_t deltaITS=0,driftITS=0, wITS= 0.;
2255 Double_t deltaLT=0, driftLT=0, wLT = 0.;
2256 Double_t deltaCE=0, driftCE=0, wCE = 0.;
1e722a63 2257 driftP = fDButil->GetVDriftTPC(deltaP,run,timeStamp);
cc65e4f5 2258 driftITS= fDButil->GetVDriftTPCITS(deltaITS,run,timeStamp);
1e722a63 2259 driftCE = fDButil->GetVDriftTPCCE(deltaCE, run,timeStamp,36000,2);
2260 driftLT = fDButil->GetVDriftTPCLaserTracks(deltaLT,run,timeStamp,36000,2);
cc65e4f5 2261 deltaITS = TMath::Abs(deltaITS);
1e722a63 2262 deltaP = TMath::Abs(deltaP);
2263 deltaLT = TMath::Abs(deltaLT);
2264 deltaCE = TMath::Abs(deltaCE);
2265 if (mode==1) {
cc65e4f5 2266 const Double_t kEpsilon=0.00000000001;
2267 const Double_t kdeltaT=360.; // 10 minutes
a52d8b6f 2268 if(TMath::Abs(deltaITS) < 12*kdeltaT) {
5647625c 2269 result = driftITS;
2270 } else {
cc65e4f5 2271 wITS = 64.*kdeltaT/(deltaITS +kdeltaT);
2272 wLT = 16.*kdeltaT/(deltaLT +kdeltaT);
2273 wP = 0. *kdeltaT/(deltaP +kdeltaT);
2274 wCE = 1. *kdeltaT/(deltaCE +kdeltaT);
2275 //
2276 //
2277 if (TMath::Abs(driftP)<kEpsilon) wP=0; // invalid calibration
2278 if (TMath::Abs(driftITS)<kEpsilon)wITS=0; // invalid calibration
2279 if (TMath::Abs(driftLT)<kEpsilon) wLT=0; // invalid calibration
1e722a63 2280 if (TMath::Abs(driftCE)<kEpsilon) wCE=0; // invalid calibration
cc65e4f5 2281 if (wP+wITS+wLT+wCE<kEpsilon) return 0;
2282 result = (driftP*wP+driftITS*wITS+driftLT*wLT+driftCE*wCE)/(wP+wITS+wLT+wCE);
5647625c 2283 }
2284
2285
43a74775 2286 }
817766d5 2287
43a74775 2288 return result;
17c90083 2289}
2290
817766d5 2291Double_t AliTPCcalibDB::GetTime0CorrectionTime(Int_t timeStamp, Int_t run, Int_t /*side*/, Int_t mode){
17c90083 2292 //
43a74775 2293 // Get time dependent time 0 (trigger delay in cm) correction
17c90083 2294 // additive correction time0 = time0+ GetTime0CorrectionTime
2295 // Value etracted combining the vdrift correction using laser tracks and CE and the physics track matchin
2296 // Arguments:
2297 // mode determines the algorith how to combine the Laser Track and physics tracks
2298 // timestamp - timestamp
2299 // run - run number
2300 // side - the drift velocity per side (possible for laser and CE)
2301 //
2302 // Notice - Extrapolation outside of calibration range - using constant function
2303 //
817766d5 2304 Double_t result=0;
cc65e4f5 2305 if (mode==2) {
2306 // TPC-TPC mode
2307 result=fDButil->GetTriggerOffsetTPC(run,timeStamp);
2308 result *=fParam->GetZLength();
2309 }
2310 if (mode==1){
2311 // TPC-ITS mode
2312 Double_t dist=0;
86c39d37 2313 result= -fDButil->GetTime0TPCITS(dist, run, timeStamp)*fParam->GetDriftV()/1000000.;
cc65e4f5 2314 }
817766d5 2315 return result;
43a74775 2316
17c90083 2317}
2318
2319
2320
2321
43a74775 2322Double_t AliTPCcalibDB::GetVDriftCorrectionGy(Int_t timeStamp, Int_t run, Int_t side, Int_t /*mode*/){
17c90083 2323 //
2324 // Get global y correction drift velocity correction factor
2325 // additive factor vd = vdnom*(1+GetVDriftCorrectionGy *gy)
5647625c 2326 // Value etracted combining the vdrift correction using laser tracks and CE or TPC-ITS
17c90083 2327 // Arguments:
5647625c 2328 // mode determines the algorith how to combine the Laser Track, LaserCE or TPC-ITS
17c90083 2329 // timestamp - timestamp
2330 // run - run number
2331 // side - the drift velocity gy correction per side (CE and Laser tracks)
2332 //
2333 // Notice - Extrapolation outside of calibration range - using constant function
a8f8b6a1 2334 //
2335 if (run<=0 && fTransform) run = fTransform->GetCurrentRunNumber();
2336 UpdateRunInformations(run,kFALSE);
43a74775 2337 TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
4429bfef 2338 if (!array) return 0;
5647625c 2339 Double_t result=0;
2340
2341 // use TPC-ITS if present
2342 TGraphErrors *gr= (TGraphErrors*)array->FindObject("ALIGN_ITSB_TPC_VDGY");
3760239f 2343 if (!gr) gr = (TGraphErrors*)array->FindObject("ALIGN_TOFB_TPC_VDGY");
5647625c 2344 if(gr) {
0fc78dbd 2345 result = AliTPCcalibDButil::EvalGraphConst(gr,timeStamp);
5647625c 2346
2347 // transform from [(cm/mus)/ m] to [1/cm]
2348 result /= (fParam->GetDriftV()/1000000.);
2349 result /= 100.;
2350
2351 //printf("result %e \n", result);
2352 return result;
2353 }
2354
2355 // use laser if ITS-TPC not present
43a74775 2356 TGraphErrors *laserA= (TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_A");
2357 TGraphErrors *laserC= (TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_C");
2358
43a74775 2359 if (laserA && laserC){
2360 result= (laserA->Eval(timeStamp)+laserC->Eval(timeStamp))*0.5;
2361 }
2362 if (laserA && side==0){
2363 result = (laserA->Eval(timeStamp));
2364 }
2365 if (laserC &&side==1){
2366 result = (laserC->Eval(timeStamp));
2367 }
5647625c 2368 //printf("laser result %e \n", -result/250.);
2369
43a74775 2370 return -result/250.; //normalized before
17c90083 2371}
949d8707 2372
e185e9d8 2373
2374Double_t AliTPCcalibDB::GetVDriftCorrectionDeltaZ(Int_t /*timeStamp*/, Int_t run, Int_t /*side*/, Int_t /*mode*/){
2375 //
2376 // Get deltaZ run/by/run correction - as fitted together with drift velocity
2377 // Value extracted form the TPC-ITS, mean value is used
2378
2379 // Arguments:
2380 // mode determines the algorith how to combine the Laser Track, LaserCE or TPC-ITS
00e32b66 2381 // timestamp - not used
e185e9d8 2382 // run - run number
00e32b66 2383 // side - common for boith sides
e185e9d8 2384 //
2385 if (run<=0 && fTransform) run = fTransform->GetCurrentRunNumber();
2386 UpdateRunInformations(run,kFALSE);
2387 TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
2388 if (!array) return 0;
2389 Double_t result=0;
2390
2391 // use TPC-ITS if present
2392 TGraphErrors *gr= (TGraphErrors*)array->FindObject("ALIGN_ITSB_TPC_DELTAZ");
2393 if(gr) {
2394 result = TMath::Mean(gr->GetN(), gr->GetY());
2395 }
2396 return result;
2397}
2398
2399
2400
2401
72b94ffb 2402AliTPCCalPad* AliTPCcalibDB::MakeDeadMap(Double_t notInMap, const char* nameMappingFile) {
f6b5fa33 2403//
2404// Read list of active DDLs from OCDB entry
2405// Generate and return AliTPCCalPad containing 1 for all pads in active DDLs,
2406// 0 for all pads in non-active DDLs.
72b94ffb 2407// For DDLs with missing status information (no DCS input point to Shuttle),
2408// the value of the AliTPCCalPad entry is determined by the parameter
2409// notInMap (default value 1)
f6b5fa33 2410//
2411 char chinfo[1000];
2412
2413 TFile *fileMapping = new TFile(nameMappingFile, "read");
2414 AliTPCmapper *mapping = (AliTPCmapper*) fileMapping->Get("tpcMapping");
2415 if (!mapping) {
4aa37f93 2416 snprintf(chinfo,1000,"Failed to get mapping object from %s. ...\n", nameMappingFile);
f6b5fa33 2417 AliError (chinfo);
2418 return 0;
2419 }
2420
2421 AliTPCCalPad *deadMap = new AliTPCCalPad("deadMap","deadMap");
2422 if (!deadMap) {
2423 AliError("Failed to allocate dead map AliTPCCalPad");
2424 return 0;
2425 }
2426
2427 /// get list of active DDLs from OCDB entry
2428 Int_t idDDL=0;
2429 if (!fALTROConfigData ) {
2430 AliError("No ALTRO config OCDB entry available");
2431 return 0;
2432 }
2433 TMap *activeDDL = (TMap*)fALTROConfigData->FindObject("DDLArray");
2434 TObjString *ddlArray=0;
2435 if (activeDDL) {
2436 ddlArray = (TObjString*)activeDDL->GetValue("DDLArray");
2437 if (!ddlArray) {
2438 AliError("Empty list of active DDLs in OCDB entry");
2439 return 0;
2440 }
2441 } else {
2442 AliError("List of active DDLs not available in OCDB entry");
2443 return 0;
2444 }
2445 TString arrDDL=ddlArray->GetString();
2446 Int_t offset = mapping->GetTpcDdlOffset();
2447 Double_t active;
2448 for (Int_t i=0; i<mapping->GetNumDdl(); i++) {
2449 idDDL= i+offset;
d150d64f 2450 if (idDDL<0) continue;
f6b5fa33 2451 Int_t patch = mapping->GetPatchFromEquipmentID(idDDL);
9f98a33d 2452 if (patch<0) continue;
f6b5fa33 2453 Int_t roc=mapping->GetRocFromEquipmentID(idDDL);
55d90f9a 2454 if (roc<0) continue;
f6b5fa33 2455 AliTPCCalROC *calRoc=deadMap->GetCalROC(roc);
2456 if (calRoc) {
2457 for ( Int_t branch = 0; branch < 2; branch++ ) {
2458 for ( Int_t fec = 0; fec < mapping->GetNfec(patch, branch); fec++ ) {
2459 for ( Int_t altro = 0; altro < 8; altro++ ) {
2460 for ( Int_t channel = 0; channel < 16; channel++ ) {
2461 Int_t hwadd = mapping->CodeHWAddress(branch, fec, altro, channel);
2462 Int_t row = mapping->GetPadRow(patch, hwadd); // row in a ROC (IROC or OROC)
2463// Int_t globalrow = mapping.GetGlobalPadRow(patch, hwadd); // row in full sector (IROC plus OROC)
2464 Int_t pad = mapping->GetPad(patch, hwadd);
72b94ffb 2465 if (!TString(arrDDL[i]).IsDigit()) {
2466 active = notInMap;
2467 } else {
2468 active=TString(arrDDL[i]).Atof();
2469 }
f6b5fa33 2470 calRoc->SetValue(row,pad,active);
2471 } // end channel for loop
2472 } // end altro for loop
2473 } // end fec for loop
2474 } // end branch for loop
2475 } // valid calROC
2476 } // end loop on active DDLs
2477 return deadMap;
2478}
f14d21a1 2479
2480
0b736a46 2481
2482AliTPCCorrection * AliTPCcalibDB::GetTPCComposedCorrection(Float_t field) const{
2483 //
2484 // GetComposed correction for given field setting
3f3549a3 2485 // If not specific correction for field used return correction for all field
2486 // - Complication needed to gaurantee OCDB back compatibility
2487 // - Not neeeded for the new space point correction
0b736a46 2488 if (!fComposedCorrectionArray) return 0;
3f3549a3 2489 if (field>0.1 && fComposedCorrectionArray->At(1)) {
2490 return (AliTPCCorrection *)fComposedCorrectionArray->At(1);
2491 }
2492 if (field<-0.1 &&fComposedCorrectionArray->At(2)) {
2493 return (AliTPCCorrection *)fComposedCorrectionArray->At(2);
2494 }
0b736a46 2495 return (AliTPCCorrection *)fComposedCorrectionArray->At(0);
2496
2497}
2498
3f3549a3 2499
2500AliTPCCorrection * AliTPCcalibDB::GetTPCComposedCorrectionDelta() const{
2501 //
2502 // GetComposedCorrection delta
2503 // Delta is time dependent - taken form the CalibTime OCDB entry
2504 //
2505 if (!fComposedCorrectionArray) return 0;
a8ef8a9c 2506 if (fRun<0) return 0;
2b4c6ff5 2507 if (fDriftCorrectionArray.GetValue(Form("%i",fRun))==0) return 0;
012c4694 2508 if (fComposedCorrectionArray->GetEntriesFast()<=4) {
2509 fComposedCorrectionArray->Expand(5);
2b4c6ff5 2510 TObjArray * timeArray =(TObjArray*)(fDriftCorrectionArray.GetValue(Form("%i",fRun)));
a8ef8a9c 2511 AliTPCCorrection * correctionTime = (AliTPCCorrection *)timeArray->FindObject("FitCorrectionTime");
2512 if (correctionTime){
2513 correctionTime->Init();
2514 fComposedCorrectionArray->AddAt(correctionTime,4); //add time dependent c
2515 }
2516 }
3f3549a3 2517 return (AliTPCCorrection *)fComposedCorrectionArray->At(4); //
2518}
2519
00e32b66 2520Double_t AliTPCcalibDB::GetGainCorrectionHVandPT(Int_t timeStamp, Int_t run, Int_t sector, Int_t deltaCache, Int_t mode){
e185e9d8 2521 //
2522 // Correction for changes of gain caused by change of the HV and by relative change of the gas density
2523 // Function is slow some kind of caching needed
2524 // Cache implemented using the static TVectorD
2525 //
2526 // Input paremeters:
2527 // deltaCache - maximal time differnce above which the cache is recaclulated
00e32b66 2528 // mode - mode==0 by default return combined correction
2529 // actual HV and Pt correction has to be present in the run calibration otherwise it is ignored.
2530 //
2531 // mode==1 return combined correction ( important for calibration pass)
2532 //
2533 // mode==2 return HV correction
2534 // mode==3 return P/T correction
2535 // Usage in the simulation/reconstruction
2536 // MC: Qcorr = Qorig*GetGainCorrectionHVandPT ( in AliTPC.cxx )
2537 // Rec: dEdx = dEdx/GetGainCorrectionHVandPT ( in aliTPCseed.cxx )
2538 //
3d674021 2539 static Float_t gGainCorrection[72];
2540 static Float_t gGainCorrectionPT[72];
2541 static Float_t gGainCorrectionHV[72];
00e32b66 2542 static Int_t gTimeStamp=0;
2543 static Bool_t hasTimeDependent=kFALSE;
e185e9d8 2544 if ( TMath::Abs(timeStamp-gTimeStamp)> deltaCache){
2545 //
2546 TGraphErrors * graphGHV = 0;
2547 TGraphErrors * graphGPT = 0;
2548 TObjArray *timeGainSplines = GetTimeGainSplinesRun(run);
00e32b66 2549 if (timeGainSplines){
2550 graphGHV = (TGraphErrors*) timeGainSplines->FindObject("GainSlopesHV");
2551 graphGPT = (TGraphErrors*) timeGainSplines->FindObject("GainSlopesPT");
2552 if (graphGHV) hasTimeDependent=kTRUE;
2553 }
e185e9d8 2554 if (!graphGHV) graphGHV = fParam->GetGainSlopesHV();
2555 if (!graphGPT) graphGPT = fParam->GetGainSlopesPT();
2556 //
2557 for (Int_t isec=0; isec<72; isec++){
2558 Double_t deltaHV= GetChamberHighVoltage(run,isec, timeStamp) - fParam->GetNominalVoltage(isec);
2559 Double_t deltaGHV=0;
2560 Double_t deltaGPT=0;
2561 if (graphGHV) deltaGHV = graphGHV->GetY()[isec]*deltaHV;
2562 if (graphGPT) deltaGPT = graphGPT->GetY()[isec]*GetPTRelative(timeStamp,run,0);
00e32b66 2563 gGainCorrection[isec]=(1.+deltaGHV)*(1.+deltaGPT);
3d674021 2564 gGainCorrectionPT[isec]=1+deltaGPT;
2565 gGainCorrectionHV[isec]=1+deltaGHV;
e185e9d8 2566 }
2567 gTimeStamp=timeStamp;
2568 }
00e32b66 2569 if (mode==0){
2570 if (hasTimeDependent) return gGainCorrection[sector];
3d674021 2571 if (!hasTimeDependent) return 1;
00e32b66 2572 }
2573 if (mode==1) return gGainCorrection[sector];
2574 if (mode==2) return gGainCorrectionPT[sector];
2575 if (mode==3) return gGainCorrectionHV[sector];
3d674021 2576 return 1;
e185e9d8 2577}