]>
Commit | Line | Data |
---|---|---|
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 | #include "AliMUONCalibrationData.h" | |
19 | ||
20 | #include "AliCDBEntry.h" | |
21 | #include "AliCDBManager.h" | |
22 | #include "AliCodeTimer.h" | |
23 | #include "AliDCSValue.h" | |
24 | #include "AliLog.h" | |
25 | #include "AliMpDCSNamer.h" | |
26 | #include "AliMpIntPair.h" | |
27 | #include "AliMUONGlobalCrateConfig.h" | |
28 | #include "AliMUONRegionalTriggerConfig.h" | |
29 | #include "AliMUONRejectList.h" | |
30 | #include "AliMUONTriggerEfficiencyCells.h" | |
31 | #include "AliMUONTriggerLut.h" | |
32 | #include "AliMUONVCalibParam.h" | |
33 | #include "AliMUONVStore.h" | |
34 | #include "AliMUONVStore.h" | |
35 | ||
36 | #include <Riostream.h> | |
37 | #include <TClass.h> | |
38 | #include <TMap.h> | |
39 | #include <TMath.h> | |
40 | ||
41 | //----------------------------------------------------------------------------- | |
42 | /// \class AliMUONCalibrationData | |
43 | /// | |
44 | /// For the moment, this class stores pedestals, gains, hv (for tracker) | |
45 | /// and lut, masks and efficiencies (for trigger) that are fetched from the CDB. | |
46 | /// | |
47 | /// This class is to be considered as a convenience class. | |
48 | /// Its aim is to ease retrieval of calibration data from the | |
49 | /// condition database. | |
50 | /// | |
51 | /// It acts as a "facade" to a bunch of underlying | |
52 | /// containers/calibration classes. | |
53 | /// | |
54 | /// \author Laurent Aphecetche | |
55 | //----------------------------------------------------------------------------- | |
56 | ||
57 | using std::cout; | |
58 | using std::endl; | |
59 | /// \cond CLASSIMP | |
60 | ClassImp(AliMUONCalibrationData) | |
61 | /// \endcond | |
62 | ||
63 | AliMUONVStore* AliMUONCalibrationData::fgBypassPedestals(0x0); | |
64 | AliMUONVStore* AliMUONCalibrationData::fgBypassGains(0x0); | |
65 | ||
66 | namespace | |
67 | { | |
68 | void MarkForDeletion(Int_t* indices, Int_t first, Int_t last) | |
69 | { | |
70 | for ( Int_t i = first; i <= last; ++i ) | |
71 | { | |
72 | indices[i] = 1; | |
73 | } | |
74 | } | |
75 | } | |
76 | ||
77 | //_____________________________________________________________________________ | |
78 | AliMUONCalibrationData::AliMUONCalibrationData(Int_t runNumber, | |
79 | Bool_t deferredInitialization) | |
80 | : TObject(), | |
81 | fIsValid(kTRUE), | |
82 | fRunNumber(runNumber), | |
83 | fGains(0x0), | |
84 | fPedestals(0x0), | |
85 | fHV(0x0), | |
86 | fTriggerDCS(0x0), | |
87 | fLocalTriggerBoardMasks(0x0), | |
88 | fRegionalTriggerConfig(0x0), | |
89 | fGlobalTriggerCrateConfig(0x0), | |
90 | fTriggerLut(0x0), | |
91 | fTriggerEfficiency(0x0), | |
92 | fCapacitances(0x0), | |
93 | fNeighbours(0x0), | |
94 | fOccupancyMap(0x0), | |
95 | fRejectList(0x0), | |
96 | fConfig(0x0) | |
97 | { | |
98 | /// Default ctor. | |
99 | ||
100 | // If deferredInitialization is false, we read *all* calibrations | |
101 | // at once. | |
102 | // So when using this class to access only one kind of calibrations (e.g. | |
103 | // only pedestals), you should put deferredInitialization to kTRUE, which | |
104 | // will instruct this object to fetch the data only when neeeded. | |
105 | ||
106 | if ( deferredInitialization == kFALSE ) | |
107 | { | |
108 | Gains(); | |
109 | Pedestals(); | |
110 | OccupancyMap(); | |
111 | RejectList(); | |
112 | HV(); | |
113 | TriggerDCS(); | |
114 | LocalTriggerBoardMasks(0); | |
115 | RegionalTriggerConfig(); | |
116 | GlobalTriggerCrateConfig(); | |
117 | TriggerLut(); | |
118 | TriggerEfficiency(); | |
119 | Capacitances(); | |
120 | Neighbours(); | |
121 | Config(); | |
122 | } | |
123 | } | |
124 | ||
125 | //_____________________________________________________________________________ | |
126 | AliMUONCalibrationData::~AliMUONCalibrationData() | |
127 | { | |
128 | /// Destructor. Note that we're the owner of our pointers if the OCDB cache | |
129 | /// is not set. Otherwise the cache is supposed to take care of them... | |
130 | if (!(AliCDBManager::Instance()->GetCacheFlag())) Reset(); | |
131 | } | |
132 | ||
133 | //_____________________________________________________________________________ | |
134 | AliMUONVStore* | |
135 | AliMUONCalibrationData::Capacitances() const | |
136 | { | |
137 | /// Create (if needed) and return the internal store for capacitances. | |
138 | ||
139 | if (!fCapacitances) | |
140 | { | |
141 | fCapacitances = CreateCapacitances(fRunNumber); | |
142 | } | |
143 | return fCapacitances; | |
144 | } | |
145 | ||
146 | //_____________________________________________________________________________ | |
147 | AliMUONVStore* | |
148 | AliMUONCalibrationData::CreateCapacitances(Int_t runNumber, Int_t* startOfValidity) | |
149 | { | |
150 | /// Create capa store from OCDB for a given run | |
151 | ||
152 | return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/Capacitances",startOfValidity)); | |
153 | } | |
154 | ||
155 | //_____________________________________________________________________________ | |
156 | AliMUONVStore* | |
157 | AliMUONCalibrationData::CreateGains(Int_t runNumber, Int_t* startOfValidity) | |
158 | { | |
159 | /// Create a new gain store from the OCDB for a given run | |
160 | return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/Gains",startOfValidity)); | |
161 | } | |
162 | ||
163 | //_____________________________________________________________________________ | |
164 | AliMUONGlobalCrateConfig* | |
165 | AliMUONCalibrationData::CreateGlobalTriggerCrateConfig(Int_t runNumber, Int_t* startOfValidity) | |
166 | { | |
167 | /// Create the internal store for GlobalTriggerCrateConfig from OCDB | |
168 | ||
169 | return dynamic_cast<AliMUONGlobalCrateConfig*>(CreateObject(runNumber,"MUON/Calib/GlobalTriggerCrateConfig",startOfValidity)); | |
170 | } | |
171 | ||
172 | ||
173 | //______________________________________________________________________________ | |
174 | Bool_t AliMUONCalibrationData::CheckHVGroup(TObjArray& values, Int_t first, Int_t last, Double_t& value, Int_t& slope, TString* msg) | |
175 | { | |
176 | // Get the HV of the values between first and last indices | |
177 | // return the HV slope (in Volt per second) and a message | |
178 | // Return kFALSE if we must discard the group | |
179 | // | |
180 | ||
181 | if (msg) *msg=""; | |
182 | ||
183 | if ( last < first ) return kFALSE; | |
184 | if ( last - first < 2 ) return kFALSE; | |
185 | ||
186 | Double_t a(0.0); | |
187 | Double_t b(0.0); | |
188 | ||
189 | Float_t HVSAME(1); // 1 volts | |
190 | ||
191 | AliDCSValue* vfirst = static_cast<AliDCSValue*>(values.UncheckedAt(first)); | |
192 | AliDCSValue* vlast = static_cast<AliDCSValue*>(values.UncheckedAt(last)); | |
193 | ||
194 | Int_t deltaHV = TMath::Nint(TMath::Abs(vfirst->GetFloat()-vlast->GetFloat())); | |
195 | ||
196 | if ( deltaHV < HVSAME ) return kFALSE; | |
197 | ||
198 | for ( Int_t i = first; i <= last; ++i ) | |
199 | { | |
200 | AliDCSValue* v = static_cast<AliDCSValue*>(values.UncheckedAt(i)); | |
201 | ||
202 | Double_t y = v->GetFloat() - vfirst->GetFloat(); | |
203 | Double_t x = v->GetTimeStamp() - vfirst->GetTimeStamp(); | |
204 | ||
205 | a += x*y; | |
206 | b += x*x; | |
207 | } | |
208 | ||
209 | value = a/b; | |
210 | slope = value > 0 ? 1 : -1; | |
211 | value = TMath::Abs(value); | |
212 | ||
213 | UInt_t deltaTime = vlast->GetTimeStamp() - vfirst->GetTimeStamp(); | |
214 | ||
215 | if (msg) | |
216 | { | |
217 | if (slope>0) (*msg) = Form("RU%d[%d:%d](%d)",TMath::Nint(value),first,last,deltaTime); | |
218 | if (slope<0) (*msg) = Form("RD%d[%d:%d](%d)",TMath::Nint(value),first,last,deltaTime); | |
219 | ||
220 | if ( TMath::Nint(value) == 0 ) | |
221 | { | |
222 | // this is to protect for the few cases | |
223 | // (see e.g. MchHvLvLeft/Chamber00Left/Quad2Sect0.actual.vMon in run 134497) | |
224 | // where we can have *lots* of values (2483 in this example) but that | |
225 | // are more or less constant... | |
226 | // | |
227 | // or simply to remove small ramps | |
228 | // | |
229 | slope = 0; | |
230 | value = (vfirst->GetFloat()+vlast->GetFloat())/2.0; | |
231 | *msg = Form("FLUCT%d[%d:%d]",TMath::Nint(value),first,last); | |
232 | } | |
233 | } | |
234 | ||
235 | return kTRUE; | |
236 | } | |
237 | ||
238 | //______________________________________________________________________________ | |
239 | Bool_t AliMUONCalibrationData::PatchHVValues(TObjArray& values, | |
240 | TString* msg, | |
241 | Bool_t dryRun) | |
242 | { | |
243 | /// We do here a little bit of massaging of the HV values, if needed. | |
244 | /// | |
245 | /// The main point is to "gather" values that are within a given small amount | |
246 | /// of time (typically 60 seconds) and infer a slope from those values | |
247 | /// slope > 0 means it is a ramp-up, slope < 0 that's a ramp-down | |
248 | /// | |
249 | /// This is to avoid both the "ramp-down-before-end-of-run" and the | |
250 | /// "ramp-up-after-start-of-run" syndroms... | |
251 | /// | |
252 | /// Use dryRun = kTRUE to fill the messages *without* altering the values | |
253 | /// | |
254 | /// Return kFALSE is the kind of HV (trouble) case we have here | |
255 | /// has not been identified... | |
256 | /// | |
257 | ||
258 | UInt_t DELTATIME(60); // in seconds | |
259 | Int_t IENDRU(60); // in seconds | |
260 | ||
261 | // Start by finding groups of values which are not separated (each) by more than | |
262 | // deltaTime | |
263 | ||
264 | Bool_t gather(kFALSE); | |
265 | Int_t ifirst(0); | |
266 | Int_t ilast(0); | |
267 | TObjArray groups; | |
268 | groups.SetOwner(kTRUE); | |
269 | ||
270 | for ( Int_t i = values.GetLast(); i > 0; --i ) | |
271 | { | |
272 | AliDCSValue* vi = static_cast<AliDCSValue*>(values.UncheckedAt(i)); | |
273 | AliDCSValue* vj = static_cast<AliDCSValue*>(values.UncheckedAt(i-1)); | |
274 | ||
275 | if ( vi->GetTimeStamp() - vj->GetTimeStamp() < DELTATIME ) | |
276 | { | |
277 | if ( !gather ) | |
278 | { | |
279 | gather = kTRUE; | |
280 | ifirst = i; | |
281 | } | |
282 | ilast=i; | |
283 | } | |
284 | else | |
285 | { | |
286 | if ( gather ) | |
287 | { | |
288 | ilast=i; | |
289 | ||
290 | groups.Add(new AliMpIntPair(ilast,ifirst)); | |
291 | } | |
292 | gather = kFALSE; | |
293 | } | |
294 | } | |
295 | ||
296 | if (gather) | |
297 | { | |
298 | groups.Add(new AliMpIntPair(0,ifirst)); | |
299 | } | |
300 | ||
301 | TIter nextGroup(&groups,kIterBackward); | |
302 | AliMpIntPair* p; | |
303 | TString internalMsg; | |
304 | Int_t ngroups(0); | |
305 | ||
306 | Int_t nRU(0); | |
307 | Int_t nRD(0); | |
308 | Int_t nStartRU(0); | |
309 | Int_t nEndAndShortRU(0); | |
310 | Int_t nEndRD(0); | |
311 | Int_t nTripRD(0); | |
312 | Int_t nFluct(0); | |
313 | TObjArray trips; | |
314 | trips.SetOwner(kTRUE); | |
315 | ||
316 | while ( ( p = static_cast<AliMpIntPair*>(nextGroup()) ) ) | |
317 | { | |
318 | Double_t value; | |
319 | Int_t slope; | |
320 | ||
321 | TString groupMsg; | |
322 | ||
323 | AliDebugClass(1,Form("group %d:%d",p->GetFirst(),p->GetSecond())); | |
324 | ||
325 | Bool_t ok = CheckHVGroup(values,p->GetFirst(),p->GetSecond(),value,slope,&groupMsg); | |
326 | ||
327 | if (!ok) continue; | |
328 | ||
329 | ++ngroups; | |
330 | ||
331 | if ( slope > 0 ) | |
332 | { | |
333 | if ( p->GetFirst() == 0 ) | |
334 | { | |
335 | // start with a ramp-up | |
336 | ++nStartRU; | |
337 | } | |
338 | else if ( p->GetSecond() == values.GetLast() && TMath::Nint(value) < IENDRU ) | |
339 | { | |
340 | ++nEndAndShortRU; | |
341 | } | |
342 | else | |
343 | { | |
344 | // ramp-up in the middle of nowhere... | |
345 | ++nRU; | |
346 | } | |
347 | } | |
348 | else if ( slope < 0 ) | |
349 | { | |
350 | if ( p->GetSecond() == values.GetLast() ) | |
351 | { | |
352 | // end with a ramp-down | |
353 | ++nEndRD; | |
354 | } | |
355 | else | |
356 | { | |
357 | // ramp-down in the middle of nowhere | |
358 | ++nRD; | |
359 | } | |
360 | ||
361 | AliDCSValue* d = static_cast<AliDCSValue*>(values.At(p->GetSecond())); | |
362 | ||
363 | if ( d->GetFloat() < AliMpDCSNamer::TrackerHVOFF() ) | |
364 | { | |
365 | ++nTripRD; | |
366 | AliDCSValue* tripStart = static_cast<AliDCSValue*>(values.At(p->GetFirst())); | |
367 | trips.Add(new AliMpIntPair(tripStart->GetTimeStamp(),TMath::Nint(tripStart->GetFloat()))); | |
368 | } | |
369 | } | |
370 | else | |
371 | { | |
372 | ++nFluct; | |
373 | } | |
374 | ||
375 | internalMsg += groupMsg; | |
376 | internalMsg += " "; | |
377 | } | |
378 | ||
379 | /* | |
380 | ||
381 | Once we have "decoded" the groups we try to find out which of | |
382 | the following cases we're facing : | |
383 | ||
384 | case A = -------- = OK(1) | |
385 | ||
386 | case B = ---- | |
387 | \ | |
388 | \ = OK, once we have removed the ramp-down (2) | |
389 | ||
390 | case C = ----- | |
391 | / | |
392 | / = OK, once we have removed the ramp-up (3) | |
393 | ||
394 | case D = ----- | |
395 | / \ | |
396 | / \ = OK, once we have removed the ramp-down (2) and the ramp-up (3) | |
397 | ||
398 | case E = ---- | |
399 | \ | |
400 | \____ = TRIP = BAD (here the ramp-down slope should be bigger than in case C) | |
401 | ||
402 | case F = ---- | |
403 | \ ----- = BAD (trip + ramp-up at end of run) | |
404 | \____/ | |
405 | ||
406 | case G = fluctuations (within a range defined in CheckHVGroup...) | |
407 | ||
408 | case H = | |
409 | / | |
410 | / = ramp-up right at the end-of-run = OK (4) | |
411 | ------ | |
412 | ||
413 | (1) OK means the group is identified correctly, still the value can be below ready... | |
414 | (2) ramp-down values will be removed if the ramp is indeed the last values in the serie | |
415 | i.e. it's really an end-of-run problem (otherwise it's not case B) | |
416 | (3) ramp-up values will be removed if the ramp is indeed the first values in the serie | |
417 | i.e. it's really a start-of-run problem (otherwise it's not case C) | |
418 | (4) OK if short enough... | |
419 | ||
420 | Any other case is unknown and we'll : | |
421 | a) return kFALSE | |
422 | b) assume the channel is OFF. | |
423 | ||
424 | ||
425 | */ | |
426 | ||
427 | AliDebugClass(1,Form("msg=%s ngroupds=%d",internalMsg.Data(),ngroups)); | |
428 | AliDebugClass(1,Form("nRU %d nRD %d nStartRU %d nEndRD %d nTripRD %d nFluct %d", | |
429 | nRU,nRD,nStartRU,nEndRD,nTripRD,nFluct)); | |
430 | ||
431 | TString hvCase("OTHER"); | |
432 | int dummy(0),a(-1),b(-1); | |
433 | char r[81]; | |
434 | Int_t nvalues = values.GetSize(); | |
435 | Int_t* indices = new Int_t[nvalues]; | |
436 | memset(indices,0,nvalues*sizeof(Int_t)); | |
437 | ||
438 | AliDCSValue* vfirst = static_cast<AliDCSValue*>(values.UncheckedAt(0)); | |
439 | AliDCSValue* vlast = static_cast<AliDCSValue*>(values.UncheckedAt(values.GetLast())); | |
440 | ||
441 | UInt_t meanTimeStamp = ( vfirst->GetTimeStamp() + vlast->GetTimeStamp() ) / 2; | |
442 | ||
443 | if ( ngroups == 0 ) | |
444 | { | |
445 | hvCase = "A"; | |
446 | } | |
447 | else if ( nTripRD > 0 ) | |
448 | { | |
449 | const Double_t HVLOWTRIP(600); // a trip below this value is considered a "low trip" | |
450 | // i.e. one starting for a non-operational voltage | |
451 | ||
452 | internalMsg += Form("NT:%d ",nTripRD); | |
453 | ||
454 | if ( nRU > 0 && nRD > 0 ) | |
455 | { | |
456 | hvCase = "F"; | |
457 | } | |
458 | else | |
459 | { | |
460 | hvCase = "E"; | |
461 | } | |
462 | ||
463 | for ( Int_t iTrip = 0; iTrip <= trips.GetLast(); ++iTrip ) | |
464 | { | |
465 | AliMpIntPair* tripPair = static_cast<AliMpIntPair*>(trips.At(iTrip)); | |
466 | TString tripType("TRIP"); | |
467 | if ( tripPair->GetSecond() < HVLOWTRIP) | |
468 | { | |
469 | tripType = "LOWTRIP"; | |
470 | } | |
471 | ||
472 | internalMsg += Form("%s SV:%d TS:%d ",tripType.Data(),tripPair->GetSecond(),tripPair->GetFirst()); | |
473 | } | |
474 | ||
475 | // we put here the TRIP value as SV:value | |
476 | // for cases where there's a drop in voltage but the starting point was | |
477 | // below operational voltage, so strictly speaking it's *not* a trip, but | |
478 | // more a big fluctuation | |
479 | if ( !dryRun ) | |
480 | { | |
481 | MarkForDeletion(indices,0,values.GetLast()); | |
482 | values.Add(new AliDCSValue(static_cast<Float_t>(0),meanTimeStamp)); | |
483 | } | |
484 | } | |
485 | else if ( nStartRU > 0 && nRU == 0 && nRD == 0 && nEndRD == 0 ) | |
486 | { | |
487 | hvCase = "C"; | |
488 | if (!dryRun) | |
489 | { | |
490 | sscanf(internalMsg.Data(),"RU%10d[%10d:%10d]%80s",&dummy,&a,&b,r); | |
491 | MarkForDeletion(indices,a,b); | |
492 | } | |
493 | } | |
494 | else if ( nStartRU > 0 && nEndRD > 0 && nRD == 0 && nRU == 0 ) | |
495 | { | |
496 | hvCase = "D"; | |
497 | if (!dryRun) | |
498 | { | |
499 | sscanf(internalMsg.Data(),"RU%10d[%10d:%10d]%80s",&dummy,&a,&b,r); | |
500 | MarkForDeletion(indices,a,b-1); | |
501 | Int_t i = internalMsg.Index("RD",strlen("RD"),0,TString::kExact); | |
502 | sscanf(internalMsg(i,internalMsg.Length()-i).Data(), | |
503 | "RD%10d[%10d:%10d]%80s",&dummy,&a,&b,r); | |
504 | MarkForDeletion(indices,a+1,b); | |
505 | } | |
506 | } | |
507 | else if ( nEndRD > 0 && nStartRU == 0 && nRU == 0 && nRD == 0 ) | |
508 | { | |
509 | hvCase = "B"; | |
510 | if (!dryRun) | |
511 | { | |
512 | Int_t i = internalMsg.Index("RD",strlen("RD"),0,TString::kExact); | |
513 | sscanf(internalMsg(i,internalMsg.Length()-i).Data(), | |
514 | "RD%10d[%10d:%10d]%80s",&dummy,&a,&b,r); | |
515 | MarkForDeletion(indices,a,b); | |
516 | } | |
517 | } | |
518 | else if ( nFluct > 0 ) | |
519 | { | |
520 | hvCase = "G"; | |
521 | if (!dryRun) | |
522 | { | |
523 | TObjArray* af = internalMsg.Tokenize(" "); | |
524 | TIter next(af); | |
525 | TObjString* str; | |
526 | while ( ( str = static_cast<TObjString*>(next()) ) ) | |
527 | { | |
528 | TString s(str->String()); | |
529 | if ( s.BeginsWith("FLUCT") ) | |
530 | { | |
531 | sscanf(s.Data(),"FLUCT%d[%d:%d]",&dummy,&a,&b); | |
532 | MarkForDeletion(indices,a,b); | |
533 | } | |
534 | } | |
535 | delete af; | |
536 | } | |
537 | } | |
538 | else if ( nEndAndShortRU > 0 && nStartRU == 0 && nRU == 0 && nRD == 0 && nEndRD == 0 ) | |
539 | { | |
540 | hvCase = "H"; | |
541 | if (!dryRun) | |
542 | { | |
543 | sscanf(internalMsg.Data(),"RU%10d[%10d:%10d]%80s",&dummy,&a,&b,r); | |
544 | MarkForDeletion(indices,a,b); | |
545 | } | |
546 | } | |
547 | else | |
548 | { | |
549 | // last chance... | |
550 | // here we know it's not a trip, so let's assume everything is OK | |
551 | // if first and last value are in the same ballpark | |
552 | ||
553 | const Double_t HVFLUCT(20); // volts | |
554 | ||
555 | if ( TMath::Abs(vfirst->GetFloat() - vlast->GetFloat()) < HVFLUCT ) | |
556 | { | |
557 | hvCase = "Z"; | |
558 | } | |
559 | if (!dryRun) | |
560 | { | |
561 | MarkForDeletion(indices,1,nvalues-1); | |
562 | } | |
563 | } | |
564 | ||
565 | if (!dryRun) | |
566 | { | |
567 | for ( Int_t i = 0; i < nvalues; ++i ) | |
568 | { | |
569 | if ( indices[i] ) | |
570 | { | |
571 | values.RemoveAt(i); | |
572 | } | |
573 | } | |
574 | ||
575 | values.Compress(); | |
576 | } | |
577 | ||
578 | delete[] indices; | |
579 | ||
580 | if ( !values.GetEntries() ) | |
581 | { | |
582 | AliErrorClass(Form("No value left after patch... Check that !!! initial # of values=%d msg=%s", | |
583 | nvalues,internalMsg.Data())); | |
584 | hvCase = "OTHER"; | |
585 | } | |
586 | ||
587 | if (!dryRun) | |
588 | { | |
589 | // take the max of the remaining values | |
590 | TIter nextA(&values); | |
591 | AliDCSValue* val; | |
592 | Float_t maxval(-9999); | |
593 | ||
594 | while ( ( val = static_cast<AliDCSValue*>(nextA()) ) ) | |
595 | { | |
596 | if ( val->GetFloat() > maxval ) | |
597 | { | |
598 | maxval = val->GetFloat(); | |
599 | } | |
600 | } | |
601 | ||
602 | values.Clear(); | |
603 | ||
604 | values.Add(new AliDCSValue(maxval,meanTimeStamp)); | |
605 | } | |
606 | ||
607 | // once the case is inferred, add a "CASE:%10d",hvCase.Data() | |
608 | // to the msg | |
609 | // so we can them sum up for all channels and get a summary per run... | |
610 | ||
611 | internalMsg += Form("CASE:%s",hvCase.Data()); | |
612 | ||
613 | if (msg) *msg = internalMsg.Data(); | |
614 | ||
615 | return hvCase=="OTHER" ? kFALSE : kTRUE; | |
616 | } | |
617 | ||
618 | //_____________________________________________________________________________ | |
619 | TMap* | |
620 | AliMUONCalibrationData::CreateHV(Int_t runNumber, | |
621 | Int_t* startOfValidity, | |
622 | Bool_t patched, | |
623 | TList* messages, | |
624 | Bool_t dryRun) | |
625 | { | |
626 | /// Create a new HV map from the OCDB for a given run | |
627 | /// | |
628 | /// dryRun is only usefull with patched=kTRUE and non-empty messages) : | |
629 | /// it allow to get the list of messages without altering the values at all | |
630 | /// (A patch without a patch, so to speak...) | |
631 | /// | |
632 | ||
633 | TMap* hvMap = dynamic_cast<TMap*>(CreateObject(runNumber,"MUON/Calib/HV",startOfValidity)); | |
634 | ||
635 | if (!hvMap) return 0x0; | |
636 | ||
637 | if (patched) | |
638 | { | |
639 | TIter next(hvMap); | |
640 | TObjString* hvChannelName; | |
641 | ||
642 | while ( ( hvChannelName = static_cast<TObjString*>(next()) ) ) | |
643 | { | |
644 | TString name(hvChannelName->String()); | |
645 | ||
646 | if ( name.Contains("sw") ) continue; // skip switches | |
647 | ||
648 | if ( name.Contains("iMon") ) continue; // skip HV currents | |
649 | ||
650 | TPair* hvPair = static_cast<TPair*>(hvMap->FindObject(name.Data())); | |
651 | TObjArray* values = static_cast<TObjArray*>(hvPair->Value()); | |
652 | if (!values) | |
653 | { | |
654 | AliErrorClass(Form("Could not get values for alias %s",name.Data())); | |
655 | } | |
656 | else | |
657 | { | |
658 | TString msg; | |
659 | ||
660 | AliDebugClass(1,Form("channel %s",name.Data())); | |
661 | Bool_t ok = PatchHVValues(*values,&msg,dryRun); | |
662 | ||
663 | if ( messages ) | |
664 | { | |
665 | messages->Add(new TObjString(Form("%s %s",hvChannelName->String().Data(),msg.Data()))); | |
666 | } | |
667 | ||
668 | if (!ok) | |
669 | { | |
670 | AliErrorClass(Form("PatchHVValue was not successfull ! This is serious ! " | |
671 | "You'll have to check the logic for channel %s in run %09d", | |
672 | name.Data(),runNumber)); | |
673 | } | |
674 | } | |
675 | } | |
676 | ||
677 | } | |
678 | ||
679 | if ( messages ) | |
680 | { | |
681 | Int_t a(0),b(0),c(0),d(0),e(0),f(0),g(0),h(0),u(0),z(0); | |
682 | TIter next(messages); | |
683 | TObjString* msg; | |
684 | char hvCase('u'); | |
685 | ||
686 | while ( ( msg = static_cast<TObjString*>(next()) ) ) | |
687 | { | |
688 | Int_t i = msg->String().Index("CASE",strlen("CASE"),0,TString::kExact); | |
689 | ||
690 | if ( i >= 0 ) | |
691 | { | |
692 | sscanf(msg->String()(i,msg->String().Length()-i).Data(),"CASE:%10c",&hvCase); | |
693 | } | |
694 | ||
695 | switch (hvCase) | |
696 | { | |
697 | case 'A': ++a; break; | |
698 | case 'B': ++b; break; | |
699 | case 'C': ++c; break; | |
700 | case 'D': ++d; break; | |
701 | case 'E': ++e; break; | |
702 | case 'F': ++f; break; | |
703 | case 'G': ++g; break; | |
704 | case 'H': ++h; break; | |
705 | case 'Z': ++z; break; | |
706 | default: ++u; break; | |
707 | } | |
708 | } | |
709 | ||
710 | messages->Add(new TObjString(Form("SUMMARY : # of cases A(%3d) B(%3d) C(%3d) D(%3d) E(%3d) F(%3d) G(%3d) H(%3d) Z(%3d) OTHER(%3d)", | |
711 | a,b,c,d,e,f,g,h,z,u))); | |
712 | } | |
713 | ||
714 | return hvMap; | |
715 | } | |
716 | ||
717 | //_____________________________________________________________________________ | |
718 | TMap* | |
719 | AliMUONCalibrationData::CreateTriggerDCS(Int_t runNumber, Int_t* startOfValidity) | |
720 | { | |
721 | /// Create a new Trigger HV and curent map from the OCDB for a given run | |
722 | return dynamic_cast<TMap*>(CreateObject(runNumber,"MUON/Calib/TriggerDCS",startOfValidity)); | |
723 | } | |
724 | ||
725 | //_____________________________________________________________________________ | |
726 | AliMUONVStore* | |
727 | AliMUONCalibrationData::CreateLocalTriggerBoardMasks(Int_t runNumber, Int_t* startOfValidity) | |
728 | { | |
729 | /// Get the internal store for LocalTriggerBoardMasks from OCDB | |
730 | ||
731 | return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/LocalTriggerBoardMasks",startOfValidity)); | |
732 | } | |
733 | ||
734 | //_____________________________________________________________________________ | |
735 | AliMUONVStore* | |
736 | AliMUONCalibrationData::CreateNeighbours(Int_t runNumber, Int_t* startOfValidity) | |
737 | { | |
738 | /// Create a neighbour store from the OCDB for a given run | |
739 | return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/Neighbours",startOfValidity)); | |
740 | } | |
741 | ||
742 | //_____________________________________________________________________________ | |
743 | TObject* | |
744 | AliMUONCalibrationData::CreateObject(Int_t runNumber, const char* path, Int_t* startOfValidity) | |
745 | { | |
746 | /// Access the CDB for a given path (e.g. MUON/Calib/Pedestals), | |
747 | /// and return the corresponding TObject. | |
748 | ||
749 | AliCodeTimerAutoClass(Form("%09d : %s",runNumber,path),0); | |
750 | ||
751 | AliCDBManager* man = AliCDBManager::Instance(); | |
752 | ||
753 | AliCDBEntry* entry = man->Get(path,runNumber); | |
754 | ||
755 | if (entry) | |
756 | { | |
757 | if ( startOfValidity ) *startOfValidity = entry->GetId().GetFirstRun(); | |
758 | ||
759 | TObject* object = entry->GetObject(); | |
760 | if (!(man->GetCacheFlag())) | |
761 | { | |
762 | entry->SetOwner(kFALSE); | |
763 | delete entry; | |
764 | } | |
765 | // else | |
766 | // { | |
767 | // entry->SetOwner(kTRUE); //FIXME : this should be done but is causing problems with RecoParams at the end of the reco : investigate why... | |
768 | // } | |
769 | return object; | |
770 | } | |
771 | else | |
772 | { | |
773 | if ( startOfValidity ) *startOfValidity = AliCDBRunRange::Infinity(); | |
774 | } | |
775 | ||
776 | { | |
777 | ||
778 | AliCodeTimerAutoClass(Form("Failed to get %s for run %09d",path,runNumber),1); | |
779 | ||
780 | } | |
781 | ||
782 | return 0x0; | |
783 | } | |
784 | ||
785 | //_____________________________________________________________________________ | |
786 | AliMUONVStore* | |
787 | AliMUONCalibrationData::CreateOccupancyMap(Int_t runNumber, Int_t* startOfValidity) | |
788 | { | |
789 | /// Create a new occupancy map store from the OCDB for a given run | |
790 | return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/OccupancyMap",startOfValidity)); | |
791 | } | |
792 | ||
793 | //_____________________________________________________________________________ | |
794 | AliMUONRejectList* | |
795 | AliMUONCalibrationData::CreateRejectList(Int_t runNumber, Int_t* startOfValidity) | |
796 | { | |
797 | /// Create a new rejectlist store from the OCDB for a given run | |
798 | return dynamic_cast<AliMUONRejectList*>(CreateObject(runNumber,"MUON/Calib/RejectList",startOfValidity)); | |
799 | } | |
800 | ||
801 | //_____________________________________________________________________________ | |
802 | AliMUONVStore* | |
803 | AliMUONCalibrationData::CreatePedestals(Int_t runNumber, Int_t* startOfValidity) | |
804 | { | |
805 | /// Create a new pedestal store from the OCDB for a given run | |
806 | return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/Pedestals",startOfValidity)); | |
807 | } | |
808 | ||
809 | //_____________________________________________________________________________ | |
810 | AliMUONVStore* | |
811 | AliMUONCalibrationData::CreateConfig(Int_t runNumber, Int_t* startOfValidity) | |
812 | { | |
813 | /// Create a new config store from the OCDB for a given run | |
814 | return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/Config",startOfValidity)); | |
815 | } | |
816 | ||
817 | ||
818 | //_____________________________________________________________________________ | |
819 | AliMUONRegionalTriggerConfig* | |
820 | AliMUONCalibrationData::CreateRegionalTriggerConfig(Int_t runNumber, Int_t* startOfValidity) | |
821 | { | |
822 | /// Create the internal store for RegionalTriggerConfig from OCDB | |
823 | ||
824 | return dynamic_cast<AliMUONRegionalTriggerConfig*>(CreateObject(runNumber,"MUON/Calib/RegionalTriggerConfig",startOfValidity)); | |
825 | } | |
826 | ||
827 | //_____________________________________________________________________________ | |
828 | AliMUONTriggerEfficiencyCells* | |
829 | AliMUONCalibrationData::CreateTriggerEfficiency(Int_t runNumber, Int_t* startOfValidity) | |
830 | { | |
831 | /// Create trigger efficiency object from OCBD | |
832 | ||
833 | return dynamic_cast<AliMUONTriggerEfficiencyCells*>(CreateObject(runNumber,"MUON/Calib/TriggerEfficiency",startOfValidity)); | |
834 | } | |
835 | ||
836 | //_____________________________________________________________________________ | |
837 | AliMUONTriggerLut* | |
838 | AliMUONCalibrationData::CreateTriggerLut(Int_t runNumber, Int_t* startOfValidity) | |
839 | { | |
840 | /// Create trigger LUT from OCDB | |
841 | ||
842 | return dynamic_cast<AliMUONTriggerLut*>(CreateObject(runNumber,"MUON/Calib/TriggerLut",startOfValidity)); | |
843 | } | |
844 | ||
845 | //_____________________________________________________________________________ | |
846 | AliMUONVStore* | |
847 | AliMUONCalibrationData::Gains() const | |
848 | { | |
849 | /// Create (if needed) and return the internal store for gains. | |
850 | if (fgBypassGains) return fgBypassGains; | |
851 | ||
852 | if (!fGains) | |
853 | { | |
854 | fGains = CreateGains(fRunNumber); | |
855 | } | |
856 | return fGains; | |
857 | } | |
858 | ||
859 | //_____________________________________________________________________________ | |
860 | AliMUONVCalibParam* | |
861 | AliMUONCalibrationData::Gains(Int_t detElemId, Int_t manuId) const | |
862 | { | |
863 | /// Return the gains for a given (detElemId, manuId) pair | |
864 | /// Note that, unlike the DeadChannel case, if the result is 0x0, that's an | |
865 | /// error (meaning that we should get gains for all channels). | |
866 | ||
867 | AliMUONVStore* gains = Gains(); | |
868 | if (!gains) | |
869 | { | |
870 | return 0x0; | |
871 | } | |
872 | ||
873 | return static_cast<AliMUONVCalibParam*>(gains->FindObject(detElemId,manuId)); | |
874 | } | |
875 | ||
876 | //_____________________________________________________________________________ | |
877 | AliMUONGlobalCrateConfig* | |
878 | AliMUONCalibrationData::GlobalTriggerCrateConfig() const | |
879 | { | |
880 | /// Return the config for the global trigger board. | |
881 | ||
882 | if (!fGlobalTriggerCrateConfig) | |
883 | { | |
884 | fGlobalTriggerCrateConfig = CreateGlobalTriggerCrateConfig(fRunNumber); | |
885 | } | |
886 | return fGlobalTriggerCrateConfig; | |
887 | } | |
888 | ||
889 | ||
890 | //_____________________________________________________________________________ | |
891 | TMap* | |
892 | AliMUONCalibrationData::HV(Bool_t patched) const | |
893 | { | |
894 | /// Return the calibration for a given (detElemId, manuId) pair | |
895 | ||
896 | if (!fHV) | |
897 | { | |
898 | fHV = CreateHV(fRunNumber,0,patched); | |
899 | } | |
900 | return fHV; | |
901 | } | |
902 | ||
903 | //_____________________________________________________________________________ | |
904 | TMap* | |
905 | AliMUONCalibrationData::TriggerDCS() const | |
906 | { | |
907 | /// Return the calibration for a given (detElemId, manuId) pair | |
908 | ||
909 | if (!fTriggerDCS) | |
910 | { | |
911 | fTriggerDCS = CreateTriggerDCS(fRunNumber); | |
912 | } | |
913 | return fTriggerDCS; | |
914 | } | |
915 | ||
916 | //_____________________________________________________________________________ | |
917 | AliMUONVStore* | |
918 | AliMUONCalibrationData::Neighbours() const | |
919 | { | |
920 | /// Create (if needed) and return the internal store for neighbours. | |
921 | if (!fNeighbours) | |
922 | { | |
923 | fNeighbours = CreateNeighbours(fRunNumber); | |
924 | } | |
925 | return fNeighbours; | |
926 | } | |
927 | ||
928 | //_____________________________________________________________________________ | |
929 | AliMUONVCalibParam* | |
930 | AliMUONCalibrationData::LocalTriggerBoardMasks(Int_t localBoardNumber) const | |
931 | { | |
932 | /// Return the masks for a given trigger local board. | |
933 | ||
934 | if (!fLocalTriggerBoardMasks) | |
935 | { | |
936 | fLocalTriggerBoardMasks = CreateLocalTriggerBoardMasks(fRunNumber); | |
937 | } | |
938 | ||
939 | if ( fLocalTriggerBoardMasks ) | |
940 | { | |
941 | AliMUONVCalibParam* ltbm = | |
942 | static_cast<AliMUONVCalibParam*>(fLocalTriggerBoardMasks->FindObject(localBoardNumber)); | |
943 | if (!ltbm) | |
944 | { | |
945 | AliError(Form("Could not get mask for localBoardNumber=%d",localBoardNumber)); | |
946 | } | |
947 | return ltbm; | |
948 | } | |
949 | return 0x0; | |
950 | } | |
951 | ||
952 | //_____________________________________________________________________________ | |
953 | AliMUONVStore* | |
954 | AliMUONCalibrationData::OccupancyMap() const | |
955 | { | |
956 | /// Get occupancy map | |
957 | if (!fOccupancyMap) | |
958 | { | |
959 | fOccupancyMap = CreateOccupancyMap(fRunNumber); | |
960 | } | |
961 | return fOccupancyMap; | |
962 | } | |
963 | ||
964 | //_____________________________________________________________________________ | |
965 | AliMUONRejectList* | |
966 | AliMUONCalibrationData::RejectList() const | |
967 | { | |
968 | /// Get reject list | |
969 | if (!fRejectList) | |
970 | { | |
971 | fRejectList = CreateRejectList(fRunNumber); | |
972 | } | |
973 | return fRejectList; | |
974 | } | |
975 | ||
976 | //_____________________________________________________________________________ | |
977 | void | |
978 | AliMUONCalibrationData::BypassStores(AliMUONVStore* ped, AliMUONVStore* gain) | |
979 | { | |
980 | /// Force the use of those pedestals and gains | |
981 | fgBypassPedestals = ped; | |
982 | fgBypassGains = gain; | |
983 | ||
984 | } | |
985 | ||
986 | //_____________________________________________________________________________ | |
987 | AliMUONVStore* | |
988 | AliMUONCalibrationData::Pedestals() const | |
989 | { | |
990 | /// Return pedestals | |
991 | ||
992 | if (fgBypassPedestals) return fgBypassPedestals; | |
993 | ||
994 | if (!fPedestals) | |
995 | { | |
996 | fPedestals = CreatePedestals(fRunNumber); | |
997 | } | |
998 | return fPedestals; | |
999 | } | |
1000 | ||
1001 | //_____________________________________________________________________________ | |
1002 | AliMUONVStore* | |
1003 | AliMUONCalibrationData::Config() const | |
1004 | { | |
1005 | /// Return config | |
1006 | ||
1007 | if (!fConfig) | |
1008 | { | |
1009 | fConfig = CreateConfig(fRunNumber); | |
1010 | } | |
1011 | return fConfig; | |
1012 | } | |
1013 | ||
1014 | //_____________________________________________________________________________ | |
1015 | AliMUONVCalibParam* | |
1016 | AliMUONCalibrationData::Pedestals(Int_t detElemId, Int_t manuId) const | |
1017 | { | |
1018 | /// Return the pedestals for a given (detElemId, manuId) pair. | |
1019 | /// A return value of 0x0 is considered an error, meaning we should get | |
1020 | /// pedestals for all channels. | |
1021 | ||
1022 | AliMUONVStore* pedestals = Pedestals(); | |
1023 | if (!pedestals) | |
1024 | { | |
1025 | return 0x0; | |
1026 | } | |
1027 | ||
1028 | return static_cast<AliMUONVCalibParam*>(pedestals->FindObject(detElemId,manuId)); | |
1029 | } | |
1030 | ||
1031 | //_____________________________________________________________________________ | |
1032 | void | |
1033 | AliMUONCalibrationData::Print(Option_t*) const | |
1034 | { | |
1035 | /// A very basic dump of our guts. | |
1036 | ||
1037 | cout << "RunNumber " << RunNumber() | |
1038 | << " fGains=" << fGains | |
1039 | << " fPedestals=" << fPedestals | |
1040 | << " fConfig=" << fConfig | |
1041 | << " fHV=" << fHV | |
1042 | << " fTriggerDCS=" << fTriggerDCS | |
1043 | << " fLocalTriggerBoardMasks=" << fLocalTriggerBoardMasks | |
1044 | << " fRegionalTriggerConfig=" << fRegionalTriggerConfig | |
1045 | << " fGlobalTriggerCrateConfig=" << fGlobalTriggerCrateConfig | |
1046 | << " fTriggerLut=" << fTriggerLut | |
1047 | << endl; | |
1048 | } | |
1049 | ||
1050 | ||
1051 | //_____________________________________________________________________________ | |
1052 | AliMUONRegionalTriggerConfig* | |
1053 | AliMUONCalibrationData::RegionalTriggerConfig() const | |
1054 | { | |
1055 | /// Return the config for the regional trigger board. | |
1056 | ||
1057 | if (!fRegionalTriggerConfig) | |
1058 | { | |
1059 | fRegionalTriggerConfig = CreateRegionalTriggerConfig(fRunNumber); | |
1060 | } | |
1061 | return fRegionalTriggerConfig; | |
1062 | } | |
1063 | ||
1064 | ||
1065 | //_____________________________________________________________________________ | |
1066 | AliMUONTriggerEfficiencyCells* | |
1067 | AliMUONCalibrationData::TriggerEfficiency() const | |
1068 | { | |
1069 | /// Return the trigger efficiency. | |
1070 | ||
1071 | if (!fTriggerEfficiency) | |
1072 | { | |
1073 | fTriggerEfficiency = CreateTriggerEfficiency(fRunNumber); | |
1074 | } | |
1075 | return fTriggerEfficiency; | |
1076 | } | |
1077 | ||
1078 | ||
1079 | //_____________________________________________________________________________ | |
1080 | AliMUONTriggerLut* | |
1081 | AliMUONCalibrationData::TriggerLut() const | |
1082 | { | |
1083 | /// Return the trigger look up table. | |
1084 | ||
1085 | if (!fTriggerLut) | |
1086 | { | |
1087 | fTriggerLut = CreateTriggerLut(fRunNumber); | |
1088 | } | |
1089 | return fTriggerLut; | |
1090 | } | |
1091 | ||
1092 | //_____________________________________________________________________________ | |
1093 | void | |
1094 | AliMUONCalibrationData::Reset() | |
1095 | { | |
1096 | /// Reset all data | |
1097 | ||
1098 | AliCodeTimerAuto("",0); | |
1099 | ||
1100 | delete fConfig; | |
1101 | fConfig = 0x0; | |
1102 | delete fPedestals; | |
1103 | fPedestals = 0x0; | |
1104 | delete fGains; | |
1105 | fGains = 0x0; | |
1106 | delete fHV; | |
1107 | fHV = 0x0; | |
1108 | delete fTriggerDCS; | |
1109 | fTriggerDCS = 0x0; | |
1110 | delete fLocalTriggerBoardMasks; | |
1111 | fLocalTriggerBoardMasks = 0x0; | |
1112 | delete fRegionalTriggerConfig; | |
1113 | fRegionalTriggerConfig = 0x0; | |
1114 | delete fGlobalTriggerCrateConfig; | |
1115 | fGlobalTriggerCrateConfig = 0x0; | |
1116 | ||
1117 | delete fTriggerLut; | |
1118 | fTriggerLut = 0x0; | |
1119 | delete fTriggerEfficiency; | |
1120 | fTriggerEfficiency = 0x0; | |
1121 | delete fCapacitances; | |
1122 | fCapacitances = 0x0; | |
1123 | delete fNeighbours; | |
1124 | fNeighbours = 0x0; | |
1125 | } | |
1126 | ||
1127 | //_____________________________________________________________________________ | |
1128 | void | |
1129 | AliMUONCalibrationData::Check(Int_t runNumber) | |
1130 | { | |
1131 | /// Self-check to see if we can read all data for a given run | |
1132 | /// from the current OCDB... | |
1133 | ||
1134 | if ( ! CreateCapacitances(runNumber) ) | |
1135 | { | |
1136 | AliErrorClass("Could not read capacitances"); | |
1137 | } | |
1138 | else | |
1139 | { | |
1140 | AliInfoClass("Capacitances read OK"); | |
1141 | } | |
1142 | ||
1143 | if ( ! CreateGains(runNumber) ) | |
1144 | { | |
1145 | AliErrorClass("Could not read gains"); | |
1146 | } | |
1147 | else | |
1148 | { | |
1149 | AliInfoClass("Gains read OK"); | |
1150 | } | |
1151 | ||
1152 | if ( ! CreateGlobalTriggerCrateConfig(runNumber) ) | |
1153 | { | |
1154 | AliErrorClass("Could not read Trigger Crate Config"); | |
1155 | } | |
1156 | else | |
1157 | { | |
1158 | AliInfoClass("TriggerBoardMasks read OK"); | |
1159 | } | |
1160 | ||
1161 | if ( ! CreateHV(runNumber) ) | |
1162 | { | |
1163 | AliErrorClass("Could not read HV"); | |
1164 | } | |
1165 | else | |
1166 | { | |
1167 | AliInfoClass("HV read OK"); | |
1168 | } | |
1169 | ||
1170 | if ( ! CreateTriggerDCS(runNumber) ) | |
1171 | { | |
1172 | AliErrorClass("Could not read Trigger HV and Currents"); | |
1173 | } | |
1174 | else | |
1175 | { | |
1176 | AliInfoClass("Trigger HV and Currents read OK"); | |
1177 | } | |
1178 | ||
1179 | if ( ! CreateNeighbours(runNumber) ) | |
1180 | { | |
1181 | AliErrorClass("Could not read Neighbours"); | |
1182 | } | |
1183 | else | |
1184 | { | |
1185 | AliInfoClass("Neighbours read OK"); | |
1186 | } | |
1187 | ||
1188 | if ( ! CreateLocalTriggerBoardMasks(runNumber) ) | |
1189 | { | |
1190 | AliErrorClass("Could not read LocalTriggerBoardMasks"); | |
1191 | } | |
1192 | else | |
1193 | { | |
1194 | AliInfoClass("LocalTriggerBoardMasks read OK"); | |
1195 | } | |
1196 | ||
1197 | if ( ! CreatePedestals(runNumber) ) | |
1198 | { | |
1199 | AliErrorClass("Could not read pedestals"); | |
1200 | } | |
1201 | else | |
1202 | { | |
1203 | AliInfoClass("Pedestals read OK"); | |
1204 | } | |
1205 | ||
1206 | if ( ! CreateConfig(runNumber) ) | |
1207 | { | |
1208 | AliErrorClass("Could not read config"); | |
1209 | } | |
1210 | else | |
1211 | { | |
1212 | AliInfoClass("Config read OK"); | |
1213 | } | |
1214 | ||
1215 | if ( ! CreateRegionalTriggerConfig(runNumber) ) | |
1216 | { | |
1217 | AliErrorClass("Could not read RegionalTriggerConfig"); | |
1218 | } | |
1219 | else | |
1220 | { | |
1221 | AliInfoClass("RegionalTriggerBoardMasks read OK"); | |
1222 | } | |
1223 | ||
1224 | if ( ! CreateTriggerLut(runNumber) ) | |
1225 | { | |
1226 | AliErrorClass("Could not read TriggerLut"); | |
1227 | } | |
1228 | else | |
1229 | { | |
1230 | AliInfoClass("TriggerLut read OK"); | |
1231 | } | |
1232 | ||
1233 | if ( ! CreateTriggerEfficiency(runNumber) ) | |
1234 | { | |
1235 | AliErrorClass("Could not read TriggerEfficiency"); | |
1236 | } | |
1237 | else | |
1238 | { | |
1239 | AliInfoClass("TriggerEfficiency read OK"); | |
1240 | } | |
1241 | } |