PID probability calculated using refractive index evaluated from OCDB information...
[u/mrichter/AliRoot.git] / TRD / AliTRDcalibDB.cxx
CommitLineData
3551db50 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/* $Id$ */
17
18///////////////////////////////////////////////////////////////////////////////
19// //
20// Class providing the calibration parameters by accessing the CDB //
21// //
2745a409 22// Request an instance with AliTRDcalibDB::Instance() //
3551db50 23// If a new event is processed set the event number with SetRun //
24// Then request the calibration data //
25// //
2745a409 26// Author: //
27// Jan Fiete Grosse-Oetringhaus (Jan.Fiete.Grosse-Oetringhaus@cern.ch) //
28// //
3551db50 29///////////////////////////////////////////////////////////////////////////////
30
a7ac01d2 31#include <TClonesArray.h>
e232d349 32#include <TObjArray.h>
3551db50 33
2745a409 34#include "AliCDBManager.h"
2745a409 35#include "AliCDBEntry.h"
36#include "AliLog.h"
3551db50 37
51a0ce25 38#include "AliTRDPIDReference.h"
3551db50 39#include "AliTRDcalibDB.h"
a9e22145 40#include "AliTRDtrapConfig.h"
41#include "AliTRDtrapConfigHandler.h"
eda91732 42#include "AliTRDCommonParam.h"
3551db50 43
7754cd1f 44#include "Cal/AliTRDCalROC.h"
7754cd1f 45#include "Cal/AliTRDCalPad.h"
46#include "Cal/AliTRDCalDet.h"
e232d349 47#include "Cal/AliTRDCalDCS.h"
d6a1ec13 48#include "Cal/AliTRDCalDCSv2.h"
ea3eaa08 49#include "Cal/AliTRDCalDCSFEEv2.h"
720a0a16 50#include "Cal/AliTRDCalPID.h"
7754cd1f 51#include "Cal/AliTRDCalMonitoring.h"
7754cd1f 52#include "Cal/AliTRDCalChamberStatus.h"
7754cd1f 53#include "Cal/AliTRDCalPadStatus.h"
54#include "Cal/AliTRDCalSingleChamberStatus.h"
9dcc64cc 55#include "Cal/AliTRDCalTrkAttach.h"
ea3eaa08 56#include "Cal/AliTRDCalOnlineGainTable.h"
3551db50 57
58ClassImp(AliTRDcalibDB)
59
2745a409 60AliTRDcalibDB *AliTRDcalibDB::fgInstance = 0;
61Bool_t AliTRDcalibDB::fgTerminated = kFALSE;
3551db50 62
63//_ singleton implementation __________________________________________________
64AliTRDcalibDB* AliTRDcalibDB::Instance()
65{
66 //
67 // Singleton implementation
68 // Returns an instance of this class, it is created if neccessary
63a700c6 69 //
3551db50 70
6d50f529 71 if (fgTerminated != kFALSE) {
3551db50 72 return 0;
6d50f529 73 }
3551db50 74
6d50f529 75 if (fgInstance == 0) {
3551db50 76 fgInstance = new AliTRDcalibDB();
6d50f529 77 }
e254cad1 78
3551db50 79 return fgInstance;
4e009ce4 80
3551db50 81}
82
2745a409 83//_____________________________________________________________________________
3551db50 84void AliTRDcalibDB::Terminate()
85{
86 //
87 // Singleton implementation
6bf5f0ce 88 // Deletes the instance of this class and sets the terminated flag,
89 // instances cannot be requested anymore
3551db50 90 // This function can be called several times.
91 //
92
93 fgTerminated = kTRUE;
94
6d50f529 95 if (fgInstance != 0) {
3551db50 96 delete fgInstance;
97 fgInstance = 0;
98 }
2745a409 99
3551db50 100}
101
102//_____________________________________________________________________________
103AliTRDcalibDB::AliTRDcalibDB()
2745a409 104 :TObject()
105 ,fRun(-1)
6d50f529 106 ,fPRFsmp(0)
107 ,fPRFbin(0)
108 ,fPRFlo(0)
109 ,fPRFhi(0)
110 ,fPRFwid(0)
111 ,fPRFpad(0)
9dcc64cc 112 ,fPIDResponse(NULL)
ea3eaa08 113 ,fOnlineGainTableID(0)
a9e22145 114 ,fTrapConfig(0x0)
f16844ef 115 ,fTrapConfigName("")
116 ,fTrapConfigVersion("")
3551db50 117{
118 //
2745a409 119 // Default constructor
3551db50 120 //
2745a409 121 // TODO Default runnumber is set to 0, this should be changed later
122 // to an invalid value (e.g. -1) to prevent
3551db50 123 // TODO invalid calibration data to be used.
2745a409 124 //
125
95867fd1 126 for (Int_t i = 0; i < kCDBCacheSize; ++i) {
2745a409 127 fCDBCache[i] = 0;
128 fCDBEntries[i] = 0;
129 }
3551db50 130
2745a409 131 // Create the sampled PRF
132 SamplePRF();
d4c6453d 133
2745a409 134}
135
136//_____________________________________________________________________________
137AliTRDcalibDB::AliTRDcalibDB(const AliTRDcalibDB &c)
138 :TObject(c)
6d50f529 139 ,fRun(-1)
140 ,fPRFsmp(0)
141 ,fPRFbin(0)
142 ,fPRFlo(0)
143 ,fPRFhi(0)
144 ,fPRFwid(0)
145 ,fPRFpad(0)
9dcc64cc 146 ,fPIDResponse(NULL)
ea3eaa08 147 ,fOnlineGainTableID(0)
a9e22145 148 ,fTrapConfig(0x0)
f16844ef 149 ,fTrapConfigName("")
150 ,fTrapConfigVersion("")
2745a409 151{
152 //
153 // Copy constructor (not that it make any sense for a singleton...)
154 //
155
95867fd1 156 for (Int_t i = 0; i < kCDBCacheSize; ++i) {
2745a409 157 fCDBCache[i] = 0;
3551db50 158 fCDBEntries[i] = 0;
159 }
6a739e92 160
161 // Create the sampled PRF
162 SamplePRF();
2745a409 163
164}
165
166//_____________________________________________________________________________
167AliTRDcalibDB &AliTRDcalibDB::operator=(const AliTRDcalibDB &c)
168{
169 //
170 // Assignment operator (same as above ...)
171 //
172
173 if (this != &c) {
174 AliFatal("No assignment operator defined");
175 }
4e009ce4 176
2745a409 177 return *this;
178
acba9bad 179}
3551db50 180
181//_____________________________________________________________________________
182AliTRDcalibDB::~AliTRDcalibDB()
183{
184 //
185 // destructor
186 //
187
6d50f529 188 if (fPRFsmp) {
189 delete [] fPRFsmp;
190 fPRFsmp = 0;
6a739e92 191 }
ea3eaa08 192
193 if (fPIDResponse) {
194 delete fPIDResponse;
195 fPIDResponse = 0x0;
196 }
6a739e92 197
3551db50 198 Invalidate();
2745a409 199
acba9bad 200}
3551db50 201
63a700c6 202//_caching functions____________________________________________________________
95867fd1 203const TObject *AliTRDcalibDB::GetCachedCDBObject(Int_t id)
63a700c6 204{
2745a409 205 //
206 // Retrieves a cdb object with the given id. The objects are cached as
207 // long as the run number is not changed.
208 //
209 // Put together the available objects here by using the lines
210 // a) For usual calibration objects:
211 // case kID<Name> :
212 // return CacheCDBEntry(kID<Name>,"TRD/Calib/<Path>");
213 // break;
214 // See function CacheCDBEntry for details.
215 // and
216 // b) For calibration data which depends on two objects: One containing
217 // a value per detector and one the local fluctuations per pad:
218 // case kID<Name> :
219 // return CacheMergeCDBEntry(kID<Name>,"TRD/Calib/<padPath>","TRD/Calib/<chamberPath>");
220 // break;
221 // See function CacheMergeCDBEntry for details.
222 //
63a700c6 223
6d50f529 224 switch (id) {
2745a409 225
226 // Parameters defined per pad and chamber
227 case kIDVdriftPad :
6d50f529 228 return CacheCDBEntry(kIDVdriftPad ,"TRD/Calib/LocalVdrift");
2745a409 229 break;
230 case kIDVdriftChamber :
6d50f529 231 return CacheCDBEntry(kIDVdriftChamber ,"TRD/Calib/ChamberVdrift");
2745a409 232 break;
eda91732 233 case kIDExBChamber :
234 return CacheCDBEntry(kIDExBChamber ,"TRD/Calib/ChamberExB");
235 break;
2745a409 236 case kIDT0Pad :
6d50f529 237 return CacheCDBEntry(kIDT0Pad ,"TRD/Calib/LocalT0");
2745a409 238 break;
239 case kIDT0Chamber :
6d50f529 240 return CacheCDBEntry(kIDT0Chamber ,"TRD/Calib/ChamberT0");
2745a409 241 break;
242 case kIDGainFactorPad :
6d50f529 243 return CacheCDBEntry(kIDGainFactorPad ,"TRD/Calib/LocalGainFactor");
2745a409 244 break;
245 case kIDGainFactorChamber :
6d50f529 246 return CacheCDBEntry(kIDGainFactorChamber ,"TRD/Calib/ChamberGainFactor");
2745a409 247 break;
ea3eaa08 248
249 case kIDOnlineGainFactor :
250 switch(GetOnlineGainTableID()) {
251 case 0:
252 // For testing purposes only !!!
253 AliInfo("No gain table name from OCDB. Use default table!");
254 return CacheCDBEntry(kIDOnlineGainFactor ,"TRD/Calib/Krypton_2011-01");
255 break;
256 case 1:
257 // Online gain table ID 1
258 return CacheCDBEntry(kIDOnlineGainFactor ,"TRD/Calib/Krypton_2011-01");
259 break;
412d07b9 260 case 2:
261 // Online gain table ID 2
262 return CacheCDBEntry(kIDOnlineGainFactor ,"TRD/Calib/Gaintbl_Uniform_FGAN0_2011-01");
263 break;
264 case 3:
265 // Online gain table ID 3
266 return CacheCDBEntry(kIDOnlineGainFactor ,"TRD/Calib/Gaintbl_Uniform_FGAN8_2011-01");
267 break;
3abf1c06 268 case 4:
269 // Online gain table ID 4
270 return CacheCDBEntry(kIDOnlineGainFactor ,"TRD/Calib/Krypton_2011-02");
271 break;
4a05be5f 272 case 5:
273 // Online gain table ID 5
274 return CacheCDBEntry(kIDOnlineGainFactor ,"TRD/Calib/Krypton_2011-03");
275 break;
276 case 6:
277 // Online gain table ID 6
278 return CacheCDBEntry(kIDOnlineGainFactor ,"TRD/Calib/Gaintbl_Uniform_FGAN0_2012-01");
279 break;
280 case 7:
281 // Online gain table ID 7
282 return CacheCDBEntry(kIDOnlineGainFactor ,"TRD/Calib/Gaintbl_Uniform_FGAN8_2012-01");
283 break;
ea3eaa08 284 }
285 break;
286
df83a620 287 case kIDNoiseChamber :
ea3eaa08 288 return CacheCDBEntry(kIDNoiseChamber ,"TRD/Calib/DetNoise");
df83a620 289 break;
290 case kIDNoisePad :
ea3eaa08 291 return CacheCDBEntry(kIDNoisePad ,"TRD/Calib/PadNoise");
df83a620 292 break;
293
2745a409 294 // Parameters defined per pad
295 case kIDPRFWidth :
6d50f529 296 return CacheCDBEntry(kIDPRFWidth ,"TRD/Calib/PRFWidth");
2745a409 297 break;
298
299 // Status values
2745a409 300 case kIDChamberStatus :
6d50f529 301 return CacheCDBEntry(kIDChamberStatus ,"TRD/Calib/ChamberStatus");
2745a409 302 break;
2745a409 303 case kIDPadStatus :
6d50f529 304 return CacheCDBEntry(kIDPadStatus ,"TRD/Calib/PadStatus");
2745a409 305 break;
306
307 // Global parameters
308 case kIDMonitoringData :
6d50f529 309 return CacheCDBEntry(kIDMonitoringData ,"TRD/Calib/MonitoringData");
2745a409 310 break;
aa617684 311 case kIDFEE :
312 return CacheCDBEntry(kIDFEE ,"TRD/Calib/FEE");
2745a409 313 break;
a9e22145 314 case kIDTrapConfig :
315 return CacheCDBEntry(kIDFEE ,"TRD/Calib/TrapConfig");
316 break;
e232d349 317 case kIDDCS :
5f481838 318 return CacheCDBEntry(kIDDCS ,"TRD/Calib/DCS");
e232d349 319 break;
44dbae42 320 case kIDPIDNN :
321 return CacheCDBEntry(kIDPIDNN ,"TRD/Calib/PIDNN");
ea3eaa08 322 break;
2745a409 323 case kIDPIDLQ :
6d50f529 324 return CacheCDBEntry(kIDPIDLQ ,"TRD/Calib/PIDLQ");
2745a409 325 break;
9dcc64cc 326 case kIDPIDLQ1D:
327 return CacheCDBEntry(kIDPIDLQ1D ,"TRD/Calib/PIDLQ1D");
328 break;
a7ac01d2 329 case kIDRecoParam :
9dcc64cc 330 return CacheCDBEntry(kIDRecoParam ,"TRD/Calib/RecoParam");
331 break;
332 case kIDAttach :
333 return CacheCDBEntry(kIDAttach ,"TRD/Calib/TrkAttach");
a7ac01d2 334 break;
e2a1c98b 335 case kIDPHQ :
336 return CacheCDBEntry(kIDPHQ ,"TRD/Calib/PHQ");
337 break;
2745a409 338 }
339
340 return 0;
341
63a700c6 342}
343
344//_____________________________________________________________________________
95867fd1 345AliCDBEntry *AliTRDcalibDB::GetCDBEntry(const char *cdbPath)
63a700c6 346{
347 //
348 // Retrieves an entry with path <cdbPath> from the CDB.
349 //
350
95867fd1 351 AliCDBEntry *entry = AliCDBManager::Instance()->Get(cdbPath,fRun);
2745a409 352 if (!entry) {
a7ac01d2 353 AliError(Form("Failed to get entry: %s",cdbPath));
63a700c6 354 return 0;
355 }
356
63a700c6 357 return entry;
2745a409 358
63a700c6 359}
360
361//_____________________________________________________________________________
95867fd1 362const TObject *AliTRDcalibDB::CacheCDBEntry(Int_t id, const char *cdbPath)
63a700c6 363{
364 //
365 // Caches the entry <id> with cdb path <cdbPath>
366 //
d6a1ec13 367
2745a409 368 if (!fCDBCache[id]) {
63a700c6 369 fCDBEntries[id] = GetCDBEntry(cdbPath);
95867fd1 370 if (fCDBEntries[id]) {
63a700c6 371 fCDBCache[id] = fCDBEntries[id]->GetObject();
95867fd1 372 }
d6a1ec13 373 }
374
63a700c6 375 return fCDBCache[id];
ea3eaa08 376
63a700c6 377}
378
3551db50 379//_____________________________________________________________________________
380void AliTRDcalibDB::SetRun(Long64_t run)
381{
382 //
7754cd1f 383 // Sets current run number. Calibration data is read from the corresponding file.
3551db50 384 // When the run number changes the caching is invalidated.
385 //
7754cd1f 386
6d50f529 387 if (fRun == run) {
3551db50 388 return;
6d50f529 389 }
7754cd1f 390
3551db50 391 fRun = run;
95867fd1 392
3551db50 393 Invalidate();
2745a409 394
3551db50 395}
7754cd1f 396
3551db50 397//_____________________________________________________________________________
398void AliTRDcalibDB::Invalidate()
399{
400 //
401 // Invalidates cache (when run number is changed).
402 //
403
95867fd1 404 for (Int_t i = 0; i < kCDBCacheSize; ++i) {
2745a409 405 if (fCDBEntries[i]) {
406 if (AliCDBManager::Instance()->GetCacheFlag() == kFALSE) {
11f5dd43 407 if ((fCDBEntries[i]->IsOwner() == kFALSE) &&
408 (fCDBCache[i])) {
e254cad1 409 delete fCDBCache[i];
2745a409 410 }
e254cad1 411 delete fCDBEntries[i];
412 }
3551db50 413 fCDBEntries[i] = 0;
2745a409 414 fCDBCache[i] = 0;
3551db50 415 }
416 }
2745a409 417
ea3eaa08 418 fOnlineGainTableID = 0;
419
df83a620 420}
ea3eaa08 421
df83a620 422//_____________________________________________________________________________
423Float_t AliTRDcalibDB::GetNoise(Int_t det, Int_t col, Int_t row)
424{
425 //
426 // Returns the noise level in ADC counts for the given pad.
427 //
428
429 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
430 (GetCachedCDBObject(kIDNoisePad));
431 if (!calPad) {
432 return -1;
433 }
434
435 AliTRDCalROC *roc = calPad->GetCalROC(det);
436 if (!roc) {
437 return -1;
438 }
439
440 const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *>
441 (GetCachedCDBObject(kIDNoiseChamber));
442 if (!calChamber) {
443 return -1;
444 }
445
446 return calChamber->GetValue(det) * roc->GetValue(col,row);
447
448}
449
450//_____________________________________________________________________________
451AliTRDCalROC *AliTRDcalibDB::GetNoiseROC(Int_t det)
452{
453 //
454 // Returns the Vdrift calibration object for a given ROC
455 // containing one number per pad
456 //
457
458 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
459 (GetCachedCDBObject(kIDNoisePad));
460 if (!calPad) {
461 return 0;
462 }
463
464 AliTRDCalROC *roc = calPad->GetCalROC(det);
465 if (!roc) {
466 return 0;
467 }
468 else {
469 return roc;
470 }
471
472}
473
474//_____________________________________________________________________________
475const AliTRDCalDet *AliTRDcalibDB::GetNoiseDet()
476{
477 //
478 // Returns the Vdrift calibration object
479 // containing one number per detector
480 //
481
482 const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *>
483 (GetCachedCDBObject(kIDNoiseChamber));
484 if (!calChamber) {
485 return 0;
486 }
487 else {
488 return calChamber;
489 }
490
3551db50 491}
492
3551db50 493//_____________________________________________________________________________
494Float_t AliTRDcalibDB::GetVdrift(Int_t det, Int_t col, Int_t row)
495{
496 //
497 // Returns the drift velocity for the given pad.
498 //
7754cd1f 499
95867fd1 500 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
6d50f529 501 (GetCachedCDBObject(kIDVdriftPad));
502 if (!calPad) {
3551db50 503 return -1;
6d50f529 504 }
3551db50 505
95867fd1 506 AliTRDCalROC *roc = calPad->GetCalROC(det);
6d50f529 507 if (!roc) {
3551db50 508 return -1;
6d50f529 509 }
3551db50 510
95867fd1 511 const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *>
6d50f529 512 (GetCachedCDBObject(kIDVdriftChamber));
513 if (!calChamber) {
7754cd1f 514 return -1;
6d50f529 515 }
7754cd1f 516
95867fd1 517 return calChamber->GetValue(det) * roc->GetValue(col,row);
2745a409 518
7754cd1f 519}
afb9f880 520
521//_____________________________________________________________________________
522AliTRDCalROC *AliTRDcalibDB::GetVdriftROC(Int_t det)
523{
524 //
525 // Returns the Vdrift calibration object for a given ROC
526 // containing one number per pad
527 //
528
529 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
530 (GetCachedCDBObject(kIDVdriftPad));
531 if (!calPad) {
532 return 0;
533 }
534
535 AliTRDCalROC *roc = calPad->GetCalROC(det);
536 if (!roc) {
537 return 0;
538 }
539 else {
540 return roc;
541 }
542
543}
544
545//_____________________________________________________________________________
546const AliTRDCalDet *AliTRDcalibDB::GetVdriftDet()
547{
548 //
549 // Returns the Vdrift calibration object
550 // containing one number per detector
551 //
552
553 const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *>
554 (GetCachedCDBObject(kIDVdriftChamber));
555 if (!calChamber) {
556 return 0;
557 }
558 else {
559 return calChamber;
560 }
561
562}
7754cd1f 563
e2a1c98b 564//_____________________________________________________________________________
565TObjArray * AliTRDcalibDB::GetPHQ()
566{
567 //
568 //return PHQ calibration object
569 //
570 TObjArray *arr = (TObjArray *) (GetCachedCDBObject(kIDPHQ));
571 return arr;
572}
573
7754cd1f 574//_____________________________________________________________________________
575Float_t AliTRDcalibDB::GetVdriftAverage(Int_t det)
576{
577 //
578 // Returns the average drift velocity for the given detector
579 //
580
95867fd1 581 const AliTRDCalDet *calDet = dynamic_cast<const AliTRDCalDet *>
6d50f529 582 (GetCachedCDBObject(kIDVdriftChamber));
583 if (!calDet) {
7754cd1f 584 return -1;
6d50f529 585 }
7754cd1f 586
587 return calDet->GetValue(det);
2745a409 588
acba9bad 589}
eda91732 590//_____________________________________________________________________________
591const AliTRDCalDet *AliTRDcalibDB::GetExBDet()
592{
593 //
594 // Returns the exB calibration object
595 // containing one number per detector
596 //
597
598 const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *> (GetCachedCDBObject(kIDExBChamber));
599
600 Double_t meanexb = 100.0;
601 if (calChamber) meanexb = calChamber->GetMean();
602 //printf("mean %f\n",meanexb);
3551db50 603
eda91732 604 if ((!calChamber) || (meanexb > 70.0)) {
605
606 const AliTRDCalDet *calChambervdrift = dynamic_cast<const AliTRDCalDet *>
607 (GetCachedCDBObject(kIDVdriftChamber));
608 if (!calChambervdrift) {
609 return 0;
610 }
611 else {
612 AliTRDCalDet *calDetExB = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)");
613 for(Int_t k = 0; k < 540; k++){
614 calDetExB->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(calChambervdrift->GetValue(k)));
eda91732 615 }
616 return calDetExB;
617 }
618 }
619 else return calChamber;
620
621}
3551db50 622//_____________________________________________________________________________
623Float_t AliTRDcalibDB::GetT0(Int_t det, Int_t col, Int_t row)
624{
625 //
626 // Returns t0 for the given pad.
627 //
628
d4c6453d 629 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
630 (GetCachedCDBObject(kIDT0Pad));
6d50f529 631 if (!calPad) {
3551db50 632 return -1;
6d50f529 633 }
3551db50 634
d4c6453d 635 AliTRDCalROC *roc = calPad->GetCalROC(det);
6d50f529 636 if (!roc) {
3551db50 637 return -1;
6d50f529 638 }
3551db50 639
d4c6453d 640 const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *>
641 (GetCachedCDBObject(kIDT0Chamber));
6d50f529 642 if (!calChamber) {
7754cd1f 643 return -1;
6d50f529 644 }
7754cd1f 645
8d786fb8 646 return calChamber->GetValue(det) + roc->GetValue(col,row);
2745a409 647
7754cd1f 648}
afb9f880 649
56178ff4 650//_____________________________________________________________________________
651AliTRDCalROC *AliTRDcalibDB::GetT0ROC(Int_t det)
652{
653 //
654 // Returns the t0 calibration object for a given ROC
655 // containing one number per pad
656 //
657
658 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
659 (GetCachedCDBObject(kIDT0Pad));
660 if (!calPad) {
661 return 0;
662 }
663
664 AliTRDCalROC *roc = calPad->GetCalROC(det);
665 if (!roc) {
666 return 0;
667 }
668 else {
669 return roc;
670 }
671
672}
673
674//_____________________________________________________________________________
675const AliTRDCalDet *AliTRDcalibDB::GetT0Det()
676{
677 //
678 // Returns the t0 calibration object
679 // containing one number per detector
680 //
681
682 const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *>
683 (GetCachedCDBObject(kIDT0Chamber));
684 if (!calChamber) {
685 return 0;
686 }
687 else {
688 return calChamber;
689 }
690
691}
692
7754cd1f 693//_____________________________________________________________________________
694Float_t AliTRDcalibDB::GetT0Average(Int_t det)
695{
696 //
697 // Returns the average t0 for the given detector
698 //
699
5aba4f09 700 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
701 (GetCachedCDBObject(kIDT0Pad));
702 if (!calPad) {
703 return -1;
704 }
705
706 AliTRDCalROC *roc = calPad->GetCalROC(det);
707 if (!roc) {
708 return -1;
709 }
710
95867fd1 711 const AliTRDCalDet *calDet = dynamic_cast<const AliTRDCalDet *>
6d50f529 712 (GetCachedCDBObject(kIDT0Chamber));
713 if (!calDet) {
7754cd1f 714 return -1;
6d50f529 715 }
7754cd1f 716
4eb02ab1 717 Double_t sum = 0.0;
5aba4f09 718 for (Int_t channel = 0; channel < roc->GetNchannels(); ++channel) {
4eb02ab1 719 sum += roc->GetValue(channel);
5aba4f09 720 }
4eb02ab1 721 sum /= roc->GetNchannels();
722 sum += calDet->GetValue(det);
723 return sum;
2745a409 724
acba9bad 725}
3551db50 726
ea3eaa08 727//_____________________________________________________________________________
728AliTRDCalOnlineGainTableROC* AliTRDcalibDB::GetOnlineGainTableROC(Int_t det)
729{
730 //
731 // Returns the online gain factor table for a given ROC.
732 //
c36ddf52 733
734 if (!HasOnlineFilterGain()) {
735 return 0x0;
736 }
ea3eaa08 737
738 const AliTRDCalOnlineGainTable *calOnline
739 = dynamic_cast<const AliTRDCalOnlineGainTable *>
740 (GetCachedCDBObject(kIDOnlineGainFactor));
741 if (!calOnline) {
742 return 0x0;
743 }
744
745 return calOnline->GetGainTableROC(det);
746
747}
748
749//_____________________________________________________________________________
750Float_t AliTRDcalibDB::GetOnlineGainFactor(Int_t det, Int_t col, Int_t row)
751{
752 //
753 // Returns the online gain factor for the given pad.
754 //
c36ddf52 755
756 if (!HasOnlineFilterGain()) {
757 return 0x0;
758 }
ea3eaa08 759
760 const AliTRDCalOnlineGainTable *calOnline
761 = dynamic_cast<const AliTRDCalOnlineGainTable *>
762 (GetCachedCDBObject(kIDOnlineGainFactor));
763 if (!calOnline) {
764 return -1;
765 }
766
767 return calOnline->GetGainCorrectionFactor(det,row,col);
768
769}
770
56178ff4 771//_____________________________________________________________________________
772AliTRDCalROC *AliTRDcalibDB::GetGainFactorROC(Int_t det)
773{
774 //
775 // Returns the gain factor calibration object for a given ROC
56178ff4 776 //
777
778 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
779 (GetCachedCDBObject(kIDGainFactorPad));
780 if (!calPad) {
781 return 0;
782 }
783
784 AliTRDCalROC *roc = calPad->GetCalROC(det);
785 if (!roc) {
786 return 0;
787 }
788 else {
789 return roc;
790 }
791
792}
793
c36ddf52 794//_____________________________________________________________________________
795Float_t AliTRDcalibDB::GetGainFactor(Int_t det, Int_t col, Int_t row)
796{
797 //
798 // Returns the gain factor for the given pad.
799 //
800
801 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
802 (GetCachedCDBObject(kIDGainFactorPad));
803 if (!calPad) {
804 return -1;
805 }
806
807 AliTRDCalROC *roc = calPad->GetCalROC(det);
808 if (!roc) {
809 return -1;
810 }
811
812 const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *>
813 (GetCachedCDBObject(kIDGainFactorChamber));
814 if (!calChamber) {
815 return -1;
816 }
817
818 return calChamber->GetValue(det) * roc->GetValue(col,row);
819
820}
821
56178ff4 822//_____________________________________________________________________________
823const AliTRDCalDet *AliTRDcalibDB::GetGainFactorDet()
824{
825 //
826 // Returns the gain factor calibration object
827 // containing one number per detector
828 //
829
830 const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *>
831 (GetCachedCDBObject(kIDGainFactorChamber));
832 if (!calChamber) {
833 return 0;
834 }
835 else {
836 return calChamber;
837 }
838
839}
840
7754cd1f 841//_____________________________________________________________________________
842Float_t AliTRDcalibDB::GetGainFactorAverage(Int_t det)
843{
844 //
845 // Returns the average gain factor for the given detector
846 //
847
95867fd1 848 const AliTRDCalDet *calDet = dynamic_cast<const AliTRDCalDet *>
6d50f529 849 (GetCachedCDBObject(kIDGainFactorChamber));
850 if (!calDet) {
7754cd1f 851 return -1;
6d50f529 852 }
7754cd1f 853
854 return calDet->GetValue(det);
2745a409 855
acba9bad 856}
6a739e92 857
524fc8fa 858//_____________________________________________________________________________
859AliTRDCalROC *AliTRDcalibDB::GetPRFROC(Int_t det)
860{
861 //
862 // Returns the PRF calibration object for a given ROC
863 // containing one number per pad
864 //
865
866 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
867 (GetCachedCDBObject(kIDPRFWidth));
868 if (!calPad) {
869 return 0;
870 }
871
872 AliTRDCalROC *roc = calPad->GetCalROC(det);
873 if (!roc) {
874 return 0;
875 }
876 else {
877 return roc;
878 }
879
880}
881
6a739e92 882//_____________________________________________________________________________
883Float_t AliTRDcalibDB::GetPRFWidth(Int_t det, Int_t col, Int_t row)
884{
885 //
886 // Returns the PRF width for the given pad.
887 //
888
95867fd1 889 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
6d50f529 890 (GetCachedCDBObject(kIDPRFWidth));
891 if (!calPad) {
6a739e92 892 return -1;
6d50f529 893 }
6a739e92 894
95867fd1 895 AliTRDCalROC *roc = calPad->GetCalROC(det);
6d50f529 896 if (!roc) {
6a739e92 897 return -1;
6d50f529 898 }
6a739e92 899
95867fd1 900 return roc->GetValue(col,row);
2745a409 901
acba9bad 902}
3551db50 903
904//_____________________________________________________________________________
f1dcad37 905Int_t AliTRDcalibDB::GetNumberOfTimeBinsDCS()
3551db50 906{
e232d349 907 //
908 // Returns Number of time bins from the DCS
909 //
f1dcad37 910
c6f7c6cb 911 Int_t nMixed = -2; // not the same number for all chambers
912 Int_t nUndef = -1; // default value - has not been set!
913 Int_t nTbSor = nUndef;
914 Int_t nTbEor = nUndef;
d6a1ec13 915 Int_t calver = 0; // Check CalDCS version
c6f7c6cb 916
e232d349 917 const TObjArray *dcsArr = dynamic_cast<const TObjArray *>(GetCachedCDBObject(kIDDCS));
c6f7c6cb 918 if (!dcsArr) {
919 AliError("No DCS object found!");
920 return nUndef;
e232d349 921 }
c6f7c6cb 922
d6a1ec13 923 if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCS")) calver = 1;
924 if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCSv2")) calver = 2;
0eaf9c74 925
d6a1ec13 926 if (calver == 1) {
927 // DCS object
928 const AliTRDCalDCS *calDCSsor = dynamic_cast<const AliTRDCalDCS *>(dcsArr->At(0));
929 const AliTRDCalDCS *calDCSeor = dynamic_cast<const AliTRDCalDCS *>(dcsArr->At(1));
930 if (!calDCSsor) {
931 // the SOR file is mandatory
932 AliError("NO SOR AliTRDCalDCS object found in CDB file!");
933 return nUndef;
934 }
935 if (!calDCSeor) {
936 // this can happen if the run is shorter than a couple of seconds.
937 AliWarning("NO EOR AliTRDCalDCS object found in CDB file.");
7a6352a6 938 }
c6f7c6cb 939
d6a1ec13 940 // get the numbers
941 nTbSor = calDCSsor->GetGlobalNumberOfTimeBins();
942 if (calDCSeor) nTbEor = calDCSeor->GetGlobalNumberOfTimeBins();
943
944 } else if (calver == 2) {
945 // DCSv2 object
946 const AliTRDCalDCSv2 *calDCSsorv2 = dynamic_cast<const AliTRDCalDCSv2 *>(dcsArr->At(0));
947 const AliTRDCalDCSv2 *calDCSeorv2 = dynamic_cast<const AliTRDCalDCSv2 *>(dcsArr->At(1));
948 if (!calDCSsorv2) {
949 // the SOR file is mandatory
950 AliError("NO SOR AliTRDCalDCSv2 object found in CDB file!");
951 return nUndef;
952 }
953 if (!calDCSeorv2) {
954 // this can happen if the run is shorter than a couple of seconds.
955 AliWarning("NO EOR AliTRDCalDCSv2 object found in CDB file.");
7a6352a6 956 }
c6f7c6cb 957
d6a1ec13 958 // get the numbers
959 nTbSor = calDCSsorv2->GetGlobalNumberOfTimeBins();
960 if (calDCSeorv2) nTbEor = calDCSeorv2->GetGlobalNumberOfTimeBins();
961
962 } else AliError("NO DCS/DCSv2 OCDB entry found!");
c6f7c6cb 963
964 // if they're the same return the value
965 // -2 means mixed, -1: no data, >= 0: good number of time bins
966 if (nTbSor == nTbEor) return nTbSor;
967
968 // if they're differing:
969 if (nTbSor == nMixed || nTbEor == nMixed) {
970 AliWarning("Inconsistent number of time bins found!");
971 return nMixed;
e232d349 972 }
d6a1ec13 973
c6f7c6cb 974 // one is undefined, the other ok -> return that one
975 if (nTbSor == nUndef) return nTbEor;
976 if (nTbEor == nUndef) return nTbSor;
977
978 // only remains: two different numbers >= 0
979 return nMixed;
ea3eaa08 980
e232d349 981}
982
983//_____________________________________________________________________________
f1dcad37 984void AliTRDcalibDB::GetFilterType(TString &filterType)
985{
986 //
987 // Returns the filter type
988 //
989
fc358d0f 990 GetDCSConfigParOption(kFltrSet, 0, filterType);
d6a1ec13 991
af086c5e 992}
993
994//_____________________________________________________________________________
ea3eaa08 995Int_t AliTRDcalibDB::GetOnlineGainTableID()
996{
997 //
998 // Get the gain table ID from the DCS
999 //
1000
1001 if (fOnlineGainTableID > 0) {
1002 return fOnlineGainTableID;
1003 }
1004
1005 const TObjArray *dcsArr = dynamic_cast<const TObjArray *>(GetCachedCDBObject(kIDDCS));
1006 if (!dcsArr){
1007 return -1;
1008 }
1009
1010 Int_t esor = 0; // Take SOR
1011 Int_t calver = 0; // Check CalDCS version
1012 if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCS")) calver = 1;
1013 if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCSv2")) calver = 2;
1014
1015 if (calver == 1) {
1016
1017 // No data for old DCS object available, anyway
1018 return -1;
1019
1020 }
1021 else if (calver == 2) {
1022
1023 // DCSv2 object
1024 const AliTRDCalDCSv2 *calDCSv2 = dynamic_cast<const AliTRDCalDCSv2 *>(dcsArr->At(esor));
1025 if(!calDCSv2){
1026 return -1;
1027 }
1028
1029 TString tableName = "";
1030 for (Int_t i = 0; i < 540; i++) {
1031 const AliTRDCalDCSFEEv2 *calDCSFEEv2 = calDCSv2->GetCalDCSFEEObj(0);
1032 tableName = calDCSFEEv2->GetGainTableName();
1033 if (tableName.Length() > 0) {
1034 break;
1035 }
1036 }
412d07b9 1037 if (tableName.CompareTo("Krypton_2011-01") == 0) {
ea3eaa08 1038 fOnlineGainTableID = 1;
1039 return fOnlineGainTableID;
1040 }
412d07b9 1041 if (tableName.CompareTo("Gaintbl_Uniform_FGAN0_2011-01") == 0) {
1042 fOnlineGainTableID = 2;
1043 return fOnlineGainTableID;
1044 }
1045 if (tableName.CompareTo("Gaintbl_Uniform_FGAN8_2011-01") == 0) {
1046 fOnlineGainTableID = 3;
1047 return fOnlineGainTableID;
1048 }
3abf1c06 1049 if (tableName.CompareTo("Krypton_2011-02") == 0) {
1050 fOnlineGainTableID = 4;
1051 return fOnlineGainTableID;
1052 }
4a05be5f 1053 if (tableName.CompareTo("Krypton_2011-03") == 0) {
1054 fOnlineGainTableID = 5;
1055 return fOnlineGainTableID;
1056 }
1057 if (tableName.CompareTo("Gaintbl_Uniform_FGAN0_2012-01") == 0) {
1058 fOnlineGainTableID = 6;
1059 return fOnlineGainTableID;
1060 }
1061 if (tableName.CompareTo("Gaintbl_Uniform_FGAN8_2012-01") == 0) {
1062 fOnlineGainTableID = 7;
1063 return fOnlineGainTableID;
1064 }
ea3eaa08 1065
1066 }
1067 else {
1068
1069 AliError("NO DCS/DCSv2 OCDB entry found!");
1070 return -1;
1071
1072 }
1073
45b38fb0 1074 return -1;
1075
ea3eaa08 1076}
1077
1078//_____________________________________________________________________________
1079void AliTRDcalibDB::GetGlobalConfiguration(TString &config)
1080{
af086c5e 1081 //
1082 // Get Configuration from the DCS
1083 //
d6a1ec13 1084
af086c5e 1085 const TObjArray *dcsArr = dynamic_cast<const TObjArray *>(GetCachedCDBObject(kIDDCS));
1086 if(!dcsArr){
1087 config = "";
1088 return;
1089 }
d6a1ec13 1090
1091 Int_t esor = 0; // Take SOR
1092 Int_t calver = 0; // Check CalDCS version
1093 if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCS")) calver = 1;
1094 if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCSv2")) calver = 2;
1095
ea3eaa08 1096 if (calver == 1) {
1097
d6a1ec13 1098 // DCS object
ea3eaa08 1099 const AliTRDCalDCS *calDCS = dynamic_cast<const AliTRDCalDCS *>(dcsArr->At(esor));
d6a1ec13 1100 if(!calDCS){
1101 config = "";
1102 return;
1103 }
1104 config = calDCS->GetGlobalConfigName();
ea3eaa08 1105
1106 }
1107 else if (calver == 2) {
1108
d6a1ec13 1109 // DCSv2 object
1110 const AliTRDCalDCSv2 *calDCSv2 = dynamic_cast<const AliTRDCalDCSv2 *>(dcsArr->At(esor));
1111 if(!calDCSv2){
1112 config = "";
1113 return;
1114 }
1115 config = calDCSv2->GetGlobalConfigName();
ea3eaa08 1116
1117 }
1118 else {
1119
1120 AliError("NO DCS/DCSv2 OCDB entry found!");
1121
1122 }
d6a1ec13 1123
af086c5e 1124}
f1dcad37 1125
f8059b39 1126//_____________________________________________________________________________
1127void AliTRDcalibDB::GetGlobalConfigurationVersion(TString &version)
1128{
1129 //
1130 // Get Version of Configuration from the DCS
1131 //
1132
1133 const TObjArray *dcsArr = dynamic_cast<const TObjArray *>(GetCachedCDBObject(kIDDCS));
1134 if(!dcsArr){
1135 version = "";
1136 return;
1137 }
1138
1139 Int_t esor = 0; // Take SOR
1140 Int_t calver = 0; // Check CalDCS version
1141 if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCS")) calver = 1;
1142 if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCSv2")) calver = 2;
1143
1144 if (calver == 1) {
1145
1146 // DCS object
1147 const AliTRDCalDCS *calDCS = dynamic_cast<const AliTRDCalDCS *>(dcsArr->At(esor));
1148 if(!calDCS){
1149 version = "";
1150 return;
1151 }
1152 version = calDCS->GetGlobalConfigVersion();
1153
1154 }
1155 else if (calver == 2) {
1156
1157 // DCSv2 object
1158 const AliTRDCalDCSv2 *calDCSv2 = dynamic_cast<const AliTRDCalDCSv2 *>(dcsArr->At(esor));
1159 if(!calDCSv2){
1160 version = "";
1161 return;
1162 }
1163 version = calDCSv2->GetGlobalConfigVersion();
1164
1165 }
1166 else {
1167
1168 AliError("NO DCS/DCSv2 OCDB entry found!");
1169
1170 }
1171
1172}
1173
af086c5e 1174//_____________________________________________________________________________
fc358d0f 1175void AliTRDcalibDB::GetDCSConfigParOption(Int_t cfgType, Int_t option, TString &cfgo)
af086c5e 1176{
1177 //
fc358d0f 1178 // Get a configuration (see enum in header file) or the options of a configuration
1179 // option == 0 returns the configuration itself
1180 // option > 0 returns the optional parameter Nr. (option) of the configuration (cfgType)
af086c5e 1181 //
ea3eaa08 1182
fc358d0f 1183 // define the delimiters
1184 TString cdelim = "_";
1185 TString odelim = "-";
ea3eaa08 1186
fc358d0f 1187 // get the full configuration name
1188 TString cname;
af086c5e 1189 GetGlobalConfiguration(cname);
fc358d0f 1190 TObjArray *carr = cname.Tokenize(cdelim);
1191 Int_t nconfig = carr->GetEntries();
1192
1193 // protect
1194 if (nconfig == 0) {
1195 AliError("Bad DCS configuration name!");
1196 cfgo = "";
1197 return;
1198 } else if ((nconfig-1) < cfgType) {
1199 AliError("Not enough DCS configuration parameters!");
1200 cfgo = "";
1201 return;
1202 }
1203
1204 TString fullcfg = ((TObjString*)carr->At(cfgType))->GetString();
1205
1206 if (fullcfg.Contains(odelim)) {
ea3eaa08 1207
fc358d0f 1208 TObjArray *oarr = fullcfg.Tokenize(odelim);
1209 Int_t noptions = oarr->GetEntries();
1210
1211 // protect
1212 if ((noptions-1) < option) {
1213 AliError("Not enough DCS configuration options defined!");
1214 cfgo = "";
1215 return;
1216 }
1217
1218 cfgo = ((TObjString*)oarr->At(option))->GetString();
1219 return;
1220
1221 }
1222 else {
1223
1224 if (option != 0) {
1225 AliError("Not enough DCS configuration options defined!");
1226 cfgo = "";
1227 return;
1228 }
1229 cfgo = fullcfg;
1230 return;
1231
1232 }
1233
1234}
1235
1236//_____________________________________________________________________________
1237Bool_t AliTRDcalibDB::HasOnlineFilterPedestal()
1238{
1239 //
1240 // Checks whether pedestal filter was applied online
1241 //
1242
1243 TString filterconfig;
1244 GetFilterType(filterconfig);
ea3eaa08 1245
af086c5e 1246 return filterconfig.Contains("p");
ea3eaa08 1247
af086c5e 1248}
1249
1250//_____________________________________________________________________________
ea3eaa08 1251Bool_t AliTRDcalibDB::HasOnlineFilterGain()
1252{
af086c5e 1253 //
1254 // Checks whether online gain filter was applied
1255 //
ea3eaa08 1256
fc358d0f 1257 TString filterconfig;
1258 GetFilterType(filterconfig);
ea3eaa08 1259
af086c5e 1260 return filterconfig.Contains("g");
ea3eaa08 1261
af086c5e 1262}
1263
1264//_____________________________________________________________________________
ea3eaa08 1265Bool_t AliTRDcalibDB::HasOnlineTailCancellation()
1266{
af086c5e 1267 //
1268 // Checks whether online tail cancellation was applied
1269 //
ea3eaa08 1270
fc358d0f 1271 TString filterconfig;
1272 GetFilterType(filterconfig);
ea3eaa08 1273
af086c5e 1274 return filterconfig.Contains("t");
ea3eaa08 1275
e232d349 1276}
1277
7754cd1f 1278//_____________________________________________________________________________
1279Char_t AliTRDcalibDB::GetPadStatus(Int_t det, Int_t col, Int_t row)
1280{
1281 //
1282 // Returns the status of the given pad
1283 //
1284
aa617684 1285 const AliTRDCalPadStatus *cal = dynamic_cast<const AliTRDCalPadStatus *>
1286 (GetCachedCDBObject(kIDPadStatus));
6d50f529 1287 if (!cal) {
7754cd1f 1288 return -1;
6d50f529 1289 }
7754cd1f 1290
95867fd1 1291 const AliTRDCalSingleChamberStatus *roc = cal->GetCalROC(det);
6d50f529 1292 if (!roc) {
7754cd1f 1293 return -1;
6d50f529 1294 }
7754cd1f 1295
95867fd1 1296 return roc->GetStatus(col,row);
2745a409 1297
7754cd1f 1298}
1299
0e09df31 1300//_____________________________________________________________________________
1301AliTRDCalSingleChamberStatus* AliTRDcalibDB::GetPadStatusROC(Int_t det)
1302{
1303 //
1304 // Returns the pad status calibration object for a given ROC
1305 //
1306
1307 const AliTRDCalPadStatus *cal = dynamic_cast<const AliTRDCalPadStatus *>
1308 (GetCachedCDBObject(kIDPadStatus));
1309 if (!cal) {
1310 return 0;
1311 }
1312
1313 AliTRDCalSingleChamberStatus *roc = cal->GetCalROC(det);
1314 if (!roc) {
1315 return 0;
1316 }
1317 else {
1318 return roc;
1319 }
1320
1321}
1322
7754cd1f 1323//_____________________________________________________________________________
1324Char_t AliTRDcalibDB::GetChamberStatus(Int_t det)
1325{
1326 //
1327 // Returns the status of the given chamber
1328 //
1329
95867fd1 1330 const AliTRDCalChamberStatus *cal = dynamic_cast<const AliTRDCalChamberStatus *>
6d50f529 1331 (GetCachedCDBObject(kIDChamberStatus));
1332 if (!cal) {
7754cd1f 1333 return -1;
6d50f529 1334 }
7754cd1f 1335
1336 return cal->GetStatus(det);
2745a409 1337
7754cd1f 1338}
1339
a7ac01d2 1340//_____________________________________________________________________________
1341AliTRDrecoParam* AliTRDcalibDB::GetRecoParam(Int_t */*eventtype*/)
1342{
be28462a 1343 //
1344 // Returns the TRD reconstruction parameters from the OCDB
1345 //
1346
a7ac01d2 1347 const TClonesArray *recos = dynamic_cast<const TClonesArray*>(GetCachedCDBObject(kIDRecoParam));
be28462a 1348 if (!recos) return 0x0;
a7ac01d2 1349
1350 // calculate entry based on event type info
1351 Int_t n = 0; //f(eventtype[0], eventtype[1], ....)
be28462a 1352
ea3eaa08 1353 return (AliTRDrecoParam *) recos->UncheckedAt(n);
a7ac01d2 1354
be28462a 1355}
a7ac01d2 1356
7754cd1f 1357//_____________________________________________________________________________
1358Bool_t AliTRDcalibDB::IsPadMasked(Int_t det, Int_t col, Int_t row)
1359{
1360 //
1361 // Returns status, see name of functions for details ;-)
1362 //
1363
95867fd1 1364 const AliTRDCalPadStatus *cal = dynamic_cast<const AliTRDCalPadStatus *>
1365 (GetCachedCDBObject(kIDPadStatus));
6d50f529 1366 if (!cal) {
7754cd1f 1367 return -1;
6d50f529 1368 }
7754cd1f 1369
95867fd1 1370 return cal->IsMasked(det,col,row);
2745a409 1371
7754cd1f 1372}
1373
1374//_____________________________________________________________________________
1375Bool_t AliTRDcalibDB::IsPadBridgedLeft(Int_t det, Int_t col, Int_t row)
1376{
1377 //
1378 // Returns status, see name of functions for details ;-)
1379 //
1380
95867fd1 1381 const AliTRDCalPadStatus *cal = dynamic_cast<const AliTRDCalPadStatus *>
1382 (GetCachedCDBObject(kIDPadStatus));
6d50f529 1383 if (!cal) {
7754cd1f 1384 return -1;
6d50f529 1385 }
7754cd1f 1386
95867fd1 1387 return cal->IsBridgedLeft(det,col,row);
2745a409 1388
7754cd1f 1389}
1390
1391//_____________________________________________________________________________
1392Bool_t AliTRDcalibDB::IsPadBridgedRight(Int_t det, Int_t col, Int_t row)
1393{
1394 //
1395 // Returns status, see name of functions for details ;-)
1396 //
1397
95867fd1 1398 const AliTRDCalPadStatus * cal = dynamic_cast<const AliTRDCalPadStatus *>
1399 (GetCachedCDBObject(kIDPadStatus));
6d50f529 1400 if (!cal) {
7754cd1f 1401 return -1;
6d50f529 1402 }
7754cd1f 1403
95867fd1 1404 return cal->IsBridgedRight(det,col,row);
2745a409 1405
7754cd1f 1406}
1407
fa7427d0 1408//_____________________________________________________________________________
1409Bool_t AliTRDcalibDB::IsPadNotConnected(Int_t det, Int_t col, Int_t row)
1410{
1411 //
1412 // Returns status, see name of functions for details ;-)
1413 //
f1dcad37 1414
fa7427d0 1415 const AliTRDCalPadStatus * cal = dynamic_cast<const AliTRDCalPadStatus *>
1416 (GetCachedCDBObject(kIDPadStatus));
1417 if (!cal) {
1418 return -1;
1419 }
1420
1421 return cal->IsNotConnected(det,col,row);
1422
1423}
1424
7754cd1f 1425//_____________________________________________________________________________
eda91732 1426Bool_t AliTRDcalibDB::IsChamberGood(Int_t det)
1427{
1428 //
1429 // Returns status, see name of functions for details ;-)
1430 //
1431
1432 const AliTRDCalChamberStatus * cal = dynamic_cast<const AliTRDCalChamberStatus *>
1433 (GetCachedCDBObject(kIDChamberStatus));
1434 if (!cal) {
1435 return -1;
1436 }
1437
1438 return cal->IsGood(det);
1439
1440}
1441
1442//_____________________________________________________________________________
1443Bool_t AliTRDcalibDB::IsChamberNoData(Int_t det)
7754cd1f 1444{
1445 //
1446 // Returns status, see name of functions for details ;-)
1447 //
1448
95867fd1 1449 const AliTRDCalChamberStatus * cal = dynamic_cast<const AliTRDCalChamberStatus *>
1450 (GetCachedCDBObject(kIDChamberStatus));
6d50f529 1451 if (!cal) {
7754cd1f 1452 return -1;
6d50f529 1453 }
7754cd1f 1454
eda91732 1455 return cal->IsNoData(det);
2745a409 1456
7754cd1f 1457}
1458
1459//_____________________________________________________________________________
eda91732 1460Bool_t AliTRDcalibDB::IsHalfChamberNoData(Int_t det, Int_t side)
7754cd1f 1461{
1462 //
1463 // Returns status, see name of functions for details ;-)
1464 //
1465
95867fd1 1466 const AliTRDCalChamberStatus * cal = dynamic_cast<const AliTRDCalChamberStatus *>
1467 (GetCachedCDBObject(kIDChamberStatus));
6d50f529 1468 if (!cal) {
7754cd1f 1469 return -1;
6d50f529 1470 }
7754cd1f 1471
eda91732 1472 return side > 0 ? cal->IsNoDataSideB(det) : cal->IsNoDataSideA(det);
2745a409 1473
7754cd1f 1474}
ea3eaa08 1475
7a6352a6 1476//_____________________________________________________________________________
eda91732 1477Bool_t AliTRDcalibDB::IsChamberBadCalibrated(Int_t det)
ea3eaa08 1478{
7a6352a6 1479 //
1480 // Returns status, see name of functions for details ;-)
1481 //
7754cd1f 1482
7a6352a6 1483 const AliTRDCalChamberStatus * cal = dynamic_cast<const AliTRDCalChamberStatus *>
1484 (GetCachedCDBObject(kIDChamberStatus));
1485 if (!cal) {
1486 return -1;
1487 }
1488
eda91732 1489 return cal->IsBadCalibrated(det);
7a6352a6 1490
1491}
ea3eaa08 1492
cc7cef99 1493//_____________________________________________________________________________
0d83b3a5 1494const AliTRDCalPID *AliTRDcalibDB::GetPIDObject(AliTRDpidUtil::ETRDPIDMethod method)
cc7cef99 1495{
1496 //
1497 // Returns the object storing the distributions for PID with likelihood
1498 //
9a96f175 1499
1500 switch(method) {
0d83b3a5 1501 case AliTRDpidUtil::kLQ:
4ba1d6ae 1502 return dynamic_cast<const AliTRDCalPID *>(GetCachedCDBObject(kIDPIDLQ));
0d83b3a5 1503 case AliTRDpidUtil::kNN:
4ba1d6ae 1504 return dynamic_cast<const AliTRDCalPID *>(GetCachedCDBObject(kIDPIDNN));
543691ea 1505 case AliTRDpidUtil::kESD:
1506 return 0x0; // To avoid compiler warnings
9a96f175 1507 }
1508
10f75631 1509 return 0x0;
2745a409 1510
cc7cef99 1511}
1512
9dcc64cc 1513//_____________________________________________________________________________
ea3eaa08 1514AliTRDPIDResponse *AliTRDcalibDB::GetPIDResponse(AliTRDPIDResponse::ETRDPIDMethod method)
1515{
1516 //
1517 // Returns the PID response object for 1D-LQ
1518 //
1519
1520 if (!fPIDResponse) {
1521
9dcc64cc 1522 fPIDResponse = new AliTRDPIDResponse;
ea3eaa08 1523
9dcc64cc 1524 // Load Reference Histos from OCDB
1525 fPIDResponse->SetPIDmethod(method);
51a0ce25 1526 const TObjArray *references = dynamic_cast<const TObjArray *>(GetCachedCDBObject(kIDPIDLQ1D));
ea3eaa08 1527
51a0ce25 1528 TIter refs(references);
1529 TObject *obj = NULL;
1530 AliTRDPIDReference *ref = NULL;
1531 Bool_t hasReference = kFALSE;
ea3eaa08 1532 while ((obj = refs())){
1533 if ((ref = dynamic_cast<AliTRDPIDReference *>(obj))){
1534 fPIDResponse->Load(ref);
1535 hasReference = kTRUE;
1536 break;
1537 }
51a0ce25 1538 }
ea3eaa08 1539
1540 if (!hasReference) {
1541 AliError("Reference histograms not found in the OCDB");
1542 }
1543
9dcc64cc 1544 }
ea3eaa08 1545
9dcc64cc 1546 return fPIDResponse;
ea3eaa08 1547
9dcc64cc 1548}
1549
1550//_____________________________________________________________________________
1551const AliTRDCalTrkAttach* AliTRDcalibDB::GetAttachObject()
1552{
1553 //
1554 // Returns the object storing likelihood distributions for cluster to track attachment
1555 //
ea3eaa08 1556
9dcc64cc 1557 return dynamic_cast<const AliTRDCalTrkAttach*>(GetCachedCDBObject(kIDAttach));
9dcc64cc 1558
ea3eaa08 1559}
9dcc64cc 1560
7754cd1f 1561//_____________________________________________________________________________
d4c6453d 1562const AliTRDCalMonitoring *AliTRDcalibDB::GetMonitoringObject()
7754cd1f 1563{
1564 //
1565 // Returns the object storing the monitoring data
1566 //
1567
d4c6453d 1568 return dynamic_cast<const AliTRDCalMonitoring *>
1569 (GetCachedCDBObject(kIDMonitoringData));
1b95a37b 1570
7754cd1f 1571}
1572
6a739e92 1573//_____________________________________________________________________________
1574void AliTRDcalibDB::SamplePRF()
1575{
1576 //
2745a409 1577 // Samples the pad response function (should maybe go somewhere else ...)
6a739e92 1578 //
1579
1580 const Int_t kPRFbin = 61;
1581
053767a4 1582 Float_t prf[kNlayer][kPRFbin] = {
6d50f529 1583 {2.9037e-02, 3.3608e-02, 3.9020e-02, 4.5292e-02,
6a739e92 1584 5.2694e-02, 6.1362e-02, 7.1461e-02, 8.3362e-02,
1585 9.7063e-02, 1.1307e-01, 1.3140e-01, 1.5235e-01,
1586 1.7623e-01, 2.0290e-01, 2.3294e-01, 2.6586e-01,
1587 3.0177e-01, 3.4028e-01, 3.8077e-01, 4.2267e-01,
1588 4.6493e-01, 5.0657e-01, 5.4655e-01, 5.8397e-01,
1589 6.1767e-01, 6.4744e-01, 6.7212e-01, 6.9188e-01,
1590 7.0627e-01, 7.1499e-01, 7.1851e-01, 7.1499e-01,
1591 7.0627e-01, 6.9188e-01, 6.7212e-01, 6.4744e-01,
1592 6.1767e-01, 5.8397e-01, 5.4655e-01, 5.0657e-01,
1593 4.6493e-01, 4.2267e-01, 3.8077e-01, 3.4028e-01,
1594 3.0177e-01, 2.6586e-01, 2.3294e-01, 2.0290e-01,
1595 1.7623e-01, 1.5235e-01, 1.3140e-01, 1.1307e-01,
1596 9.7063e-02, 8.3362e-02, 7.1461e-02, 6.1362e-02,
1597 5.2694e-02, 4.5292e-02, 3.9020e-02, 3.3608e-02,
1598 2.9037e-02},
1599 {2.5478e-02, 2.9695e-02, 3.4655e-02, 4.0454e-02,
1600 4.7342e-02, 5.5487e-02, 6.5038e-02, 7.6378e-02,
1601 8.9696e-02, 1.0516e-01, 1.2327e-01, 1.4415e-01,
1602 1.6794e-01, 1.9516e-01, 2.2573e-01, 2.5959e-01,
1603 2.9694e-01, 3.3719e-01, 3.7978e-01, 4.2407e-01,
1604 4.6889e-01, 5.1322e-01, 5.5569e-01, 5.9535e-01,
1605 6.3141e-01, 6.6259e-01, 6.8882e-01, 7.0983e-01,
1606 7.2471e-01, 7.3398e-01, 7.3761e-01, 7.3398e-01,
1607 7.2471e-01, 7.0983e-01, 6.8882e-01, 6.6259e-01,
1608 6.3141e-01, 5.9535e-01, 5.5569e-01, 5.1322e-01,
1609 4.6889e-01, 4.2407e-01, 3.7978e-01, 3.3719e-01,
1610 2.9694e-01, 2.5959e-01, 2.2573e-01, 1.9516e-01,
1611 1.6794e-01, 1.4415e-01, 1.2327e-01, 1.0516e-01,
1612 8.9696e-02, 7.6378e-02, 6.5038e-02, 5.5487e-02,
1613 4.7342e-02, 4.0454e-02, 3.4655e-02, 2.9695e-02,
1614 2.5478e-02},
1615 {2.2363e-02, 2.6233e-02, 3.0782e-02, 3.6140e-02,
1616 4.2535e-02, 5.0157e-02, 5.9197e-02, 6.9900e-02,
1617 8.2707e-02, 9.7811e-02, 1.1548e-01, 1.3601e-01,
1618 1.5998e-01, 1.8739e-01, 2.1840e-01, 2.5318e-01,
1619 2.9182e-01, 3.3373e-01, 3.7837e-01, 4.2498e-01,
1620 4.7235e-01, 5.1918e-01, 5.6426e-01, 6.0621e-01,
1621 6.4399e-01, 6.7700e-01, 7.0472e-01, 7.2637e-01,
1622 7.4206e-01, 7.5179e-01, 7.5551e-01, 7.5179e-01,
1623 7.4206e-01, 7.2637e-01, 7.0472e-01, 6.7700e-01,
1624 6.4399e-01, 6.0621e-01, 5.6426e-01, 5.1918e-01,
1625 4.7235e-01, 4.2498e-01, 3.7837e-01, 3.3373e-01,
1626 2.9182e-01, 2.5318e-01, 2.1840e-01, 1.8739e-01,
1627 1.5998e-01, 1.3601e-01, 1.1548e-01, 9.7811e-02,
1628 8.2707e-02, 6.9900e-02, 5.9197e-02, 5.0157e-02,
1629 4.2535e-02, 3.6140e-02, 3.0782e-02, 2.6233e-02,
1630 2.2363e-02},
1631 {1.9635e-02, 2.3167e-02, 2.7343e-02, 3.2293e-02,
1632 3.8224e-02, 4.5335e-02, 5.3849e-02, 6.4039e-02,
1633 7.6210e-02, 9.0739e-02, 1.0805e-01, 1.2841e-01,
1634 1.5216e-01, 1.7960e-01, 2.1099e-01, 2.4671e-01,
1635 2.8647e-01, 3.2996e-01, 3.7660e-01, 4.2547e-01,
1636 4.7536e-01, 5.2473e-01, 5.7215e-01, 6.1632e-01,
1637 6.5616e-01, 6.9075e-01, 7.1939e-01, 7.4199e-01,
1638 7.5838e-01, 7.6848e-01, 7.7227e-01, 7.6848e-01,
1639 7.5838e-01, 7.4199e-01, 7.1939e-01, 6.9075e-01,
1640 6.5616e-01, 6.1632e-01, 5.7215e-01, 5.2473e-01,
1641 4.7536e-01, 4.2547e-01, 3.7660e-01, 3.2996e-01,
1642 2.8647e-01, 2.4671e-01, 2.1099e-01, 1.7960e-01,
1643 1.5216e-01, 1.2841e-01, 1.0805e-01, 9.0739e-02,
1644 7.6210e-02, 6.4039e-02, 5.3849e-02, 4.5335e-02,
1645 3.8224e-02, 3.2293e-02, 2.7343e-02, 2.3167e-02,
1646 1.9635e-02},
1647 {1.7224e-02, 2.0450e-02, 2.4286e-02, 2.8860e-02,
1648 3.4357e-02, 4.0979e-02, 4.8966e-02, 5.8612e-02,
1649 7.0253e-02, 8.4257e-02, 1.0102e-01, 1.2094e-01,
1650 1.4442e-01, 1.7196e-01, 2.0381e-01, 2.4013e-01,
1651 2.8093e-01, 3.2594e-01, 3.7450e-01, 4.2563e-01,
1652 4.7796e-01, 5.2991e-01, 5.7974e-01, 6.2599e-01,
1653 6.6750e-01, 7.0344e-01, 7.3329e-01, 7.5676e-01,
1654 7.7371e-01, 7.8410e-01, 7.8793e-01, 7.8410e-01,
1655 7.7371e-01, 7.5676e-01, 7.3329e-01, 7.0344e-01,
1656 6.6750e-01, 6.2599e-01, 5.7974e-01, 5.2991e-01,
1657 4.7796e-01, 4.2563e-01, 3.7450e-01, 3.2594e-01,
1658 2.8093e-01, 2.4013e-01, 2.0381e-01, 1.7196e-01,
1659 1.4442e-01, 1.2094e-01, 1.0102e-01, 8.4257e-02,
1660 7.0253e-02, 5.8612e-02, 4.8966e-02, 4.0979e-02,
1661 3.4357e-02, 2.8860e-02, 2.4286e-02, 2.0450e-02,
1662 1.7224e-02},
1663 {1.5096e-02, 1.8041e-02, 2.1566e-02, 2.5793e-02,
1664 3.0886e-02, 3.7044e-02, 4.4515e-02, 5.3604e-02,
1665 6.4668e-02, 7.8109e-02, 9.4364e-02, 1.1389e-01,
1666 1.3716e-01, 1.6461e-01, 1.9663e-01, 2.3350e-01,
1667 2.7527e-01, 3.2170e-01, 3.7214e-01, 4.2549e-01,
1668 4.8024e-01, 5.3460e-01, 5.8677e-01, 6.3512e-01,
1669 6.7838e-01, 7.1569e-01, 7.4655e-01, 7.7071e-01,
1670 7.8810e-01, 7.9871e-01, 8.0255e-01, 7.9871e-01,
1671 7.8810e-01, 7.7071e-01, 7.4655e-01, 7.1569e-01,
1672 6.7838e-01, 6.3512e-01, 5.8677e-01, 5.3460e-01,
1673 4.8024e-01, 4.2549e-01, 3.7214e-01, 3.2170e-01,
1674 2.7527e-01, 2.3350e-01, 1.9663e-01, 1.6461e-01,
1675 1.3716e-01, 1.1389e-01, 9.4364e-02, 7.8109e-02,
1676 6.4668e-02, 5.3604e-02, 4.4515e-02, 3.7044e-02,
1677 3.0886e-02, 2.5793e-02, 2.1566e-02, 1.8041e-02,
1678 1.5096e-02}};
1679
1680 // More sampling precision with linear interpolation
6d50f529 1681 fPRFlo = -1.5;
1682 fPRFhi = 1.5;
6a739e92 1683 Float_t pad[kPRFbin];
1684 Int_t sPRFbin = kPRFbin;
6d50f529 1685 Float_t sPRFwid = (fPRFhi - fPRFlo) / ((Float_t) sPRFbin);
6a739e92 1686 for (Int_t iPad = 0; iPad < sPRFbin; iPad++) {
6d50f529 1687 pad[iPad] = ((Float_t) iPad + 0.5) * sPRFwid + fPRFlo;
6a739e92 1688 }
6d50f529 1689 fPRFbin = 500;
1690 fPRFwid = (fPRFhi - fPRFlo) / ((Float_t) fPRFbin);
1691 fPRFpad = ((Int_t) (1.0 / fPRFwid));
6a739e92 1692
6d50f529 1693 if (fPRFsmp) delete [] fPRFsmp;
053767a4 1694 fPRFsmp = new Float_t[kNlayer*fPRFbin];
6a739e92 1695
1696 Int_t ipos1;
1697 Int_t ipos2;
1698 Float_t diff;
1699
053767a4 1700 for (Int_t iLayer = 0; iLayer < kNlayer; iLayer++) {
6a739e92 1701
6d50f529 1702 for (Int_t iBin = 0; iBin < fPRFbin; iBin++) {
6a739e92 1703
6d50f529 1704 Float_t bin = (((Float_t) iBin) + 0.5) * fPRFwid + fPRFlo;
6a739e92 1705 ipos1 = ipos2 = 0;
1706 diff = 0;
1707 do {
1708 diff = bin - pad[ipos2++];
1709 } while ((diff > 0) && (ipos2 < kPRFbin));
1710 if (ipos2 == kPRFbin) {
053767a4 1711 fPRFsmp[iLayer*fPRFbin+iBin] = prf[iLayer][ipos2-1];
6a739e92 1712 }
1713 else if (ipos2 == 1) {
053767a4 1714 fPRFsmp[iLayer*fPRFbin+iBin] = prf[iLayer][ipos2-1];
6a739e92 1715 }
1716 else {
1717 ipos2--;
1718 if (ipos2 >= kPRFbin) ipos2 = kPRFbin - 1;
1719 ipos1 = ipos2 - 1;
053767a4 1720 fPRFsmp[iLayer*fPRFbin+iBin] = prf[iLayer][ipos2]
1721 + diff * (prf[iLayer][ipos2] - prf[iLayer][ipos1])
1722 / sPRFwid;
6a739e92 1723 }
1724
1725 }
1726 }
1727
1728}
1729
1730//_____________________________________________________________________________
1731Int_t AliTRDcalibDB::PadResponse(Double_t signal, Double_t dist
eb52b657 1732 , Int_t layer, Double_t *pad) const
6a739e92 1733{
1734 //
1735 // Applies the pad response
56178ff4 1736 // So far this is the fixed parametrization and should be replaced by
1737 // something dependent on calibration values
6a739e92 1738 //
1739
eb52b657 1740 Int_t iBin = ((Int_t) ((-dist - fPRFlo) / fPRFwid));
053767a4 1741 Int_t iOff = layer * fPRFbin;
6a739e92 1742
6d50f529 1743 Int_t iBin0 = iBin - fPRFpad + iOff;
6a739e92 1744 Int_t iBin1 = iBin + iOff;
6d50f529 1745 Int_t iBin2 = iBin + fPRFpad + iOff;
6a739e92 1746
1747 pad[0] = 0.0;
1748 pad[1] = 0.0;
1749 pad[2] = 0.0;
053767a4 1750 if ((iBin1 >= 0) && (iBin1 < (fPRFbin*kNlayer))) {
6a739e92 1751
1752 if (iBin0 >= 0) {
6d50f529 1753 pad[0] = signal * fPRFsmp[iBin0];
6a739e92 1754 }
6d50f529 1755 pad[1] = signal * fPRFsmp[iBin1];
053767a4 1756 if (iBin2 < (fPRFbin*kNlayer)) {
6d50f529 1757 pad[2] = signal * fPRFsmp[iBin2];
6a739e92 1758 }
1759
1760 return 1;
1761
1762 }
1763 else {
1764
1765 return 0;
1766
1767 }
ab0a4106 1768
3551db50 1769}
7a6352a6 1770
1771
a9e22145 1772AliTRDtrapConfig* AliTRDcalibDB::GetTrapConfig()
1773{
1774 // return an existing TRAPconfig or load it from the OCDB
1775 // in case of failure, a default TRAPconfig is created
1776
1777 if (fTrapConfig)
1778 return fTrapConfig;
1779 else {
1b1afdd3 1780 if ((fTrapConfigName.Length() <= 0) || (fTrapConfigVersion.Length() <= 0)) {
1781 // query the configuration to be used
1782 TString configName;
1783 this->GetGlobalConfiguration(configName);
1784 TString configVersion;
1785 this->GetGlobalConfigurationVersion(configVersion);
1786 }
a9e22145 1787
1b1afdd3 1788 // try to load the requested configuration
1789 this->LoadTrapConfig(fTrapConfigName, fTrapConfigVersion);
a9e22145 1790
1791 // if we still don't have a valid TRAPconfig, create a default one
1792 if (!fTrapConfig) {
1793 AliWarning("Falling back to default configuration");
1794 fTrapConfig = new AliTRDtrapConfig("default", "default TRAP configuration");
1795 AliTRDtrapConfigHandler cfgHandler(fTrapConfig);
1796 cfgHandler.Init();
1797 cfgHandler.LoadConfig();
1798 }
1799
1800 AliInfo(Form("using TRAPconfig \"%s\"", fTrapConfig->GetTitle()));
1801
1802 return fTrapConfig;
1803 }
1804}
1805
1806
1807AliTRDtrapConfig* AliTRDcalibDB::LoadTrapConfig(const TString &name, const TString &version)
1808{
1809 // try to load the specified configuration from the OCDB
1810 // if it fails, or it does not exist, return null
1811
1812 AliInfo(Form("looking for TRAPconfig \"%s.%s\"", name.Data(), version.Data()));
1813
1814 const AliTRDCalTrapConfig *caltrap = dynamic_cast<const AliTRDCalTrapConfig*> (GetCachedCDBObject(kIDTrapConfig));
1815
1816 if (caltrap) {
1817 TString configName(name);
1818 configName.Append(".");
1819 configName.Append(version);
1820 fTrapConfig = caltrap->Get(configName);
1821 }
1822 else {
1823 fTrapConfig = 0x0;
1824 AliError("No TRAPconfig entry found!");
1825 }
1826
1827 return fTrapConfig;
1828}