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