New InvalidFloatValue() method (Laurent)
[u/mrichter/AliRoot.git] / MUON / MUONCDB.C
CommitLineData
b3c7c475 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/// By Laurent Aphecetche
19
20#if !defined(__CINT__) || defined(__MAKECINT__)
d29760d6 21
b3c7c475 22#include "MUONCDB.h"
d29760d6 23
b3c7c475 24#include "AliCDBEntry.h"
25#include "AliCDBManager.h"
d29760d6 26#include "AliMUON1DArray.h"
8f7d7575 27#include "AliMUON2DMap.h"
8f7d7575 28#include "AliMUONCalibParam1I.h"
29#include "AliMUONCalibParam2F.h"
d29760d6 30#include "AliMUONConstants.h"
31#include "AliMUONTriggerLut.h"
32#include "AliMUONV2DStore.h"
33#include "AliMUONVCalibParam.h"
b3c7c475 34#include "AliMpDEIterator.h"
35#include "AliMpDEManager.h"
b3c7c475 36#include "AliMpSegFactory.h"
37#include "AliMpStationType.h"
38#include "AliMpVSegmentation.h"
d29760d6 39#include "AliMUONTriggerEfficiencyCells.h"
b3c7c475 40#include "Riostream.h"
41#include "TH1F.h"
42#include "TList.h"
43#include "TRandom.h"
44#include "TStopwatch.h"
45#include "TSystem.h"
46#endif
47
d29760d6 48//_____________________________________________________________________________
49Int_t countChannels(AliMpVSegmentation& seg)
50{
51 Int_t n(0);
52
53 for ( Int_t ix = 0; ix < seg.MaxPadIndexX(); ++ix )
54 {
55 for ( Int_t iy = 0; iy < seg.MaxPadIndexY(); ++iy )
56 {
57 if ( seg.HasPad(AliMpIntPair(ix,iy)) ) ++n;
58 }
59 }
60 return n;
61}
b3c7c475 62
63//_____________________________________________________________________________
64AliMpSegFactory* segFactory()
65{
66 static AliMpSegFactory* sf = new AliMpSegFactory();
67 return sf;
68}
69
70//_____________________________________________________________________________
d29760d6 71void countChannels()
72{
73 AliMpDEIterator it;
74 Int_t ntotal(0);
75 Int_t ntracker(0);
76 Int_t ntrigger(0);
77
78 for ( Int_t station = 0; station < AliMUONConstants::NCh(); ++station )
79 {
80 Int_t n(0);
81 it.First(station);
82 while (!it.IsDone())
83 {
84 Int_t de = it.CurrentDE();
85 for ( Int_t cathode = 0; cathode < 2; ++cathode )
86 {
87 AliMpVSegmentation* seg = segFactory()->CreateMpSegmentation(de,cathode);
88 n += countChannels(*seg);
89 }
90 it.Next();
91 }
92 cout << "Station " << station << " has " << n << " channels" << endl;
93 if ( station < AliMUONConstants::NTrackingCh() )
94 {
95 ntracker += n;
96 }
97 else
98 {
99 ntrigger += n;
100 }
101 ntotal += n;
102 }
103 cout << "Tracker channels = " << ntracker << endl;
104 cout << "Trigger channels = " << ntrigger << endl;
105 cout << "Total channels =" << ntotal << endl;
106}
107
108//_____________________________________________________________________________
109AliMUONV2DStore* read2D(const char* calibType)
b3c7c475 110{
111 AliCDBManager* man = AliCDBManager::Instance();
112 man->SetDefaultStorage(CDBPath);
113
114 AliCDBEntry* entry = man->Get(calibType,0);
115
116 if (entry)
117 {
8f7d7575 118 return (AliMUONV2DStore*)entry->GetObject();
b3c7c475 119 }
120 return 0;
121}
122
123//_____________________________________________________________________________
d29760d6 124AliMUONV1DStore* read1D(const char* calibType)
125{
126 AliCDBManager* man = AliCDBManager::Instance();
127 man->SetDefaultStorage(CDBPath);
128
129 AliCDBEntry* entry = man->Get(calibType,0);
130
131 if (entry)
132 {
133 return (AliMUONV1DStore*)entry->GetObject();
134 }
135 return 0;
136}
137
138//_____________________________________________________________________________
8f7d7575 139void checkCDB(const char* calibType)
140{
141 TString c(calibType);
142 Float_t refValue(0);
143
144 if ( c == "MUON/Calib/DeadChannels" )
145 {
146 refValue=5;
147 }
148
d29760d6 149 AliMUONV2DStore* store = read2D(calibType);
8f7d7575 150 if (!store) return;
151
152 TIter next(manuList());
153 AliMpIntPair* p;
154
155 while ( ( p = (AliMpIntPair*)next() ) )
156 {
157 Int_t detElemId = p->GetFirst();
158 Int_t manuId = p->GetSecond();
159
160 AliMUONVCalibParam* value =
161 dynamic_cast<AliMUONVCalibParam*>(store->Get(detElemId,manuId));
162
163 if (value)
164 {
165 for ( Int_t manuChannel = 0; manuChannel < value->Size(); ++manuChannel )
166 {
167 Float_t testValue = value->ValueAsFloat(manuChannel,0);
168 if ( testValue && testValue != refValue )
169 {
170 cout << "Got a strange value for DE=" << detElemId << " manuId="
171 << manuId << " manuChannel=" << manuChannel << " was expecting "
172 << refValue << " and I got " << testValue << endl;
173 }
174 }
175 }
176 else
177 {
178 cout << "Got a null value for DE=" << detElemId << " manuId="
179 << manuId << endl;
180 }
181 }
182
183 delete store;
184}
185
186
187//_____________________________________________________________________________
188void plotCDB(const char* calibType)
b3c7c475 189{
190 TString c(calibType);
191
192 TH1* h = 0;
8f7d7575 193 TH1* h2 = 0;
b3c7c475 194
195 if ( c == "MUON/Calib/Gains" )
196 {
8f7d7575 197 h = new TH1F("gains_mean","mean gain",100,0,1.5);
198 h2 = new TH1F("saturation","adc saturation",4096,-0.5,4095.5);
b3c7c475 199 }
200 else if ( c == "MUON/Calib/Pedestals" )
201 {
8f7d7575 202 h = new TH1F("pedestals_mean","pedestals_mean",4096,-0.5,4095.5);
203 h2 = new TH1F("pedestals_sigma","pedestals_sigma",100,0,20);
204 }
205 else if ( c == "MUON/Calib/DeadChannels" )
206 {
207 h = new TH1F("dead_channels","dead channels per DE",1500,-0.5,1499.5);
b3c7c475 208 }
209 else
210 {
211 cerr << "Don't know how to deal with " << calibType << endl;
212 return;
213 }
214
d29760d6 215 AliMUONV2DStore* store = read2D(calibType);
b3c7c475 216 if (!store) return;
217
8f7d7575 218 TIter next(manuList());
219 AliMpIntPair* p;
220 Int_t n(0);
221 Int_t ndead(0);
222 Int_t nPerStation[7];
223
224 for ( Int_t i = 0; i < 7; ++i ) nPerStation[i]=0;
b3c7c475 225
8f7d7575 226 while ( ( p = (AliMpIntPair*)next() ) )
b3c7c475 227 {
8f7d7575 228 Int_t detElemId = p->GetFirst();
229 Int_t manuId = p->GetSecond();
66f4c572 230 Int_t station = AliMpDEmanager::GetChamberId(detElemId);
8f7d7575 231
232 AliMUONVCalibParam* value =
233 dynamic_cast<AliMUONVCalibParam*>(store->Get(detElemId,manuId));
b3c7c475 234
b3c7c475 235 if (value)
236 {
8f7d7575 237 for ( Int_t manuChannel = 0; manuChannel < value->Size(); ++manuChannel )
238 {
239 ++n;
240 ++nPerStation[station];
241 if (h2)
242 {
243 h->Fill(value->ValueAsFloat(manuChannel,0));
244 h2->Fill(value->ValueAsFloat(manuChannel,1));
245 }
246 else
247 {
248 if( value->ValueAsInt(manuChannel) )
249 {
250 h->Fill(detElemId);
251 ++ndead;
252 }
253 }
254 }
b3c7c475 255 }
256 else
257 {
258 cout << "Got a null value for DE=" << detElemId << " manuId="
8f7d7575 259 << manuId << endl;
b3c7c475 260 }
261 }
262
8f7d7575 263 cout << "Number of channels = " << n << endl;
264 for ( Int_t i = 0; i < 7; ++i )
265 {
266 cout << "Station " << (i+1) << " " << nPerStation[i] << endl;
267 }
268
269 if (n && c == "MUON/Calib/DeadChannels")
270 {
271 cout << "Number of dead channels=" << ndead << endl;
272 }
b3c7c475 273 delete store;
274}
275
276//_____________________________________________________________________________
8f7d7575 277void testReadStore(const AliMUONV2DStore& store, Int_t n)
b3c7c475 278{
8f7d7575 279 TIter next(manuList());
280 AliMpIntPair* p;
b3c7c475 281
8f7d7575 282 while ( ( p = (AliMpIntPair*)next() ) )
b3c7c475 283 {
284 for ( Int_t i = 0; i < n; ++i )
285 {
8f7d7575 286 store.Get(p->GetFirst(),p->GetSecond());
b3c7c475 287 }
288 }
289}
290
291//_____________________________________________________________________________
8f7d7575 292Int_t makeStores(AliMUONV2DStore& pedestalStore,
293 AliMUONV2DStore& gainStore,
294 AliMUONV2DStore& deadStore,
b3c7c475 295 Bool_t defaultValues)
296{
8f7d7575 297 TIter next(manuList());
b3c7c475 298
8f7d7575 299 AliMpIntPair* p;
b3c7c475 300
301 Int_t ngenerated(0);
302
303 Bool_t replace = kFALSE;
304
8f7d7575 305 const Int_t nChannels(64);
306
307 while ( ( p = (AliMpIntPair*)next() ) )
b3c7c475 308 {
8f7d7575 309 AliMUONVCalibParam* ped = new AliMUONCalibParam2F(nChannels);
310 AliMUONVCalibParam* gain = new AliMUONCalibParam2F(nChannels);
311 AliMUONVCalibParam* dead = new AliMUONCalibParam1I(nChannels);
312
313 for ( Int_t manuChannel = 0; manuChannel < nChannels; ++manuChannel )
b3c7c475 314 {
8f7d7575 315 Float_t meanPedestal;
316 Float_t sigmaPedestal;
317 Float_t meanGain;
318 Float_t saturation(3000);
319
320 if ( defaultValues )
b3c7c475 321 {
8f7d7575 322 meanPedestal = 0.0;
323 sigmaPedestal = 1.0;
324 meanGain = 1.0;
b3c7c475 325 }
8f7d7575 326 else
b3c7c475 327 {
8f7d7575 328 meanPedestal = -1;
329 while ( meanPedestal < 0 )
330 {
331 meanPedestal = gRandom->Gaus(150,10);
332 }
333 sigmaPedestal = -1;
334 while ( sigmaPedestal < 0 )
335 {
336 sigmaPedestal = gRandom->Gaus(1,0.2);
337 }
338 meanGain = -1;
339 while ( meanGain < 0 )
340 {
341 meanGain = gRandom->Gaus(1,0.05);
342 }
b3c7c475 343 }
8f7d7575 344 ped->SetValueAsFloat(manuChannel,0,meanPedestal);
345 ped->SetValueAsFloat(manuChannel,1,sigmaPedestal);
346 gain->SetValueAsFloat(manuChannel,0,meanGain);
347 gain->SetValueAsFloat(manuChannel,1,saturation);
348
349 if (!defaultValues)
b3c7c475 350 {
8f7d7575 351 // probability that this channel is dead ~ 1%
352 if ( gRandom->Uniform(100.0) < 1.0 )
353 {
354 Int_t reason = 5; // that value could be used to distinguish
355 // why the channel is dead or how it was flagged bad (online,
356 // offline, by chance...). 5 is of course a fake number.
357 dead->SetValueAsInt(manuChannel,0,reason);
358 }
b3c7c475 359 }
360 }
8f7d7575 361 Int_t detElemId = p->GetFirst();
362 Int_t manuId = p->GetSecond();
363 Bool_t ok1 = pedestalStore.Set(detElemId,manuId,ped,replace);
364 Bool_t ok2 = gainStore.Set(detElemId,manuId,gain,replace);
365 Bool_t ok3 = deadStore.Set(detElemId,manuId,dead,replace);
366 if (!ok1 || !ok2 || !ok3)
b3c7c475 367 {
368 cout << "Could not set DetElemId=" << detElemId << " manuId="
8f7d7575 369 << manuId << endl;
b3c7c475 370 }
371 else
372 {
373 ++ngenerated;
374 }
375 }
376
377 return ngenerated;
378}
379
380//_____________________________________________________________________________
8f7d7575 381TList* manuList(Bool_t reset)
b3c7c475 382{
8f7d7575 383 static TList* fgmanuList = new TList;
b3c7c475 384
385 if (reset)
386 {
8f7d7575 387 fgmanuList->Delete();
388 return fgmanuList;
b3c7c475 389 }
390
8f7d7575 391 if (!fgmanuList->IsEmpty()) return fgmanuList;
b3c7c475 392
393 TStopwatch timer;
394
8f7d7575 395 cout << "Generating manu list. Please wait" << endl;
b3c7c475 396
8f7d7575 397 fgmanuList->SetOwner(kTRUE);
b3c7c475 398
399 timer.Start();
400
401 AliMpDEIterator it;
402
403 it.First();
404
405 while ( !it.IsDone() )
406 {
407 Int_t detElemId = it.CurrentDE();
408 AliMpStationType stationType = AliMpDEManager::GetStationType(detElemId);
409 if ( stationType != kStationTrigger )
410 {
411 for ( Int_t cath = 0; cath <=1 ; ++cath )
412 {
413 AliMpVSegmentation* seg = segFactory()->CreateMpSegmentation(detElemId,cath);
b3c7c475 414
8f7d7575 415 TArrayI manus;
416
417 seg->GetAllElectronicCardIDs(manus);
418
419 for ( Int_t im = 0; im < manus.GetSize(); ++im )
420 {
421 fgmanuList->Add(new AliMpIntPair(detElemId,manus[im]));
422 }
b3c7c475 423 }
424 }
425 it.Next();
426 }
427
8f7d7575 428 cout << "Time to make the manu list = ";
b3c7c475 429 timer.Print();
430
8f7d7575 431 return fgmanuList;
b3c7c475 432}
433
434//_____________________________________________________________________________
8f7d7575 435void testMakeStores(Int_t readLoop)
b3c7c475 436{
8f7d7575 437 manuList();
b3c7c475 438
8f7d7575 439 AliMUONV2DStore* pedestalStore = new AliMUON2DMap;
440 AliMUONV2DStore* gainStore = new AliMUON2DMap;
441 AliMUONV2DStore* deadStore = new AliMUON2DMap;
b3c7c475 442
443 TStopwatch timer;
444
445 cout << "Creating" << endl;
446
447 timer.Start(kTRUE);
8f7d7575 448 makeStores(*pedestalStore,*gainStore,*deadStore,true);
b3c7c475 449 timer.Print();
450
451 cout << "Reading..." << endl;
452 timer.Start(kTRUE);
453 testReadStore(*pedestalStore,readLoop);
454 testReadStore(*gainStore,readLoop);
8f7d7575 455 testReadStore(*deadStore,readLoop);
b3c7c475 456 cout << timer.CpuTime()/readLoop << " CPUs (mean of " << readLoop
457 <<" samples." << endl;
458
459 delete pedestalStore;
460 delete gainStore;
8f7d7575 461 delete deadStore;
b3c7c475 462}
463
464//_____________________________________________________________________________
d29760d6 465void generateTrigger(const char* cdbpath)
466{
467 //
468 // Generate trigger related conditions :
469 //
470 // - trigger masks for board (locals, regionals, global)
471 // - trigger lut
472 // - trigger efficiency
473 // - trigger switches (to be implemented FIXME)
474 //
475 const Int_t nlboards = 234;
476 AliMUONV1DStore* localBoardMasks = new AliMUON1DArray(nlboards+1);
477
478 // Generate fake mask values for 234 localboards and put that into
479 // one single container (localBoardMasks)
480 for ( Int_t i = 1; i <= nlboards; ++i )
481 {
482 AliMUONVCalibParam* localBoard = new AliMUONCalibParam1I(8);
483 for ( Int_t x = 0; x < 2; ++x )
484 {
485 for ( Int_t y = 0; y < 4; ++y )
486 {
487 Int_t index = x*4+y;
488 localBoard->SetValueAsInt(index,0,0xFFFF);
489 }
490 }
491 localBoardMasks->Set(i,localBoard,kFALSE);
492 }
493
494 // Generate values for regional boards
495 const Int_t nrboards = 16;
496 AliMUONV1DStore* regionalBoardMasks = new AliMUON1DArray(16);
497
498 for ( Int_t i = 0; i < nrboards; ++i )
499 {
500 AliMUONVCalibParam* regionalBoard = new AliMUONCalibParam1I(16);
501 for ( Int_t j = 0; j < 16; ++j )
502 {
503 regionalBoard->SetValueAsInt(j,0,0x3F);
504 }
505 regionalBoardMasks->Set(i,regionalBoard,kFALSE);
506 }
507
508 // Generate values for global board
509 AliMUONVCalibParam* globalBoardMasks = new AliMUONCalibParam1I(16);
510
511 for ( Int_t j = 0; j < 16; ++j )
512 {
513 globalBoardMasks->SetValueAsInt(j,0,0xFFF);
514 }
515
516 AliMUONTriggerLut lut;
bc6da0f1 517 lut.ReadFromFile("$(ALICE_ROOT)/MUON/data/lutAptLpt1Hpt1p7.root");
d29760d6 518
519 AliMUONTriggerEfficiencyCells cells("$ALICE_ROOT/MUON/data/efficiencyCells.dat");
520
521 //--------------------------------------------
522 // Store the resulting containers into the CDB
523 Int_t ever = 99999999;
524
525 AliCDBId id("MUON/Calib/LocalTriggerBoardMasks",0,ever);
526
527 AliCDBMetaData md;
528 md.SetBeamPeriod(1);
529 md.SetAliRootVersion(gROOT->GetVersion());
530 md.SetComment("Test with default values");
531 md.SetResponsible("Rachid Guernane");
532
533 AliCDBManager* man = AliCDBManager::Instance();
534 man->SetDefaultStorage(cdbpath);
535 man->Put(localBoardMasks,id,&md);
536
537 id.SetPath("MUON/Calib/RegionalTriggerBoardMasks");
538
539 man->Put(regionalBoardMasks,id,(AliCDBMetaData*)md.Clone());
540
541 id.SetPath("MUON/Calib/GlobalTriggerBoardMasks");
542
543 man->Put(globalBoardMasks,id,(AliCDBMetaData*)md.Clone());
544
545 id.SetPath("MUON/Calib/TriggerLut");
546
547 man->Put(&lut,id,(AliCDBMetaData*)md.Clone());
548
549 id.SetPath("MUON/Calib/TriggerEfficiency");
550 md.SetResponsible("Diego Stocco");
551
552 man->Put(&cells,id,(AliCDBMetaData*)md.Clone());
553
554 delete localBoardMasks;
555 delete regionalBoardMasks;
556 delete globalBoardMasks;
557}
558
559//_____________________________________________________________________________
8f7d7575 560void generateCalibrations(const char* cdbpath, Bool_t defaultValues)
b3c7c475 561{
562 //
563 //
564 //
565
8f7d7575 566 AliMUONV2DStore* pedestalStore = new AliMUON2DMap;
567 AliMUONV2DStore* gainStore = new AliMUON2DMap;
568 AliMUONV2DStore* deadStore = new AliMUON2DMap;
569
570 makeStores(*pedestalStore,*gainStore,*deadStore,defaultValues);
b3c7c475 571
572 Int_t ever = 99999999;
573
574 AliCDBId id("MUON/Calib/Pedestals",0,ever);
575 AliCDBMetaData md;
576 md.SetBeamPeriod(1);
577 md.SetAliRootVersion(gROOT->GetVersion());
578 if ( defaultValues )
579 {
580 md.SetComment("Test with default values");
581 }
582 else
583 {
584 md.SetComment("Test with random values");
585 }
586 md.SetResponsible("Laurent Aphecetche");
587
588 AliCDBManager* man = AliCDBManager::Instance();
589 man->SetDefaultStorage(cdbpath);
590 man->Put(pedestalStore,id,&md);
591
592 id.SetPath("MUON/Calib/Gains");
593
594 man->Put(gainStore,id,(AliCDBMetaData*)md.Clone());
595
8f7d7575 596 id.SetPath("MUON/Calib/DeadChannels");
597
598 man->Put(deadStore,id,(AliCDBMetaData*)md.Clone());
599
600 delete deadStore;
b3c7c475 601 delete pedestalStore;
602 delete gainStore;
603}
604
605