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