]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TPC/AliTPCcalibDB.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
updated
[u/mrichter/AliRoot.git] / TPC / AliTPCcalibDB.cxx
CommitLineData
c5bbaa2c 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16
17///////////////////////////////////////////////////////////////////////////////
18// //
19// Class providing the calibration parameters by accessing the CDB //
20// //
21// Request an instance with AliTPCcalibDB::Instance() //
22// If a new event is processed set the event number with SetRun //
1ac191a6 23// Then request the calibration data ////
f5344549 24//
25//
1ac191a6 26// Calibration data:
8cd9634d 27// 0.) Altro mapping
28// Simulation - not yet
29// Reconstruction - AliTPCclustererMI::Digits2Clusters(AliRawReader* rawReader)
30//
1ac191a6 31// 1.) pad by pad calibration - AliTPCCalPad
f5344549 32//
1ac191a6 33// a.) fPadGainFactor
34// Simulation: AliTPCDigitizer::ExecFast - Multiply by gain
35// Reconstruction : AliTPCclustererMI::Digits2Clusters - Divide by gain
f5344549 36//
1ac191a6 37// b.) fPadNoise -
38// Simulation: AliTPCDigitizer::ExecFast
39// Reconstruction: AliTPCclustererMI::FindClusters(AliTPCCalROC * noiseROC)
8cd9634d 40// Noise depending cut on clusters charge (n sigma)
f5344549 41// c.) fPedestal:
42// Simulation: Not used yet - To be impleneted - Rounding to the nearest integer
43// Reconstruction: Used in AliTPCclustererMI::Digits2Clusters(AliRawReader* rawReader)
44// if data taken without zero suppression
45// Currently switch in fRecoParam->GetCalcPedestal();
46//
47// d.) fPadTime0
48// Simulation: applied in the AliTPC::MakeSector - adding offset
49// Reconstruction: AliTPCTransform::Transform() - remove offset
50// AliTPCTransform::Transform() - to be called
51// in AliTPCtracker::Transform()
8cd9634d 52//
53//
54// 2.) Space points transformation:
55//
56// a.) General coordinate tranformation - AliTPCtransform (see $ALICE_ROOT/TPC/AliTPCtransform.cxx)
57// Created on fly - use the other calibration components
58// Unisochronity - (substract time0 - pad by pad)
59// Drift velocity - Currently common drift velocity - functionality of AliTPCParam
60// ExB effect
61// Simulation - Not used directly (the effects are applied one by one (see AliTPC::MakeSector)
62// Reconstruction -
63// AliTPCclustererMI::AddCluster
64// AliTPCtrackerMI::Transform
65// b.) ExB effect calibration -
66// classes (base class AliTPCExB, implementation- AliTPCExBExact.h AliTPCExBFirst.h)
67// a.a) Simulation: applied in the AliTPC::MakeSector -
68// calib->GetExB()->CorrectInverse(dxyz0,dxyz1);
69// a.b) Reconstruction -
70//
71// in AliTPCtransform::Correct() - called calib->GetExB()->Correct(dxyz0,dxyz1)
72//
96305e49 73// 3.) cluster error, shape and Q parameterization
74//
75//
8cd9634d 76//
c5bbaa2c 77///////////////////////////////////////////////////////////////////////////////
78
418bbcaf 79#include <iostream>
80#include <fstream>
81
c5bbaa2c 82
83#include <AliCDBManager.h>
c5bbaa2c 84#include <AliCDBEntry.h>
85#include <AliLog.h>
86
87#include "AliTPCcalibDB.h"
d6834f5f 88#include "AliTPCAltroMapping.h"
418bbcaf 89#include "AliTPCExB.h"
c5bbaa2c 90
91#include "AliTPCCalROC.h"
92#include "AliTPCCalPad.h"
54472e4f 93#include "AliTPCSensorTempArray.h"
418bbcaf 94#include "AliTPCTransform.h"
d6834f5f 95
418bbcaf 96class AliCDBStorage;
97class AliTPCCalDet;
86df2b3a 98//
99//
100
86df2b3a 101#include "TFile.h"
102#include "TKey.h"
103
104#include "TObjArray.h"
105#include "TObjString.h"
106#include "TString.h"
107#include "AliTPCCalPad.h"
0fe7645c 108#include "AliTPCCalibPulser.h"
86df2b3a 109#include "AliTPCCalibPedestal.h"
110#include "AliTPCCalibCE.h"
111
112
113
114
c5bbaa2c 115
116ClassImp(AliTPCcalibDB)
117
118AliTPCcalibDB* AliTPCcalibDB::fgInstance = 0;
119Bool_t AliTPCcalibDB::fgTerminated = kFALSE;
120
121
122//_ singleton implementation __________________________________________________
123AliTPCcalibDB* AliTPCcalibDB::Instance()
124{
125 //
126 // Singleton implementation
127 // Returns an instance of this class, it is created if neccessary
128 //
129
130 if (fgTerminated != kFALSE)
131 return 0;
132
133 if (fgInstance == 0)
134 fgInstance = new AliTPCcalibDB();
135
136 return fgInstance;
137}
138
139void AliTPCcalibDB::Terminate()
140{
141 //
142 // Singleton implementation
143 // Deletes the instance of this class and sets the terminated flag, instances cannot be requested anymore
144 // This function can be called several times.
145 //
146
147 fgTerminated = kTRUE;
148
149 if (fgInstance != 0)
150 {
151 delete fgInstance;
152 fgInstance = 0;
153 }
154}
155
156//_____________________________________________________________________________
e4dce695 157AliTPCcalibDB::AliTPCcalibDB():
9389f9a4 158 TObject(),
e4dce695 159 fRun(-1),
f5344549 160 fTransform(0),
481f877b 161 fExB(0),
e4dce695 162 fPadGainFactor(0),
163 fPadTime0(0),
e4dce695 164 fPadNoise(0),
165 fPedestals(0),
166 fTemperature(0),
d6834f5f 167 fMapping(0),
7a9e557b 168 fRecoParamArray(0),
96305e49 169 fParam(0),
170 fClusterParam(0)
c5bbaa2c 171{
172 //
173 // constructor
174 //
54472e4f 175 //
c5bbaa2c 176 Update(); // temporary
177}
178
9389f9a4 179AliTPCcalibDB::AliTPCcalibDB(const AliTPCcalibDB& ):
180 TObject(),
181 fRun(-1),
182 fTransform(0),
183 fExB(0),
184 fPadGainFactor(0),
185 fPadTime0(0),
186 fPadNoise(0),
187 fPedestals(0),
188 fTemperature(0),
189 fMapping(0),
190 fRecoParamArray(0),
191 fParam(0),
192 fClusterParam(0)
193
194{
195 //
196 // Copy constructor invalid -- singleton implementation
197 //
198 Error("copy constructor","invalid -- singleton implementation");
199}
200
201AliTPCcalibDB& AliTPCcalibDB::operator= (const AliTPCcalibDB& )
202{
203//
204// Singleton implementation - no assignment operator
205//
206 Error("operator =", "assignment operator not implemented");
207 return *this;
208}
209
210
211
c5bbaa2c 212//_____________________________________________________________________________
213AliTPCcalibDB::~AliTPCcalibDB()
214{
215 //
216 // destructor
217 //
68751c2c 218
219 // don't delete anything, CDB cache is active!
220 //if (fPadGainFactor) delete fPadGainFactor;
221 //if (fPadTime0) delete fPadTime0;
68751c2c 222 //if (fPadNoise) delete fPadNoise;
c5bbaa2c 223}
224
225
226//_____________________________________________________________________________
227AliCDBEntry* AliTPCcalibDB::GetCDBEntry(const char* cdbPath)
228{
229 //
230 // Retrieves an entry with path <cdbPath> from the CDB.
231 //
232 char chinfo[1000];
233
68751c2c 234 AliCDBEntry* entry = AliCDBManager::Instance()->Get(cdbPath, fRun);
c5bbaa2c 235 if (!entry)
236 {
237 sprintf(chinfo,"AliTPCcalibDB: Failed to get entry:\t%s ", cdbPath);
238 AliError(chinfo);
239 return 0;
240 }
241 return entry;
242}
243
244
245//_____________________________________________________________________________
246void AliTPCcalibDB::SetRun(Long64_t run)
247{
248 //
249 // Sets current run number. Calibration data is read from the corresponding file.
250 //
251 if (fRun == run)
252 return;
253 fRun = run;
254 Update();
255}
256
257
258
259void AliTPCcalibDB::Update(){
260 //
261 AliCDBEntry * entry=0;
68751c2c 262
263 Bool_t cdbCache = AliCDBManager::Instance()->GetCacheFlag(); // save cache status
264 AliCDBManager::Instance()->SetCacheFlag(kTRUE); // activate CDB cache
265
c5bbaa2c 266 //
267 entry = GetCDBEntry("TPC/Calib/PadGainFactor");
268 if (entry){
68751c2c 269 //if (fPadGainFactor) delete fPadGainFactor;
c5bbaa2c 270 entry->SetOwner(kTRUE);
271 fPadGainFactor = (AliTPCCalPad*)entry->GetObject();
272 }
273 //
274 entry = GetCDBEntry("TPC/Calib/PadTime0");
275 if (entry){
68751c2c 276 //if (fPadTime0) delete fPadTime0;
c5bbaa2c 277 entry->SetOwner(kTRUE);
278 fPadTime0 = (AliTPCCalPad*)entry->GetObject();
279 }
280 //
c5bbaa2c 281 //
282 entry = GetCDBEntry("TPC/Calib/PadNoise");
283 if (entry){
68751c2c 284 //if (fPadNoise) delete fPadNoise;
c5bbaa2c 285 entry->SetOwner(kTRUE);
286 fPadNoise = (AliTPCCalPad*)entry->GetObject();
287 }
8477f500 288
289 entry = GetCDBEntry("TPC/Calib/Pedestals");
290 if (entry){
291 //if (fPedestals) delete fPedestals;
292 entry->SetOwner(kTRUE);
293 fPedestals = (AliTPCCalPad*)entry->GetObject();
294 }
295
54472e4f 296 entry = GetCDBEntry("TPC/Calib/Temperature");
297 if (entry){
298 //if (fTemperature) delete fTemperature;
299 entry->SetOwner(kTRUE);
300 fTemperature = (AliTPCSensorTempArray*)entry->GetObject();
301 }
302
7a9e557b 303
304 entry = GetCDBEntry("TPC/Calib/RecoParam");
305 if (entry){
306 entry->SetOwner(kTRUE);
307 fRecoParamArray = (TObjArray*)(entry->GetObject());
308 }
309
310
8477f500 311 entry = GetCDBEntry("TPC/Calib/Parameters");
312 if (entry){
54472e4f 313 //if (fPadNoise) delete fPadNoise;
8477f500 314 entry->SetOwner(kTRUE);
a778f7e3 315 fParam = (AliTPCParam*)(entry->GetObject()->Clone());
8477f500 316 }
317
96305e49 318 entry = GetCDBEntry("TPC/Calib/ClusterParam");
319 if (entry){
320 //if (fPadNoise) delete fPadNoise;
321 entry->SetOwner(kTRUE);
322 fClusterParam = (AliTPCClusterParam*)(entry->GetObject()->Clone());
323 }
324
d6834f5f 325 entry = GetCDBEntry("TPC/Calib/Mapping");
326 if (entry){
327 //if (fPadNoise) delete fPadNoise;
328 entry->SetOwner(kTRUE);
329 TObjArray * array = dynamic_cast<TObjArray*>(entry->GetObject());
330 if (array && array->GetEntriesFast()==6){
331 fMapping = new AliTPCAltroMapping*[6];
332 for (Int_t i=0; i<6; i++){
333 fMapping[i] = dynamic_cast<AliTPCAltroMapping*>(array->At(i));
334 }
335 }
336 }
337
338
339
481f877b 340 entry = GetCDBEntry("TPC/Calib/ExB");
341 if (entry) {
342 entry->SetOwner(kTRUE);
343 fExB=dynamic_cast<AliTPCExB*>(entry->GetObject()->Clone());
344 }
345
f5344549 346 if (!fTransform) {
347 fTransform=new AliTPCTransform();
348 }
8477f500 349
c5bbaa2c 350 //
68751c2c 351 AliCDBManager::Instance()->SetCacheFlag(cdbCache); // reset original CDB cache
352
c5bbaa2c 353}
e4dce695 354
86df2b3a 355
356
357void AliTPCcalibDB::CreateObjectList(const Char_t *filename, TObjArray *calibObjects)
358{
418bbcaf 359//
360// Create calibration objects and read contents from OCDB
361//
86df2b3a 362 if ( calibObjects == 0x0 ) return;
363 ifstream in;
364 in.open(filename);
365 if ( !in.is_open() ){
366 fprintf(stderr,"Error: cannot open list file '%s'", filename);
367 return;
368 }
369
370 AliTPCCalPad *calPad=0x0;
371
372 TString sFile;
373 sFile.ReadFile(in);
374 in.close();
375
376 TObjArray *arrFileLine = sFile.Tokenize("\n");
377
378 TIter nextLine(arrFileLine);
379
380 TObjString *sObjLine=0x0;
2c632057 381 while ( (sObjLine = (TObjString*)nextLine()) ){
86df2b3a 382 TString sLine(sObjLine->GetString());
383
384 TObjArray *arrNextCol = sLine.Tokenize("\t");
385
386 TObjString *sObjType = (TObjString*)(arrNextCol->At(0));
387 TObjString *sObjFileName = (TObjString*)(arrNextCol->At(1));
388
389 if ( !sObjType || ! sObjFileName ) continue;
390 TString sType(sObjType->GetString());
391 TString sFileName(sObjFileName->GetString());
392 printf("%s\t%s\n",sType.Data(),sFileName.Data());
393
394 TFile *fIn = TFile::Open(sFileName);
395 if ( !fIn ){
396 fprintf(stderr,"File not found: '%s'", sFileName.Data());
397 continue;
398 }
399
400 if ( sType == "CE" ){
401 AliTPCCalibCE *ce = (AliTPCCalibCE*)fIn->Get("AliTPCCalibCE");
402
403 calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadT0());
404 calPad->SetNameTitle("CETmean","CETmean");
405 calibObjects->Add(calPad);
406
407 calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadQ());
408 calPad->SetNameTitle("CEQmean","CEQmean");
409 calibObjects->Add(calPad);
410
411 calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadRMS());
412 calPad->SetNameTitle("CETrms","CETrms");
413 calibObjects->Add(calPad);
414
415 } else if ( sType == "Pulser") {
0fe7645c 416 AliTPCCalibPulser *sig = (AliTPCCalibPulser*)fIn->Get("AliTPCCalibPulser");
86df2b3a 417
418 calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadT0());
419 calPad->SetNameTitle("PulserTmean","PulserTmean");
420 calibObjects->Add(calPad);
421
422 calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadQ());
423 calPad->SetNameTitle("PulserQmean","PulserQmean");
424 calibObjects->Add(calPad);
425
426 calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadRMS());
427 calPad->SetNameTitle("PulserTrms","PulserTrms");
428 calibObjects->Add(calPad);
429
430 } else if ( sType == "Pedestals") {
431 AliTPCCalibPedestal *ped = (AliTPCCalibPedestal*)fIn->Get("AliTPCCalibPedestal");
432
433 calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadPedestal());
434 calPad->SetNameTitle("Pedestals","Pedestals");
435 calibObjects->Add(calPad);
436
437 calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadRMS());
438 calPad->SetNameTitle("Noise","Noise");
439 calibObjects->Add(calPad);
440
441 } else {
442 fprintf(stderr,"Undefined Type: '%s'",sType.Data());
443
444 }
445 delete fIn;
446 }
447}
448
449
450
451void AliTPCcalibDB::MakeTree(const char * fileName, TObjArray * array, const char * mapFileName, AliTPCCalPad* outlierPad, Float_t ltmFraction) {
452 //
453 // Write a tree with all available information
418bbcaf 454 // if mapFileName is specified, the Map information are also written to the tree
86df2b3a 455 // pads specified in outlierPad are not used for calculating statistics
456 // - the same function as AliTPCCalPad::MakeTree -
457 //
458 AliTPCROC* tpcROCinstance = AliTPCROC::Instance();
459
460 TObjArray* mapIROCs = 0;
461 TObjArray* mapOROCs = 0;
462 TVectorF *mapIROCArray = 0;
463 TVectorF *mapOROCArray = 0;
464 Int_t mapEntries = 0;
465 TString* mapNames = 0;
466
467 if (mapFileName) {
468 TFile mapFile(mapFileName, "read");
469
470 TList* listOfROCs = mapFile.GetListOfKeys();
471 mapEntries = listOfROCs->GetEntries()/2;
472 mapIROCs = new TObjArray(mapEntries*2);
473 mapOROCs = new TObjArray(mapEntries*2);
474 mapIROCArray = new TVectorF[mapEntries];
475 mapOROCArray = new TVectorF[mapEntries];
476
477 mapNames = new TString[mapEntries];
478 for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
418bbcaf 479 TString nameROC(((TKey*)(listOfROCs->At(ivalue*2)))->GetName());
480 nameROC.Remove(nameROC.Length()-4, 4);
481 mapIROCs->AddAt((AliTPCCalROC*)mapFile.Get((nameROC + "IROC").Data()), ivalue);
482 mapOROCs->AddAt((AliTPCCalROC*)mapFile.Get((nameROC + "OROC").Data()), ivalue);
483 mapNames[ivalue].Append(nameROC);
86df2b3a 484 }
485
486 for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
487 mapIROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(0));
488 mapOROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(36));
489
490 for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(0); ichannel++)
491 (mapIROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapIROCs->At(ivalue)))->GetValue(ichannel);
492 for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(36); ichannel++)
493 (mapOROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapOROCs->At(ivalue)))->GetValue(ichannel);
494 }
495
496 } // if (mapFileName)
497
498 TTreeSRedirector cstream(fileName);
499 Int_t arrayEntries = array->GetEntries();
500
501 TString* names = new TString[arrayEntries];
502 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
503 names[ivalue].Append(((AliTPCCalPad*)array->At(ivalue))->GetName());
504
505 for (UInt_t isector = 0; isector < tpcROCinstance->GetNSectors(); isector++) {
506 //
507 // get statistic for given sector
508 //
509 TVectorF median(arrayEntries);
510 TVectorF mean(arrayEntries);
511 TVectorF rms(arrayEntries);
512 TVectorF ltm(arrayEntries);
513 TVectorF ltmrms(arrayEntries);
514 TVectorF medianWithOut(arrayEntries);
515 TVectorF meanWithOut(arrayEntries);
516 TVectorF rmsWithOut(arrayEntries);
517 TVectorF ltmWithOut(arrayEntries);
518 TVectorF ltmrmsWithOut(arrayEntries);
519
520 TVectorF *vectorArray = new TVectorF[arrayEntries];
521 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
522 vectorArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
523
524 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
525 AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
526 AliTPCCalROC* calROC = calPad->GetCalROC(isector);
527 AliTPCCalROC* outlierROC = 0;
528 if (outlierPad) outlierROC = outlierPad->GetCalROC(isector);
529 if (calROC) {
530 median[ivalue] = calROC->GetMedian();
531 mean[ivalue] = calROC->GetMean();
532 rms[ivalue] = calROC->GetRMS();
533 Double_t ltmrmsValue = 0;
534 ltm[ivalue] = calROC->GetLTM(&ltmrmsValue, ltmFraction);
535 ltmrms[ivalue] = ltmrmsValue;
536 if (outlierROC) {
537 medianWithOut[ivalue] = calROC->GetMedian(outlierROC);
538 meanWithOut[ivalue] = calROC->GetMean(outlierROC);
539 rmsWithOut[ivalue] = calROC->GetRMS(outlierROC);
540 ltmrmsValue = 0;
541 ltmWithOut[ivalue] = calROC->GetLTM(&ltmrmsValue, ltmFraction, outlierROC);
542 ltmrmsWithOut[ivalue] = ltmrmsValue;
543 }
544 }
545 else {
546 median[ivalue] = 0.;
547 mean[ivalue] = 0.;
548 rms[ivalue] = 0.;
549 ltm[ivalue] = 0.;
550 ltmrms[ivalue] = 0.;
551 medianWithOut[ivalue] = 0.;
552 meanWithOut[ivalue] = 0.;
553 rmsWithOut[ivalue] = 0.;
554 ltmWithOut[ivalue] = 0.;
555 ltmrmsWithOut[ivalue] = 0.;
556 }
557 }
558
559 //
560 // fill vectors of variable per pad
561 //
562 TVectorF *posArray = new TVectorF[8];
563 for (Int_t ivalue = 0; ivalue < 8; ivalue++)
564 posArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
565
566 Float_t posG[3] = {0};
567 Float_t posL[3] = {0};
568 Int_t ichannel = 0;
569 for (UInt_t irow = 0; irow < tpcROCinstance->GetNRows(isector); irow++) {
570 for (UInt_t ipad = 0; ipad < tpcROCinstance->GetNPads(isector, irow); ipad++) {
571 tpcROCinstance->GetPositionLocal(isector, irow, ipad, posL);
572 tpcROCinstance->GetPositionGlobal(isector, irow, ipad, posG);
573 posArray[0][ichannel] = irow;
574 posArray[1][ichannel] = ipad;
575 posArray[2][ichannel] = posL[0];
576 posArray[3][ichannel] = posL[1];
577 posArray[4][ichannel] = posG[0];
578 posArray[5][ichannel] = posG[1];
579 posArray[6][ichannel] = (Int_t)(ipad - (Double_t)(tpcROCinstance->GetNPads(isector, irow))/2);
580 posArray[7][ichannel] = ichannel;
581
582 // loop over array containing AliTPCCalPads
583 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
584 AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
585 AliTPCCalROC* calROC = calPad->GetCalROC(isector);
586 if (calROC)
587 (vectorArray[ivalue])[ichannel] = calROC->GetValue(irow, ipad);
588 else
589 (vectorArray[ivalue])[ichannel] = 0;
590 }
591 ichannel++;
592 }
593 }
594
595 cstream << "calPads" <<
596 "sector=" << isector;
597
598 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
599 cstream << "calPads" <<
600 (Char_t*)((names[ivalue] + "_Median=").Data()) << median[ivalue] <<
601 (Char_t*)((names[ivalue] + "_Mean=").Data()) << mean[ivalue] <<
602 (Char_t*)((names[ivalue] + "_RMS=").Data()) << rms[ivalue] <<
603 (Char_t*)((names[ivalue] + "_LTM=").Data()) << ltm[ivalue] <<
604 (Char_t*)((names[ivalue] + "_RMS_LTM=").Data()) << ltmrms[ivalue];
605 if (outlierPad) {
606 cstream << "calPads" <<
607 (Char_t*)((names[ivalue] + "_Median_OutlierCutted=").Data()) << medianWithOut[ivalue] <<
608 (Char_t*)((names[ivalue] + "_Mean_OutlierCutted=").Data()) << meanWithOut[ivalue] <<
609 (Char_t*)((names[ivalue] + "_RMS_OutlierCutted=").Data()) << rmsWithOut[ivalue] <<
610 (Char_t*)((names[ivalue] + "_LTM_OutlierCutted=").Data()) << ltmWithOut[ivalue] <<
611 (Char_t*)((names[ivalue] + "_RMS_LTM_OutlierCutted=").Data()) << ltmrmsWithOut[ivalue];
612 }
613 }
614
615 for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
616 cstream << "calPads" <<
617 (Char_t*)((names[ivalue] + ".=").Data()) << &vectorArray[ivalue];
618 }
619
620 if (mapFileName) {
621 for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
622 if (isector < 36)
623 cstream << "calPads" <<
624 (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapIROCArray[ivalue];
625 else
626 cstream << "calPads" <<
627 (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapOROCArray[ivalue];
628 }
629 }
630
631 cstream << "calPads" <<
632 "row.=" << &posArray[0] <<
633 "pad.=" << &posArray[1] <<
634 "lx.=" << &posArray[2] <<
635 "ly.=" << &posArray[3] <<
636 "gx.=" << &posArray[4] <<
637 "gy.=" << &posArray[5] <<
638 "rpad.=" << &posArray[6] <<
639 "channel.=" << &posArray[7];
640
641 cstream << "calPads" <<
642 "\n";
643
644 delete[] posArray;
645 delete[] vectorArray;
646 }
647
648
649 delete[] names;
650 if (mapFileName) {
651 delete mapIROCs;
652 delete mapOROCs;
653 delete[] mapIROCArray;
654 delete[] mapOROCArray;
655 delete[] mapNames;
656 }
657}
658
7a9e557b 659
660AliTPCRecoParam * AliTPCcalibDB::GetRecoParam(Int_t */*eventtype*/){
661 //
662 //
663 //
664 if (!fRecoParamArray){
665 return 0; // back compatible sollution
666 };
667
668 AliTPCRecoParam * param = (AliTPCRecoParam*)fRecoParamArray->At(0);
669 return param;
670
671}