]>
Commit | Line | Data |
---|---|---|
0145e89a | 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 "AliMUONTrackerData.h" | |
19 | ||
20 | #include "AliMUONCalibParamND.h" | |
21 | #include "AliMUONVStore.h" | |
22 | #include "AliMpBusPatch.h" | |
23 | #include "AliMpDDLStore.h" | |
24 | #include "AliMpDEManager.h" | |
25 | #include "AliMpDEIterator.h" | |
26 | #include "AliMpDetElement.h" | |
27 | #include "AliMpHVNamer.h" | |
28 | #include "AliCodeTimer.h" | |
29 | #include "AliLog.h" | |
30 | #include <Riostream.h> | |
31 | #include <TMath.h> | |
32 | #include <TObjArray.h> | |
33 | #include <TObjString.h> | |
34 | #include <TString.h> | |
35 | #include <TVector2.h> | |
36 | #include <float.h> | |
37 | ||
38 | /// \class AliMUONTrackerData | |
39 | /// | |
40 | /// Implementation of AliMUONVTrackerData class | |
41 | /// | |
42 | /// \author Laurent Aphecetche, Subatech | |
43 | ||
44 | ///\cond CLASSIMP | |
45 | ClassImp(AliMUONTrackerData) | |
46 | ///\endcond | |
47 | ||
48 | const Int_t AliMUONTrackerData::fgkExtraDimension = 2; | |
49 | const Int_t AliMUONTrackerData::fgkVirtualExtraDimension = 1; | |
50 | ||
51 | //_____________________________________________________________________________ | |
52 | AliMUONTrackerData::AliMUONTrackerData(const char* name, const char* title, | |
53 | Int_t dimension, | |
54 | Bool_t runnable) | |
55 | : AliMUONVTrackerData(name,title), | |
56 | fChannelValues(0x0), | |
57 | fManuValues(0x0), | |
58 | fBusPatchValues(0x0), | |
59 | fDEValues(0x0), | |
60 | fChamberValues(0x0), | |
61 | fPCBValues(0x0), | |
62 | fDimension(dimension*2+fgkExtraDimension), | |
63 | fNevents(0x0), | |
64 | fDimensionNames(new TObjArray(fDimension+fgkVirtualExtraDimension)), | |
65 | fExternalDimension(dimension), | |
66 | fIsRunnable(runnable) | |
67 | { | |
68 | /// ctor | |
69 | fDimensionNames->SetOwner(kTRUE); | |
70 | fDimensionNames->AddAt(new TObjString("occ"),IndexOfOccupancyDimension()); | |
71 | fDimensionNames->AddAt(new TObjString("N"),IndexOfNumberDimension()); | |
72 | fDimensionNames->AddAt(new TObjString("n"),NumberOfDimensions()-fgkVirtualExtraDimension); | |
73 | Clear(); | |
74 | } | |
75 | ||
76 | //_____________________________________________________________________________ | |
77 | AliMUONTrackerData::~AliMUONTrackerData() | |
78 | { | |
79 | /// dtor | |
80 | delete fChannelValues; | |
81 | delete fManuValues; | |
82 | delete fBusPatchValues; | |
83 | delete fDEValues; | |
84 | delete fChamberValues; | |
85 | delete fPCBValues; | |
86 | delete fDimensionNames; | |
87 | } | |
88 | ||
89 | //_____________________________________________________________________________ | |
90 | Bool_t | |
91 | AliMUONTrackerData::Add(const AliMUONVStore& store) | |
92 | { | |
93 | /// We first convert the external store to a temporary internal store | |
94 | /// with more dimension (2*store's dimension) | |
95 | ||
96 | AliCodeTimerAuto(GetName()) | |
97 | ||
98 | Int_t ndim(NumberOfDimensions()-fgkExtraDimension-fgkVirtualExtraDimension); | |
99 | ||
100 | AliMUONVStore* istore = store.Create(); | |
101 | ||
102 | TIter next(store.CreateIterator()); | |
103 | AliMUONVCalibParam* external; | |
104 | ||
105 | AliCodeTimerStart("from external to internal store"); | |
106 | ||
107 | while ( ( external = static_cast<AliMUONVCalibParam*>(next()) ) ) | |
108 | { | |
109 | Int_t detElemId = external->ID0(); | |
110 | Int_t manuId = external->ID1(); | |
111 | ||
112 | AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId); | |
113 | ||
114 | AliMUONVCalibParam* internal = static_cast<AliMUONVCalibParam*> | |
115 | (istore->FindObject(detElemId,manuId)); | |
116 | ||
117 | if (!internal) | |
118 | { | |
119 | internal = new AliMUONCalibParamND(ndim,external->Size(), | |
120 | detElemId, manuId, | |
121 | 0.0); | |
122 | istore->Add(internal); | |
123 | } | |
124 | ||
125 | for ( Int_t i = 0; i < external->Size(); ++i ) | |
126 | { | |
127 | Bool_t connectPad = de->IsConnectedChannel(manuId,i); | |
128 | ||
129 | if (!connectPad) continue; | |
130 | ||
131 | for ( Int_t j = 0; j < external->Dimension(); ++j ) | |
132 | { | |
133 | Int_t ix = External2Internal(j); | |
134 | ||
135 | Double_t vext = external->IsDoublePrecision() ? | |
136 | external->ValueAsDouble(i,j) : | |
137 | external->ValueAsFloat(i,j); | |
138 | ||
139 | Double_t sumw = internal->ValueAsDouble(i,ix) + vext; | |
140 | Double_t sumw2 = internal->ValueAsDouble(i,ix+1) + vext*vext; | |
141 | ||
142 | internal->SetValueAsFloat(i,ix,sumw); | |
143 | internal->SetValueAsFloat(i,ix+1,sumw2); | |
144 | } | |
145 | } | |
146 | } | |
147 | ||
148 | AliCodeTimerStop("from external to internal store"); | |
149 | ||
150 | /// and we add this internal store to what we already have | |
151 | ||
152 | InternalAdd(*istore); | |
153 | ||
154 | /// delete the temporary internal store. | |
155 | AliCodeTimerStart("delete"); | |
156 | delete istore; | |
157 | AliCodeTimerStop("delete"); | |
158 | ||
159 | return kTRUE; | |
160 | } | |
161 | ||
162 | //_____________________________________________________________________________ | |
163 | Double_t | |
164 | AliMUONTrackerData::BusPatch(Int_t busPatchId, Int_t dim) const | |
165 | { | |
166 | /// Return the value of a given buspatch for a given dimension | |
167 | /// or 0 if not existing | |
168 | AliMUONVCalibParam* param = BusPatchParam(busPatchId); | |
169 | return param ? Value(*param,0,dim) : 0.0; | |
170 | } | |
171 | ||
172 | //_____________________________________________________________________________ | |
173 | AliMUONVCalibParam* | |
174 | AliMUONTrackerData::BusPatchParam(Int_t busPatchId) const | |
175 | { | |
176 | /// Return (if it exist), the VCalibParam for a given busPatch | |
177 | return fBusPatchValues ? static_cast<AliMUONVCalibParam*> | |
178 | (fBusPatchValues->FindObject(busPatchId)) : 0x0; | |
179 | } | |
180 | ||
181 | //_____________________________________________________________________________ | |
182 | Double_t | |
183 | AliMUONTrackerData::Chamber(Int_t chamberId, Int_t dim) const | |
184 | { | |
185 | /// Return the value fo a given chamber for a given dimension, | |
186 | /// or zero if not existing | |
187 | AliMUONVCalibParam* param = ChamberParam(chamberId); | |
188 | return param ? Value(*param,0,dim) : 0.0; | |
189 | } | |
190 | ||
191 | //_____________________________________________________________________________ | |
192 | AliMUONVCalibParam* | |
193 | AliMUONTrackerData::ChamberParam(Int_t chamberId) const | |
194 | { | |
195 | /// Return (if it exist) the VCalibParam for a given chamber | |
196 | return fChamberValues ? static_cast<AliMUONVCalibParam*> | |
197 | (fChamberValues->FindObject(chamberId)) : 0x0; | |
198 | } | |
199 | ||
200 | //_____________________________________________________________________________ | |
201 | Double_t | |
202 | AliMUONTrackerData::Channel(Int_t detElemId, Int_t manuId, | |
203 | Int_t manuChannel, Int_t dim) const | |
204 | { | |
205 | /// Return the value for a given channel for a given dimension | |
206 | ||
207 | AliMUONVCalibParam* param = ChannelParam(detElemId,manuId); | |
208 | ||
209 | return param ? Value(*param,manuChannel,dim) : 0.0; | |
210 | } | |
211 | ||
212 | //_____________________________________________________________________________ | |
213 | AliMUONVCalibParam* | |
214 | AliMUONTrackerData::ChannelParam(Int_t detElemId, Int_t manuId) const | |
215 | { | |
216 | /// Return (if it exist) the VCalibParam for a given manu | |
217 | return fChannelValues ? static_cast<AliMUONVCalibParam*> | |
218 | (fChannelValues->FindObject(detElemId,manuId)) : 0x0 ; | |
219 | } | |
220 | ||
221 | ||
222 | //_____________________________________________________________________________ | |
223 | void | |
224 | AliMUONTrackerData::Clear(Option_t*) | |
225 | { | |
226 | /// Clear all the values | |
227 | if ( fChannelValues ) fChannelValues->Clear(); | |
228 | if ( fManuValues ) fManuValues->Clear(); | |
229 | if ( fBusPatchValues) fBusPatchValues->Clear(); | |
230 | if ( fPCBValues ) fPCBValues->Clear(); | |
231 | if ( fDEValues) fDEValues->Clear(); | |
232 | if ( fChamberValues) fChamberValues->Clear(); | |
233 | fNevents = 0; | |
234 | NumberOfEventsChanged(); | |
235 | } | |
236 | ||
237 | //_____________________________________________________________________________ | |
238 | Double_t | |
239 | AliMUONTrackerData::Count(Int_t detElemId, Int_t manuId, | |
240 | Int_t manuChannel) const | |
241 | { | |
242 | /// Return the number of times a given channel had data | |
243 | AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*> | |
244 | (fChannelValues->FindObject(detElemId,manuId)); | |
245 | ||
246 | if ( !param ) return 0.0; | |
247 | ||
248 | return param->ValueAsDouble(manuChannel,IndexOfOccupancyDimension()); | |
249 | } | |
250 | ||
251 | //_____________________________________________________________________________ | |
252 | AliMUONVCalibParam* | |
253 | AliMUONTrackerData::CreateDouble(const AliMUONVCalibParam& param) const | |
254 | { | |
255 | /// Create a double version of VCalibParam, for internal use | |
256 | AliMUONVCalibParam* c = new AliMUONCalibParamND(param.Dimension()+fgkExtraDimension, | |
257 | param.Size(), | |
258 | param.ID0(), | |
259 | param.ID1(), | |
260 | 0.0); | |
261 | ||
262 | for ( Int_t i = 0; i < c->Size(); ++i ) | |
263 | { | |
264 | c->SetValueAsDouble(i,IndexOfNumberDimension(),1.0); | |
265 | } | |
266 | ||
267 | return c; | |
268 | } | |
269 | ||
270 | //_____________________________________________________________________________ | |
271 | Double_t | |
272 | AliMUONTrackerData::DetectionElement(Int_t detElemId, Int_t dim) const | |
273 | { | |
274 | /// Return the value for a given detection element for a given dimension | |
275 | AliMUONVCalibParam* param = DetectionElementParam(detElemId); | |
276 | return param ? Value(*param,0,dim) : 0.0; | |
277 | ||
278 | } | |
279 | ||
280 | //_____________________________________________________________________________ | |
281 | AliMUONVCalibParam* | |
282 | AliMUONTrackerData::DetectionElementParam(Int_t detElemId) const | |
283 | { | |
284 | /// Return (if it exist) the VCalibParam for a given detection element | |
285 | return fDEValues ? static_cast<AliMUONVCalibParam*> | |
286 | (fDEValues->FindObject(detElemId)) : 0x0 ; | |
287 | } | |
288 | ||
289 | //_____________________________________________________________________________ | |
290 | TString | |
291 | AliMUONTrackerData::DimensionName(Int_t dim) const | |
292 | { | |
293 | /// Get the name of a given dimension | |
294 | TObjString* value = static_cast<TObjString*>(fDimensionNames->At(dim)); | |
295 | if ( value ) | |
296 | { | |
297 | return value->String(); | |
298 | } | |
299 | else | |
300 | { | |
301 | return TString("Invalid"); | |
302 | } | |
303 | } | |
304 | ||
305 | //_____________________________________________________________________________ | |
306 | Bool_t | |
307 | AliMUONTrackerData::HasBusPatch(Int_t busPatchId) const | |
308 | { | |
309 | /// Whether we have data for a given buspatch | |
310 | return ( BusPatchParam(busPatchId) != 0 ); | |
311 | } | |
312 | ||
313 | //_____________________________________________________________________________ | |
314 | Bool_t | |
315 | AliMUONTrackerData::HasChamber(Int_t chamberId) const | |
316 | { | |
317 | /// Whether we have data for a given chamber | |
318 | return ( ChamberParam(chamberId) != 0 ); | |
319 | } | |
320 | ||
321 | //_____________________________________________________________________________ | |
322 | Bool_t | |
323 | AliMUONTrackerData::HasDetectionElement(Int_t detElemId) const | |
324 | { | |
325 | /// Whether we have data for a given detection element | |
326 | return ( DetectionElementParam(detElemId) != 0 ); | |
327 | } | |
328 | ||
329 | //_____________________________________________________________________________ | |
330 | Bool_t | |
331 | AliMUONTrackerData::HasManu(Int_t detElemId, Int_t manuId) const | |
332 | { | |
333 | /// Whether we have data for a given manu | |
334 | return ( ManuParam(detElemId,manuId) != 0 ); | |
335 | } | |
336 | ||
337 | //_____________________________________________________________________________ | |
338 | Bool_t | |
339 | AliMUONTrackerData::HasPCB(Int_t detElemId, Int_t pcbIndex) const | |
340 | { | |
341 | /// Whether we have data for a given pcb | |
342 | return ( PCBParam(detElemId,pcbIndex) != 0 ); | |
343 | } | |
344 | ||
345 | //_____________________________________________________________________________ | |
346 | Bool_t | |
347 | AliMUONTrackerData::InternalAdd(const AliMUONVStore& store) | |
348 | { | |
349 | /// Add the given store to our internal store | |
350 | /// Store must be of dimension = fDimension-1 | |
351 | ||
352 | AliCodeTimerAuto(GetName()); | |
353 | ||
354 | AliMpDDLStore* ddlStore = AliMpDDLStore::Instance(); | |
355 | ||
356 | ++fNevents; | |
357 | NumberOfEventsChanged(); | |
358 | ||
359 | if (!fChannelValues) | |
360 | { | |
361 | fChannelValues = store.Create(); | |
362 | fManuValues = store.Create(); | |
363 | fBusPatchValues = store.Create(); | |
364 | fDEValues = store.Create(); | |
365 | fChamberValues = store.Create(); | |
366 | fPCBValues = store.Create(); | |
367 | } | |
368 | ||
369 | TIter next(store.CreateIterator()); | |
370 | AliMUONVCalibParam* external; | |
371 | ||
372 | AliMpHVNamer namer; | |
373 | ||
374 | while ( ( external = static_cast<AliMUONVCalibParam*>(next()) ) ) | |
375 | { | |
376 | if ( external->Dimension() != fDimension-fgkExtraDimension ) | |
377 | { | |
378 | AliError(Form("Incompatible dimensions %d vs %d", | |
379 | external->Dimension(),fDimension-fgkExtraDimension)); | |
380 | return kFALSE; | |
381 | } | |
382 | ||
383 | Int_t detElemId = external->ID0(); | |
384 | ||
385 | AliMp::StationType stationType = AliMpDEManager::GetStationType(detElemId); | |
386 | ||
387 | Int_t chamberId = AliMpDEManager::GetChamberId(detElemId); | |
388 | ||
389 | Int_t manuId = external->ID1(); | |
390 | ||
391 | AliMpDetElement* mpde = ddlStore->GetDetElement(detElemId); | |
392 | ||
393 | Int_t busPatchId = ddlStore->GetBusPatchId(detElemId,manuId); | |
394 | ||
395 | Int_t pcbIndex = -1; | |
396 | ||
397 | if ( stationType == AliMp::kStation345 ) | |
398 | { | |
399 | pcbIndex = namer.ManuId2PCBIndex(detElemId,manuId); | |
400 | } | |
401 | ||
402 | AliMUONVCalibParam* channel = ChannelParam(detElemId,manuId); | |
403 | if (!channel) | |
404 | { | |
405 | channel = CreateDouble(*external); | |
406 | fChannelValues->Add(channel); | |
407 | } | |
408 | ||
409 | AliMUONVCalibParam* manu = ManuParam(detElemId,manuId); | |
410 | if (!manu) | |
411 | { | |
412 | manu = new AliMUONCalibParamND(external->Dimension()+fgkExtraDimension, | |
413 | 1, | |
414 | detElemId, | |
415 | manuId, | |
416 | 0.0); | |
417 | ||
418 | // set the number of channels in that manu | |
419 | ||
420 | AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId); | |
421 | ||
422 | manu->SetValueAsDouble(0,IndexOfNumberDimension(),de->NofChannelsInManu(manuId)); | |
423 | ||
424 | fManuValues->Add(manu); | |
425 | } | |
426 | ||
427 | AliMUONVCalibParam* busPatch = BusPatchParam(busPatchId); | |
428 | if (!busPatch) | |
429 | { | |
430 | AliMpBusPatch* bp = AliMpDDLStore::Instance()->GetBusPatch(busPatchId); | |
431 | ||
432 | if (!bp) | |
433 | { | |
434 | AliError(Form("Got an invalid buspatchId = %d",busPatchId)); | |
435 | continue; | |
436 | } | |
437 | ||
438 | busPatch = new AliMUONCalibParamND(external->Dimension()+fgkExtraDimension, | |
439 | 1, | |
440 | busPatchId, | |
441 | 0, | |
442 | 0.0); | |
443 | ||
444 | // set the number of channels in that buspatch | |
445 | ||
446 | Int_t nchannels(0); | |
447 | ||
448 | AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId); | |
449 | ||
450 | for ( Int_t i = 0; i < bp->GetNofManus(); ++i ) | |
451 | { | |
452 | Int_t manuId = bp->GetManuId(i); | |
453 | nchannels += de->NofChannelsInManu(manuId); | |
454 | } | |
455 | ||
456 | busPatch->SetValueAsDouble(0,IndexOfNumberDimension(),nchannels); | |
457 | ||
458 | fBusPatchValues->Add(busPatch); | |
459 | } | |
460 | ||
461 | AliMUONVCalibParam* de = DetectionElementParam(detElemId); | |
462 | if (!de) | |
463 | { | |
464 | de = new AliMUONCalibParamND(external->Dimension()+fgkExtraDimension, | |
465 | 1, | |
466 | detElemId, | |
467 | 0, | |
468 | 0.0); | |
469 | ||
470 | AliMpDetElement* det = AliMpDDLStore::Instance()->GetDetElement(detElemId); | |
471 | Int_t nchannels(0); | |
472 | ||
473 | for ( Int_t i = 0; i < det->GetNofBusPatches(); ++i ) | |
474 | { | |
475 | Int_t busPatchId = det->GetBusPatchId(i); | |
476 | AliMpBusPatch* bp = AliMpDDLStore::Instance()->GetBusPatch(busPatchId); | |
477 | for ( Int_t j = 0; j < bp->GetNofManus(); ++j ) | |
478 | { | |
479 | Int_t manuId = bp->GetManuId(j); | |
480 | nchannels += det->NofChannelsInManu(manuId); | |
481 | } | |
482 | } | |
483 | ||
484 | de->SetValueAsDouble(0,IndexOfNumberDimension(),nchannels); | |
485 | ||
486 | fDEValues->Add(de); | |
487 | } | |
488 | ||
489 | AliMUONVCalibParam* chamber = ChamberParam(chamberId); | |
490 | if (!chamber) | |
491 | { | |
492 | chamber = new AliMUONCalibParamND(external->Dimension()+fgkExtraDimension, | |
493 | 1, | |
494 | chamberId, | |
495 | 0, | |
496 | 0.0); | |
497 | ||
498 | // set the number of channels in that chamber | |
499 | ||
500 | Int_t nchannels(0); | |
501 | ||
502 | AliMpDEIterator it; | |
503 | ||
504 | it.First(chamberId); | |
505 | ||
506 | while ( !it.IsDone() ) | |
507 | { | |
508 | AliMpDetElement* det = it.CurrentDE(); | |
509 | ||
510 | for ( Int_t i = 0; i < det->GetNofBusPatches(); ++i ) | |
511 | { | |
512 | Int_t busPatchId = det->GetBusPatchId(i); | |
513 | AliMpBusPatch* bp = AliMpDDLStore::Instance()->GetBusPatch(busPatchId); | |
514 | for ( Int_t j = 0; j < bp->GetNofManus(); ++j ) | |
515 | { | |
516 | Int_t manuId = bp->GetManuId(j); | |
517 | nchannels += det->NofChannelsInManu(manuId); | |
518 | } | |
519 | } | |
520 | ||
521 | it.Next(); | |
522 | } | |
523 | ||
524 | chamber->SetValueAsDouble(0,IndexOfNumberDimension(),nchannels); | |
525 | ||
526 | fChamberValues->Add(chamber); | |
527 | } | |
528 | ||
529 | AliMUONVCalibParam* pcb = 0x0; | |
530 | ||
531 | if ( pcbIndex >= 0 ) | |
532 | { | |
533 | pcb = PCBParam(detElemId,pcbIndex); | |
534 | if (!pcb) | |
535 | { | |
536 | pcb = new AliMUONCalibParamND(external->Dimension()+fgkExtraDimension, | |
537 | namer.NumberOfPCBs(detElemId), | |
538 | detElemId, | |
539 | pcbIndex, | |
540 | 0.0); | |
541 | fPCBValues->Add(pcb); | |
542 | } | |
543 | } | |
544 | ||
545 | for ( Int_t i = 0; i < external->Size(); ++i ) | |
546 | { | |
547 | Bool_t existingChannel = mpde->IsConnectedChannel(manuId,i); | |
548 | ||
549 | if ( existingChannel ) | |
550 | { | |
551 | Bool_t validChannel(kFALSE); | |
552 | ||
553 | for ( Int_t j = 0; j < external->Dimension(); ++j ) | |
554 | { | |
555 | if ( external->ValueAsFloat(i,j) >= AliMUONVCalibParam::InvalidFloatValue() ) continue; | |
556 | ||
557 | validChannel = kTRUE; | |
558 | ||
559 | Double_t vext = external->IsDoublePrecision() ? | |
560 | external->ValueAsDouble(i,j) : | |
561 | external->ValueAsFloat(i,j); | |
562 | ||
563 | Double_t value = channel->ValueAsDouble(i,j) + vext; | |
564 | ||
565 | channel->SetValueAsDouble(i,j,value); | |
566 | ||
567 | manu->SetValueAsDouble(0,j,manu->ValueAsDouble(0,j)+vext); | |
568 | ||
569 | busPatch->SetValueAsDouble(0,j,busPatch->ValueAsDouble(0,j)+vext); | |
570 | ||
571 | de->SetValueAsDouble(0,j,de->ValueAsDouble(0,j)+vext); | |
572 | ||
573 | chamber->SetValueAsDouble(0,j,chamber->ValueAsDouble(0,j)+vext); | |
574 | ||
575 | if ( pcb ) | |
576 | { | |
577 | pcb->SetValueAsDouble(pcbIndex,j,pcb->ValueAsDouble(pcbIndex,j)+vext); | |
578 | } | |
579 | } | |
580 | ||
581 | if ( validChannel ) | |
582 | { | |
583 | channel->SetValueAsDouble(i,IndexOfOccupancyDimension(), | |
584 | channel->ValueAsDouble(i,IndexOfOccupancyDimension())+1.0); | |
585 | manu->SetValueAsDouble(0,IndexOfOccupancyDimension(), | |
586 | manu->ValueAsDouble(0,IndexOfOccupancyDimension())+1.0); | |
587 | busPatch->SetValueAsDouble(0,IndexOfOccupancyDimension(), | |
588 | busPatch->ValueAsDouble(0,IndexOfOccupancyDimension())+1.0); | |
589 | de->SetValueAsDouble(0,IndexOfOccupancyDimension(), | |
590 | de->ValueAsDouble(0,IndexOfOccupancyDimension())+1.0); | |
591 | chamber->SetValueAsDouble(0,IndexOfOccupancyDimension(), | |
592 | chamber->ValueAsDouble(0,IndexOfOccupancyDimension())+1.0); | |
593 | if ( pcb ) | |
594 | { | |
595 | pcb->SetValueAsDouble(pcbIndex,IndexOfOccupancyDimension(), | |
596 | pcb->ValueAsDouble(pcbIndex,IndexOfOccupancyDimension())+1.0); | |
597 | } | |
598 | } | |
599 | } | |
600 | } | |
601 | } | |
602 | ||
603 | return kTRUE; | |
604 | } | |
605 | ||
606 | //_____________________________________________________________________________ | |
607 | Double_t | |
608 | AliMUONTrackerData::Manu(Int_t detElemId, Int_t manuId, Int_t dim) const | |
609 | { | |
9016a84e | 610 | /// Return the value for a given manu and a given dimension |
611 | ||
0145e89a | 612 | AliMUONVCalibParam* param = ManuParam(detElemId,manuId); |
613 | return param ? Value(*param,0,dim) : 0.0; | |
614 | } | |
615 | ||
616 | //_____________________________________________________________________________ | |
617 | AliMUONVCalibParam* | |
618 | AliMUONTrackerData::ManuParam(Int_t detElemId, Int_t manuId) const | |
619 | { | |
9016a84e | 620 | /// Get the VCalibParam for a given manu |
0145e89a | 621 | return fManuValues ? static_cast<AliMUONVCalibParam*> |
622 | (fManuValues->FindObject(detElemId,manuId)) : 0x0 ; | |
623 | } | |
624 | ||
625 | //_____________________________________________________________________________ | |
626 | Int_t | |
627 | AliMUONTrackerData::NumberOfDimensions() const | |
628 | { | |
629 | /// Number of dimensions we're dealing with | |
630 | ||
631 | return fDimension + fgkVirtualExtraDimension; | |
632 | } | |
633 | ||
634 | //_____________________________________________________________________________ | |
635 | Double_t | |
636 | AliMUONTrackerData::PCB(Int_t detElemId, Int_t pcbIndex, Int_t dim) const | |
637 | { | |
638 | /// Return the value of a given pcb for a given dimension | |
639 | ||
640 | AliMUONVCalibParam* param = PCBParam(detElemId,pcbIndex); | |
641 | ||
642 | return param ? Value(*param,pcbIndex,dim) : 0.0; | |
643 | } | |
644 | ||
645 | //_____________________________________________________________________________ | |
646 | AliMUONVCalibParam* | |
647 | AliMUONTrackerData::PCBParam(Int_t detElemId, Int_t pcbIndex) const | |
648 | { | |
649 | /// Return (if it exist) the VCalibParam for a given pcb | |
650 | return fPCBValues ? static_cast<AliMUONVCalibParam*> | |
651 | (fPCBValues->FindObject(detElemId,pcbIndex)) : 0x0 ; | |
652 | } | |
653 | ||
654 | //_____________________________________________________________________________ | |
655 | void | |
656 | AliMUONTrackerData::Print(Option_t* wildcard, Option_t* opt) const | |
657 | { | |
658 | /// Printout | |
659 | ||
660 | TNamed::Print(opt); | |
661 | ||
662 | if ( fIsRunnable ) | |
663 | { | |
664 | cout << " Nevents=" << fNevents << endl; | |
665 | } | |
666 | ||
667 | for ( Int_t i = 0; i <= fDimensionNames->GetLast(); ++i ) | |
668 | { | |
669 | TObjString* name = static_cast<TObjString*>(fDimensionNames->At(i)); | |
670 | cout << Form("Dimension %2d Name %s",i, | |
671 | ( name ? name->String().Data() : "null")) << endl; | |
672 | } | |
673 | ||
674 | cout << Form("External Dimensions = %d",fExternalDimension) << endl; | |
675 | ||
676 | TString sopt(opt); | |
677 | sopt.ToUpper(); | |
678 | ||
679 | if ( sopt.Contains("CHANNEL") && fChannelValues ) | |
680 | { | |
681 | fChannelValues->Print(wildcard,opt); | |
682 | } | |
683 | ||
684 | if ( sopt.Contains("MANU") && fManuValues ) | |
685 | { | |
686 | fManuValues->Print(wildcard,opt); | |
687 | } | |
688 | ||
689 | if ( sopt.Contains("BUSPATCH") && fBusPatchValues ) | |
690 | { | |
691 | fBusPatchValues->Print(wildcard,opt); | |
692 | } | |
693 | ||
694 | if ( sopt.Contains("DE") && fDEValues ) | |
695 | { | |
696 | fDEValues->Print(wildcard,opt); | |
697 | } | |
698 | ||
699 | if ( sopt.Contains("CHAMBER") && fChamberValues ) | |
700 | { | |
701 | fChamberValues->Print(wildcard,opt); | |
702 | } | |
703 | ||
704 | } | |
705 | ||
706 | //_____________________________________________________________________________ | |
707 | void | |
708 | AliMUONTrackerData::SetDimensionName(Int_t index, const char* name) | |
709 | { | |
710 | /// Set the name of a given dimension | |
711 | ||
712 | if ( index >= fExternalDimension ) | |
713 | { | |
714 | AliError(Form("Index out of bounds : %d / %d",index,fExternalDimension)); | |
715 | return; | |
716 | } | |
717 | ||
718 | Int_t ix = External2Internal(index); | |
719 | ||
720 | const char* prefix[] = { "mean", "sigma" }; | |
721 | ||
722 | for ( Int_t i = 0; i < 2; ++i ) | |
723 | { | |
724 | Int_t j = ix+i; | |
725 | ||
726 | SetInternalDimensionName(j,Form("%s of %s",prefix[i],name)); | |
727 | } | |
728 | } | |
729 | ||
730 | //_____________________________________________________________________________ | |
731 | void | |
732 | AliMUONTrackerData::SetInternalDimensionName(Int_t index, const char* value) | |
733 | { | |
734 | /// Set the name of a given internal dimension | |
735 | if ( index >= fDimension ) | |
736 | { | |
737 | AliError(Form("Index out of bounds : %d / %d",index,fDimension)); | |
738 | return; | |
739 | } | |
740 | ||
741 | TObjString* ovalue = static_cast<TObjString*>(fDimensionNames->At(index)); | |
742 | ||
743 | if ( ovalue ) | |
744 | { | |
745 | fDimensionNames->Remove(ovalue); | |
746 | delete ovalue; | |
747 | } | |
748 | fDimensionNames->AddAt(new TObjString(value),index); | |
749 | } | |
750 | ||
751 | //_____________________________________________________________________________ | |
752 | Double_t | |
753 | AliMUONTrackerData::Value(const AliMUONVCalibParam& param, Int_t i, Int_t dim) const | |
754 | { | |
755 | /// Compute the value for a given dim, using the internal information we have | |
756 | /// Basically we're converting sum of weights and sum of squares of weights | |
757 | /// into means and sigmas, and number of events into occupancy number. | |
758 | ||
759 | Double_t n = param.ValueAsDouble(i,IndexOfNumberDimension()); | |
760 | ||
761 | if ( dim == IndexOfNumberDimension() ) return n; // the number of channels in any given element does not depend on the number of events | |
762 | ||
763 | Double_t occ = param.ValueAsDouble(i,IndexOfOccupancyDimension()); | |
764 | ||
765 | if ( dim >= fDimension ) | |
766 | { | |
767 | return occ; | |
768 | } | |
769 | ||
770 | if ( dim == IndexOfOccupancyDimension() ) return occ/n/NumberOfEvents(); | |
771 | ||
772 | Double_t value = param.ValueAsDouble(i,dim); | |
773 | ||
774 | if ( value >= AliMUONVCalibParam::InvalidFloatValue() ) return AliMUONVCalibParam::InvalidFloatValue(); | |
775 | ||
776 | if ( TMath::Even(dim) ) | |
777 | { | |
778 | return value/occ; | |
779 | } | |
780 | else | |
781 | { | |
782 | Double_t sumw = param.ValueAsDouble(i,dim-1); | |
783 | Double_t mean = sumw/n; | |
784 | ||
785 | return TMath::Sqrt(TMath::Abs(value/occ - mean*mean)); | |
786 | } | |
787 | ||
788 | AliError("Why am I here ?"); | |
789 | return 0.0; | |
790 | } | |
791 |