Changed the interface to TIterator one (Laurent)
[u/mrichter/AliRoot.git] / MUON / AliMUONCDB.cxx
CommitLineData
de01cdf0 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/// \class AliMUONCDB
19///
20/// Helper class to experience the OCDB
21/// It allows to generate dummy (but complete) containers for all the
22/// calibration data types we have for tracker and trigger, and to write
23/// them into OCDB.
24///
25/// For more information, please see READMECDB
26///
27// \author Laurent Aphecetche
28
29#include "AliMUONCDB.h"
30
31#include "AliCDBEntry.h"
32#include "AliCDBManager.h"
33#include "AliDCSValue.h"
34#include "AliLog.h"
35#include "AliMUON1DArray.h"
36#include "AliMUON1DMap.h"
37#include "AliMUON2DMap.h"
38#include "AliMUON2DStoreValidator.h"
39#include "AliMUONCalibParamNF.h"
40#include "AliMUONCalibParamNI.h"
41#include "AliMUONConstants.h"
42#include "AliMUONHVNamer.h"
43#include "AliMUONObjectPair.h"
44#include "AliMUONTriggerEfficiencyCells.h"
45#include "AliMUONTriggerLut.h"
46#include "AliMUONV2DStore.h"
47#include "AliMUONVCalibParam.h"
48#include "AliMUONVCalibParam.h"
49#include "AliMUONVDataIterator.h"
50#include "AliMpDDLStore.h"
51#include "AliMpDEIterator.h"
52#include "AliMpDEManager.h"
53#include "AliMpDetElement.h"
54#include "AliMpManuList.h"
55#include "AliMpSegmentation.h"
56#include "AliMpStationType.h"
57#include "AliMpVSegmentation.h"
58#include <Riostream.h>
59#include <TArrayI.h>
60#include <TClass.h>
61#include <TH1F.h>
62#include <TList.h>
63#include <TMap.h>
64#include <TObjString.h>
65#include <TROOT.h>
66#include <TRandom.h>
67#include <TStopwatch.h>
68#include <TSystem.h>
69
70/// \cond CLASSIMP
71ClassImp(AliMUONCDB)
72/// \endcond
73
74const Int_t AliMUONCDB::fgkMaxNofChannelsPerManu=64;
75
76namespace
77{
78//_____________________________________________________________________________
79void getBoundaries(const AliMUONV2DStore& store,
80 Float_t& x0min, Float_t& x0max,
81 Float_t& x1min, Float_t& x1max)
82{
83 x0min=1E30;
84 x0max=-1E30;
85 x1min=1E30;
86 x1max=-1E30;
87
88 AliMUONVDataIterator* it = store.Iterator();
89
90 AliMUONObjectPair* p;
91
92 while ( ( p = dynamic_cast<AliMUONObjectPair*>(it->Next() ) ) )
93 {
94 AliMpIntPair* dm = dynamic_cast<AliMpIntPair*>(p->Key());
95 AliMUONVCalibParam* value = dynamic_cast<AliMUONVCalibParam*>(p->Value());
96
97 Int_t detElemId = dm->GetFirst();
98 Int_t manuId = dm->GetSecond();
99
100 const AliMpVSegmentation* seg =
101 AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
102
103 for ( Int_t manuChannel = 0; manuChannel < value->Size(); ++manuChannel )
104 {
105 AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
106 if (!pad.IsValid()) continue;
107
108 Float_t x0 = value->ValueAsFloat(manuChannel,0);
109
110 x0min = TMath::Min(x0min,x0);
111 x0max = TMath::Max(x0max,x0);
112 if ( value->Dimension()>1 )
113 {
114 Float_t x1 = value->ValueAsFloat(manuChannel,1);
115 x1min = TMath::Min(x1min,x1);
116 x1max = TMath::Max(x1max,x1);
117 }
118 }
119 if (it->IsOwner()) delete p;
120 }
121}
122
123}
124
125//_____________________________________________________________________________
126AliMUONCDB::AliMUONCDB(const char* cdbpath)
127: TObject(),
128 fCDBPath(cdbpath),
129 fManuList(AliMpManuList::ManuList())
130{
131 /// ctor
132}
133
134//_____________________________________________________________________________
135AliMUONCDB::~AliMUONCDB()
136{
137 /// dtor
138 delete fManuList;
139}
140
141//_____________________________________________________________________________
142AliMUONV2DStore*
143AliMUONCDB::Diff(AliMUONV2DStore& store1, AliMUONV2DStore& store2,
144 const char* opt)
145{
146 /// creates a store which contains store1-store2
147 /// if opt="abs" the difference is absolute one,
148 /// if opt="rel" then what is stored is (store1-store2)/store1
149 /// WARNING Works only for stores which holds AliMUONVCalibParam objects
150
151 TString sopt(opt);
152 sopt.ToUpper();
153
154 if ( !sopt.Contains("ABS") && !sopt.Contains("REL") )
155 {
156 AliErrorClass(Form("opt %s not supported. Only ABS or REL are",opt));
157 return 0x0;
158 }
159
160 AliMUONV2DStore* d = static_cast<AliMUONV2DStore*>(store1.Clone());
161
162 AliMUONVDataIterator* it = d->Iterator();
163
164 AliMUONObjectPair* p;
165
166 while ( ( p = dynamic_cast<AliMUONObjectPair*>(it->Next() ) ) )
167 {
168 AliMpIntPair* dm = dynamic_cast<AliMpIntPair*>(p->Key());
169 //FIXME: this might happen (if a full manu is missing, for instance)
170 //handle it.
171 if (!dm)
172 {
173 cerr << "dm is null : FIXME: this might happen !" << endl;
174 delete d;
175 return 0;
176 }
177 AliMUONVCalibParam* param = dynamic_cast<AliMUONVCalibParam*>(p->Value());
178 //FIXMENOT: this should *not* happen
179 if (!param)
180 {
181 cerr << "param is null" << endl;
182 delete d;
183 return 0;
184 }
185
186 AliMUONVCalibParam* param2 = dynamic_cast<AliMUONVCalibParam*>(store2.Get(dm->GetFirst(),dm->GetSecond()));
187 //FIXME: this might happen. Handle it.
188 if (!param2)
189 {
190 cerr << "param2 is null : FIXME : this might happen !" << endl;
191 delete d;
192 return 0;
193 }
194
195 for ( Int_t i = 0; i < param->Size(); ++i )
196 {
197 for ( Int_t j = 0; j < param->Dimension(); ++j )
198 {
199 Float_t value(0);
200 if ( sopt.Contains("ABS") )
201 {
202 value = param->ValueAsFloat(i,j) - param2->ValueAsFloat(i,j);
203 }
204 else if ( sopt.Contains("REL") )
205 {
206 if ( param->ValueAsFloat(i,j) )
207 {
208 value = (param->ValueAsFloat(i,j) - param2->ValueAsFloat(i,j))/param->ValueAsFloat(i,j);
209 }
210 else
211 {
212 continue;
213 }
214 }
215 param->SetValueAsFloat(i,j,value);
216 }
217 }
218 if (it->IsOwner()) delete p;
219 }
220 return d;
221}
222
223//_____________________________________________________________________________
224void
225AliMUONCDB::Plot(const AliMUONV2DStore& store, const char* name, Int_t nbins)
226{
227 /// Make a plot of the first 1 or 2 dimensions of the AliMUONVCalibParam
228 /// contained inside store.
229 /// It produces histograms named name_0, name_1, etc...
230
231 Float_t x0min, x0max, x1min, x1max;
232
233 getBoundaries(store,x0min,x0max,x1min,x1max);
234
235 if ( x0min > x0max )
236 {
237 cerr << Form("Something is wrong with boundaries : x0(min,max)=%e,%e",
238 x0min,x0max) << endl;
239 return;
240 }
241
242 if ( TMath::Abs(x0min-x0max) < 1E-3 )
243 {
244 x0min -= 1;
245 x0max += 1;
246 }
247
248 TH1* h0 = new TH1F(Form("%s_0",name),Form("%s_0",name),
249 nbins,x0min,x0max);
250
251 TH1* h1(0);
252
253 if ( x1max > x1min )
254 {
255 h1 = new TH1F(Form("%s_1",name),Form("%s_1",name),
256 nbins,x1min,x1max);
257 }
258
259 TIter next(fManuList);
260 AliMpIntPair* p;
261 Int_t n(0);
262 Int_t nPerStation[7];
263
264 for ( Int_t i = 0; i < 7; ++i ) nPerStation[i]=0;
265
266 while ( ( p = (AliMpIntPair*)next() ) )
267 {
268 Int_t detElemId = p->GetFirst();
269 Int_t manuId = p->GetSecond();
270 Int_t station = AliMpDEManager::GetChamberId(detElemId);
271
272 const AliMpVSegmentation* seg =
273 AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
274
275 AliMUONVCalibParam* value =
276 dynamic_cast<AliMUONVCalibParam*>(store.Get(detElemId,manuId));
277
278 if (value)
279 {
280 for ( Int_t manuChannel = 0; manuChannel < value->Size(); ++manuChannel )
281 {
282 AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
283 if (!pad.IsValid()) continue;
284
285 ++n;
286 ++nPerStation[station];
287 Float_t x = value->ValueAsFloat(manuChannel,0);
288 if ( x>1E4 )
289 {
290 AliInfo(Form("DE %d Manu %d Ch %d x=%e",detElemId,manuId,manuChannel,x));
291 }
292 h0->Fill(x);
293 if (h1)
294 {
295 h1->Fill(value->ValueAsFloat(manuChannel,1));
296 }
297 }
298 }
299 else
300 {
301 AliWarning(Form("Got a null value for DE=%d manuId=%d",detElemId,manuId));
302 }
303 }
304
305 AliInfo(Form("Number of channels = %d",n));
306 for ( Int_t i = 0; i < 7; ++i )
307 {
308 AliInfo(Form("Station %d %d ",(i+1),nPerStation[i]));
309 }
310}
311
312//_____________________________________________________________________________
313Int_t
314AliMUONCDB::MakeHVStore(TMap& aliasMap, Bool_t defaultValues)
315{
316 /// Create a HV store
317
318 AliMUONHVNamer hvNamer;
319 TRandom random;
320
321 TObjArray* aliases = hvNamer.GenerateAliases();
322
323 Int_t nSwitch(0);
324 Int_t nChannels(0);
325
326 for ( Int_t i = 0; i < aliases->GetEntries(); ++i )
327 {
328 TObjString* alias = static_cast<TObjString*>(aliases->At(i));
329 TString& aliasName = alias->String();
330 if ( aliasName.Contains("sw") )
331 {
332 // HV Switch (St345 only)
333 TObjArray* valueSet = new TObjArray;
334 valueSet->SetOwner(kTRUE);
335
336 Bool_t value = kTRUE;
337
338 if (!defaultValues)
339 {
340 Float_t r = random.Uniform();
341 if ( r < 0.007 ) value = kFALSE;
342 }
343
344 for ( UInt_t timeStamp = 0; timeStamp < 60*3; timeStamp += 60 )
345 {
346 AliDCSValue* dcsValue = new AliDCSValue(value,timeStamp);
347 valueSet->Add(dcsValue);
348 }
349 aliasMap.Add(new TObjString(*alias),valueSet);
350 ++nSwitch;
351 }
352 else
353 {
354 TObjArray* valueSet = new TObjArray;
355 valueSet->SetOwner(kTRUE);
356 for ( UInt_t timeStamp = 0; timeStamp < 60*15; timeStamp += 120 )
357 {
358 Float_t value = 1500;
359 if (!defaultValues) value = random.Gaus(1750,62.5);
360 AliDCSValue* dcsValue = new AliDCSValue(value,timeStamp);
361 valueSet->Add(dcsValue);
362 }
363 aliasMap.Add(new TObjString(*alias),valueSet);
364 ++nChannels;
365 }
366 }
367
368 delete aliases;
369
370 AliInfo(Form("%d HV channels and %d switches",nChannels,nSwitch));
371
372 return nChannels+nSwitch;
373}
374
375//_____________________________________________________________________________
376Int_t
377AliMUONCDB::MakePedestalStore(AliMUONV2DStore& pedestalStore, Bool_t defaultValues)
378{
379 /// Create a pedestal store. if defaultValues=true, ped.mean=ped.sigma=1,
380 /// otherwise mean and sigma are from a gaussian (with parameters
381 /// defined below by the kPedestal* constants)
382
383 TIter next(fManuList);
384
385 AliMpIntPair* p;
386
387 Int_t nchannels(0);
388 Int_t nmanus(0);
389
390 Bool_t replace = kFALSE;
391
392 const Int_t kChannels(64);
393 const Float_t kPedestalMeanMean(200);
394 const Float_t kPedestalMeanSigma(10);
395 const Float_t kPedestalSigmaMean(1.0);
396 const Float_t kPedestalSigmaSigma(0.2);
397
398 while ( ( p = (AliMpIntPair*)next() ) )
399 {
400 ++nmanus;
401 AliMUONVCalibParam* ped = new AliMUONCalibParamNF(2,kChannels,AliMUONVCalibParam::InvalidFloatValue());
402
403 Int_t detElemId = p->GetFirst();
404
405 Int_t manuId = p->GetSecond();
406
407 const AliMpVSegmentation* seg =
408 AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
409
410 for ( Int_t manuChannel = 0; manuChannel < kChannels; ++manuChannel )
411 {
412 AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
413 if (!pad.IsValid()) continue;
414
415 ++nchannels;
416
417 Float_t meanPedestal;
418 Float_t sigmaPedestal;
419
420 if ( defaultValues )
421 {
422 meanPedestal = 0.0;
423 sigmaPedestal = 1.0;
424 }
425 else
426 {
427 meanPedestal = -1;
428 while ( meanPedestal < 0 )
429 {
430 meanPedestal = gRandom->Gaus(kPedestalMeanMean,kPedestalMeanSigma);
431 }
432 sigmaPedestal = -1;
433 while ( sigmaPedestal < 0 )
434 {
435 sigmaPedestal = gRandom->Gaus(kPedestalSigmaMean,kPedestalSigmaSigma);
436 }
437 }
438 ped->SetValueAsFloat(manuChannel,0,meanPedestal);
439 ped->SetValueAsFloat(manuChannel,1,sigmaPedestal);
440
441 }
442 Bool_t ok = pedestalStore.Set(detElemId,manuId,ped,replace);
443 if (!ok)
444 {
445 AliError(Form("Could not set DetElemId=%d manuId=%d",detElemId,manuId));
446 }
447 }
448
449 AliInfo(Form("%d Manus and %d channels.",nmanus,nchannels));
450 return nchannels;
451
452}
453
454//_____________________________________________________________________________
455Int_t
456AliMUONCDB::MakeCapacitanceStore(AliMUONV1DStore& capaStore, Bool_t defaultValues)
457{
458 /// Create a capacitance store. if defaultValues=true, all capa are 1.0,
459 /// otherwise they are from a gaussian with parameters defined in the
460 /// kCapa* constants below.
461
462 TIter next(fManuList);
463
464 AliMpIntPair* p;
465
466 Int_t nchannels(0);
467 Int_t nmanus(0);
468 Int_t nmanusOK(0); // manus for which we got the serial number
469
470 Bool_t replace = kFALSE;
471
472 const Float_t kCapaMean(1.0);
473 const Float_t kCapaSigma(0.5);
474
475 while ( ( p = (AliMpIntPair*)next() ) )
476 {
477 ++nmanus;
478
479 Int_t detElemId = p->GetFirst();
480 Int_t manuId = p->GetSecond();
481
482 AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
483 Int_t serialNumber = de->GetManuSerialFromId(manuId);
484
485 if ( serialNumber > 0 ) ++nmanusOK;
486
487 const AliMpVSegmentation* seg =
488 AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
489
490 AliMUONVCalibParam* capa = static_cast<AliMUONVCalibParam*>(capaStore.Get(serialNumber));
491
492 if (!capa)
493 {
494 capa = new AliMUONCalibParamNF(1,fgkMaxNofChannelsPerManu,1.0);
495 Bool_t ok = capaStore.Set(serialNumber,capa,replace);
496 if (!ok)
497 {
498 AliError(Form("Could not set serialNumber=%d manuId=%d",serialNumber,manuId));
499 }
500 }
501
502 for ( Int_t manuChannel = 0; manuChannel < capa->Size(); ++manuChannel )
503 {
504 AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
505 if (!pad.IsValid()) continue;
506
507 ++nchannels;
508
509 Float_t capaValue;
510
511 if ( defaultValues )
512 {
513 capaValue = 1.0;
514 }
515 else
516 {
517 capaValue = -1;
518 while ( capaValue < 0 )
519 {
520 capaValue = gRandom->Gaus(kCapaMean,kCapaSigma);
521 }
522 }
523 capa->SetValueAsFloat(manuChannel,0,capaValue);
524 }
525 }
526
527 Float_t percent = 0;
528 if ( nmanus ) percent = 100*nmanusOK/nmanus;
529 AliInfo(Form("%5d manus with serial number (out of %5d manus = %3.0f%%)",
530 nmanusOK,nmanus,percent));
531 AliInfo(Form("%5d channels",nchannels));
532 if ( percent < 100 )
533 {
534 AliWarning("Did not get all serial numbers. capaStore is incomplete !!!!");
535 }
536 return nchannels;
537
538}
539
540//_____________________________________________________________________________
541Int_t
542AliMUONCDB::MakeGainStore(AliMUONV2DStore& gainStore, Bool_t defaultValues)
543{
544 /// Create a gain store. if defaultValues=true, all gain are 1.0,
545 /// otherwise they are from a gaussian with parameters defined in the
546 /// kGain* constants below.
547
548 TIter next(fManuList);
549
550 AliMpIntPair* p;
551
552 Int_t nchannels(0);
553 Int_t nmanus(0);
554
555 Bool_t replace = kFALSE;
556
557 const Double_t kSaturation(3000);
558 const Double_t kGainMean(1.0);
559 const Double_t kGainSigma(0.05);
560
561 while ( ( p = (AliMpIntPair*)next() ) )
562 {
563 ++nmanus;
564 AliMUONVCalibParam* gain =
565 new AliMUONCalibParamNF(2,fgkMaxNofChannelsPerManu,
566 AliMUONVCalibParam::InvalidFloatValue());
567
568 Int_t detElemId = p->GetFirst();
569 Int_t manuId = p->GetSecond();
570
571 const AliMpVSegmentation* seg =
572 AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
573
574 for ( Int_t manuChannel = 0; manuChannel < gain->Size(); ++manuChannel )
575 {
576 AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
577 if (!pad.IsValid()) continue;
578
579 ++nchannels;
580
581 Float_t meanGain;
582 Float_t saturation(kSaturation);
583
584 if ( defaultValues )
585 {
586 meanGain = 1.0;
587 }
588 else
589 {
590 meanGain = -1;
591 while ( meanGain < 0 )
592 {
593 meanGain = gRandom->Gaus(kGainMean,kGainSigma);
594 }
595 }
596 gain->SetValueAsFloat(manuChannel,0,meanGain);
597 gain->SetValueAsFloat(manuChannel,1,saturation);
598
599 }
600 Bool_t ok = gainStore.Set(detElemId,manuId,gain,replace);
601 if (!ok)
602 {
603 AliError(Form("Could not set DetElemId=%d manuId=%d",detElemId,manuId));
604 }
605 }
606
607 AliInfo(Form("%d Manus and %d channels.",nmanus,nchannels));
608 return nchannels;
609}
610
611//_____________________________________________________________________________
612Int_t
613AliMUONCDB::MakeLocalTriggerMaskStore(AliMUONV1DStore& localBoardMasks) const
614{
615 /// Generate local trigger masks store. All masks are set to FFFF
616
617 Int_t ngenerated(0);
618 // Generate fake mask values for 234 localboards and put that into
619 // one single container (localBoardMasks)
620 for ( Int_t i = 1; i <= 234; ++i )
621 {
622 AliMUONVCalibParam* localBoard = new AliMUONCalibParamNI(1,8);
623 for ( Int_t x = 0; x < 2; ++x )
624 {
625 for ( Int_t y = 0; y < 4; ++y )
626 {
627 Int_t index = x*4+y;
628 localBoard->SetValueAsInt(index,0,0xFFFF);
629 ++ngenerated;
630 }
631 }
632 localBoardMasks.Set(i,localBoard,kFALSE);
633 }
634 return ngenerated;
635}
636
637//_____________________________________________________________________________
638Int_t
639AliMUONCDB::MakeRegionalTriggerMaskStore(AliMUONV1DStore& rtm) const
640{
641 /// Make a regional trigger masks store. All masks are set to 3F
642
643 Int_t ngenerated(0);
644 for ( Int_t i = 0; i < 16; ++i )
645 {
646 AliMUONVCalibParam* regionalBoard = new AliMUONCalibParamNI(1,16);
647 for ( Int_t j = 0; j < 16; ++j )
648 {
649 regionalBoard->SetValueAsInt(j,0,0x3F);
650 ++ngenerated;
651 }
652 rtm.Set(i,regionalBoard,kFALSE);
653 }
654
655 return ngenerated;
656}
657
658//_____________________________________________________________________________
659Int_t
660AliMUONCDB::MakeGlobalTriggerMaskStore(AliMUONVCalibParam& gtm) const
661{
662 /// Make a global trigger masks store. All masks set to FFF
663
664 Int_t ngenerated(0);
665
666 for ( Int_t j = 0; j < 16; ++j )
667 {
668 gtm.SetValueAsInt(j,0,0xFFF);
669 ++ngenerated;
670 }
671 return ngenerated;
672}
673
674//_____________________________________________________________________________
675AliMUONTriggerLut*
676AliMUONCDB::MakeTriggerLUT(const char* file) const
677{
678 /// Make a triggerlut object, from a file.
679
680 AliMUONTriggerLut* lut = new AliMUONTriggerLut;
681 lut->ReadFromFile(file);
682 return lut;
683}
684
685//_____________________________________________________________________________
686AliMUONTriggerEfficiencyCells*
687AliMUONCDB::MakeTriggerEfficiency(const char* file) const
688{
689 /// Make a trigger efficiency object from a file.
690
691 return new AliMUONTriggerEfficiencyCells(file);
692}
693
694//_____________________________________________________________________________
695void
696AliMUONCDB::WriteToCDB(const char* calibpath, TObject* object,
697 Int_t startRun, Int_t endRun, Bool_t defaultValues)
698{
699 /// Write a given object to OCDB
700
701 AliCDBId id(calibpath,startRun,endRun);
702 AliCDBMetaData md;
703 md.SetAliRootVersion(gROOT->GetVersion());
704 if ( defaultValues )
705 {
706 md.SetComment("Test with default values");
707 }
708 else
709 {
710 md.SetComment("Test with random values");
711 }
712 md.SetResponsible("AliMUONCDB tester class");
713
714 AliCDBManager* man = AliCDBManager::Instance();
715 man->SetDefaultStorage(fCDBPath);
716 man->Put(object,id,&md);
717}
718
719//_____________________________________________________________________________
720Int_t
721AliMUONCDB::MakeNeighbourStore(AliMUONV2DStore& neighbourStore)
722{
723 /// Fill the neighbours store with, for each channel, a TObjArray of its
724 /// neighbouring pads (including itself)
725
726 TStopwatch timer;
727
728 timer.Start(kTRUE);
729
730 TIter next(fManuList);
731
732 AliMpIntPair* p;
733
734 Int_t nchannels(0);
735
736 TObjArray tmp;
737
738 while ( ( p = (AliMpIntPair*)next() ) )
739 {
740 Int_t detElemId = p->GetFirst();
741 Int_t manuId = p->GetSecond();
742
743 const AliMpVSegmentation* seg =
744 AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
745
746 AliMUONVCalibParam* calibParam = static_cast<AliMUONVCalibParam*>(neighbourStore.Get(detElemId,manuId));
747 if (!calibParam)
748 {
749 Int_t dimension(11);
750 Int_t size(64);
751 Int_t defaultValue(-1);
752 Int_t packingFactor(64);
753
754 calibParam = new AliMUONCalibParamNI(dimension,size,defaultValue,packingFactor);
755 Bool_t ok = neighbourStore.Set(detElemId,manuId,calibParam,kFALSE);
756 if (!ok)
757 {
758 AliError(Form("Could not set DetElemId=%d manuId=%d",detElemId,manuId));
759 return -1;
760 }
761 }
762
763 for ( Int_t manuChannel = 0; manuChannel < 64; ++manuChannel )
764 {
765 AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
766
767 if (pad.IsValid())
768 {
769 ++nchannels;
770
771 seg->GetNeighbours(pad,tmp,true,true);
772 Int_t nofPadNeighbours = tmp.GetEntriesFast();
773
774 for ( Int_t i = 0; i < nofPadNeighbours; ++i )
775 {
776 AliMpPad* pad = static_cast<AliMpPad*>(tmp.At(i));
777 Int_t x;
778 Bool_t ok = calibParam->PackValues(pad->GetLocation().GetFirst(),pad->GetLocation().GetSecond(),x);
779 if (!ok)
780 {
781 AliError("Could not pack value. Something is seriously wrong. Please check");
782 return -1;
783 }
784 calibParam->SetValueAsInt(manuChannel,i,x);
785 }
786 }
787 }
788 }
789
790 timer.Print();
791
792 return nchannels;
793}
794
795//_____________________________________________________________________________
796void
797AliMUONCDB::WriteLocalTriggerMasks(Int_t startRun, Int_t endRun)
798{
799 /// Write local trigger masks to OCDB
800
801 AliMUONV1DStore* ltm = new AliMUON1DArray(235);
802 Int_t ngenerated = MakeLocalTriggerMaskStore(*ltm);
803 AliInfo(Form("Ngenerated = %d",ngenerated));
804 if (ngenerated>0)
805 {
806 WriteToCDB("MUON/Calib/LocalTriggerBoardMasks",ltm,startRun,endRun,true);
807 }
808 delete ltm;
809}
810
811//_____________________________________________________________________________
812void
813AliMUONCDB::WriteRegionalTriggerMasks(Int_t startRun, Int_t endRun)
814{
815 /// Write regional trigger masks to OCDB
816
817 AliMUONV1DStore* rtm = new AliMUON1DArray(16);
818 Int_t ngenerated = MakeRegionalTriggerMaskStore(*rtm);
819 AliInfo(Form("Ngenerated = %d",ngenerated));
820 if (ngenerated>0)
821 {
822 WriteToCDB("MUON/Calib/RegionalTriggerBoardMasks",rtm,startRun,endRun,true);
823 }
824 delete rtm;
825}
826
827//_____________________________________________________________________________
828void
829AliMUONCDB::WriteGlobalTriggerMasks(Int_t startRun, Int_t endRun)
830{
831 /// Write global trigger masks to OCDB
832
833 AliMUONVCalibParam* gtm = new AliMUONCalibParamNI(1,16);
834
835 Int_t ngenerated = MakeGlobalTriggerMaskStore(*gtm);
836 AliInfo(Form("Ngenerated = %d",ngenerated));
837 if (ngenerated>0)
838 {
839 WriteToCDB("MUON/Calib/GlobalTriggerBoardMasks",gtm,startRun,endRun,true);
840 }
841 delete gtm;
842}
843
844//_____________________________________________________________________________
845void
846AliMUONCDB::WriteTriggerLut(Int_t startRun, Int_t endRun)
847{
848 /// Write trigger LUT to OCDB
849
850 AliMUONTriggerLut* lut = MakeTriggerLUT();
851 if (lut)
852 {
853 WriteToCDB("MUON/Calib/TriggerLut",lut,startRun,endRun,true);
854 }
855 delete lut;
856}
857
858//_____________________________________________________________________________
859void
860AliMUONCDB::WriteTriggerEfficiency(Int_t startRun, Int_t endRun)
861{
862 /// Write trigger efficiency to OCDB
863
864 AliMUONTriggerEfficiencyCells* eff = MakeTriggerEfficiency();
865 if (eff)
866 {
867 WriteToCDB("MUON/Calib/TriggerEfficiency",eff,startRun,endRun,true);
868 }
869 delete eff;
870}
871
872//_____________________________________________________________________________
873void
874AliMUONCDB::WriteNeighbours(Int_t startRun, Int_t endRun)
875{
876 /// Write neighbours to OCDB
877
878 AliMUONV2DStore* neighbours = new AliMUON2DMap(kTRUE);
879 Int_t ngenerated = MakeNeighbourStore(*neighbours);
880 AliInfo(Form("Ngenerated = %d",ngenerated));
881 if (ngenerated>0)
882 {
883 WriteToCDB("MUON/Calib/Neighbours",neighbours,startRun,endRun,true);
884 }
885 delete neighbours;
886}
887
888//_____________________________________________________________________________
889void
890AliMUONCDB::WriteHV(Bool_t defaultValues,
891 Int_t startRun, Int_t endRun)
892{
893 /// generate HV values (either cste = 1500 V) if defaultValues=true or random
894 /// if defaultValues=false, see makeHVStore) and
895 /// store them into CDB located at cdbpath, with a validity period
896 /// ranging from startRun to endRun
897
898 TMap* hvStore = new TMap;
899 Int_t ngenerated = MakeHVStore(*hvStore,defaultValues);
900 AliInfo(Form("Ngenerated = %d",ngenerated));
901 if (ngenerated>0)
902 {
903 WriteToCDB("MUON/Calib/HV",hvStore,startRun,endRun,defaultValues);
904 }
905 delete hvStore;
906}
907
908//_____________________________________________________________________________
909void
910AliMUONCDB::WritePedestals(Bool_t defaultValues,
911 Int_t startRun, Int_t endRun)
912{
913 /// generate pedestal values (either 0 if defaultValues=true or random
914 /// if defaultValues=false, see makePedestalStore) and
915 /// store them into CDB located at cdbpath, with a validity period
916 /// ranging from startRun to endRun
917
918 AliMUONV2DStore* pedestalStore = new AliMUON2DMap(true);
919 Int_t ngenerated = MakePedestalStore(*pedestalStore,defaultValues);
920 AliInfo(Form("Ngenerated = %d",ngenerated));
921 WriteToCDB("MUON/Calib/Pedestals",pedestalStore,startRun,endRun,defaultValues);
922 delete pedestalStore;
923}
924
925
926//_____________________________________________________________________________
927void
928AliMUONCDB::WriteGains(Bool_t defaultValues,
929 Int_t startRun, Int_t endRun)
930{
931 /// generate gain values (either 1 if defaultValues=true or random
932 /// if defaultValues=false, see makeGainStore) and
933 /// store them into CDB located at cdbpath, with a validity period
934 /// ranging from startRun to endRun
935
936 AliMUONV2DStore* gainStore = new AliMUON2DMap(true);
937 Int_t ngenerated = MakeGainStore(*gainStore,defaultValues);
938 AliInfo(Form("Ngenerated = %d",ngenerated));
939 WriteToCDB("MUON/Calib/Gains",gainStore,startRun,endRun,defaultValues);
940 delete gainStore;
941}
942
943//_____________________________________________________________________________
944void
945AliMUONCDB::WriteCapacitances(Bool_t defaultValues,
946 Int_t startRun, Int_t endRun)
947{
948 /// generate manu capacitance values (either 1 if defaultValues=true or random
949 /// if defaultValues=false, see makeCapacitanceStore) and
950 /// store them into CDB located at cdbpath, with a validity period
951 /// ranging from startRun to endRun
952
953 AliMUONV1DStore* capaStore = new AliMUON1DMap(16828);
954 Int_t ngenerated = MakeCapacitanceStore(*capaStore,defaultValues);
955 AliInfo(Form("Ngenerated = %d",ngenerated));
956 WriteToCDB("MUON/Calib/Capacitances",capaStore,startRun,endRun,defaultValues);
957 delete capaStore;
958}
959
960//_____________________________________________________________________________
961void
962AliMUONCDB::WriteTrigger(Int_t startRun, Int_t endRun)
963{
964 /// Writes all Trigger related calibration to CDB
965 WriteLocalTriggerMasks(startRun,endRun);
966 WriteRegionalTriggerMasks(startRun,endRun);
967 WriteGlobalTriggerMasks(startRun,endRun);
968 WriteTriggerLut(startRun,endRun);
969 WriteTriggerEfficiency(startRun,endRun);
970}
971
972//_____________________________________________________________________________
973void
974AliMUONCDB::WriteTracker(Bool_t defaultValues, Int_t startRun, Int_t endRun)
975{
976 /// Writes all Tracker related calibration to CDB
977 WriteHV(defaultValues,startRun,endRun);
978 WritePedestals(defaultValues,startRun,endRun);
979 WriteGains(defaultValues,startRun,endRun);
980 WriteCapacitances(defaultValues,startRun,endRun);
981 WriteNeighbours(startRun,endRun);
982}
983