Coverity fix
[u/mrichter/AliRoot.git] / MUON / AliMUONRejectList.cxx
CommitLineData
fe783497 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///
19/// \class AliMUONRejectList
20///
21/// Object to hold the probability to reject elements during reconstruction.
22///
23/// Those elements are either channels, manus,
24/// bus patches, detection elements, or all the four.
25/// (we do not consider the next level, chamber, because if a full
26/// chamber is missing, we assume we'll remove that run from the
27/// list of usable runs anyway).
28///
29/// The probability of rejection can be different from 0.0 or 1.0 only for
30/// simulations, in which case it means that :
31/// - this object was created from inspection of real data occupancy maps + ad-hoc rejections over
32/// several runs
33/// - the probability then reflects the chance a given element was useable
34/// during data taking. For instance, if one DE has a probability of 0.8, it means
35/// it was on (or correctly behaving during data taking) only for 20% of the
36/// events.
37///
38/// \author Laurent Aphecetche, Subatech
39///
40
41#include "AliMUONRejectList.h"
42
43#include "AliMpConstants.h"
44#include "AliMUON2DMap.h"
45#include "AliMUONCalibParamNF.h"
46#include "Riostream.h"
47#include "TMath.h"
48
49/// \cond CLASSIMP
50ClassImp(AliMUONRejectList)
51/// \endcond
52
53namespace
54{
55 /// The functions below are here to help re-invent the wheel,
56 /// i.e. code something which acts as std::map<int,float>
57 /// to circumvent the fact that AliRoot does not allow STL to be used.
58
59 void Dump(const char* str, UInt_t n, UInt_t* ids, Float_t* values, Bool_t debug)
60 {
61 /// Dump the values array
62
63 TString s(str);
64 s += " PROBA %e";
65
66 for ( UInt_t i = 0; i < n; ++i )
67 {
68 UInt_t key = ids[i];
69 Int_t a,b;
70 AliMUONVCalibParam::DecodeUniqueID(key,a,b);
71 if ( s.CountChar('%')==3 )
72 {
73 cout << Form(s.Data(),a,b,values[i]) << endl;
74 }
75 else
76 {
77 cout << Form(s.Data(),a,values[i]) << endl;
78 }
79 }
80
81 if ( debug )
82 {
83 cout << "------" << endl;
84 for ( UInt_t i = 0; i < n; ++i )
85 {
86 UInt_t key = ids[i];
87 Int_t a,b;
88 AliMUONVCalibParam::DecodeUniqueID(key,a,b);
89 cout << Form("ids[%5d]=%d values[%5d]=%e (a,b)=(%5d,%5d)",
90 i,ids[i],i,values[i],a,b) << endl;
91 }
92
93 }
94 }
95
96 Float_t GetValue(UInt_t n, UInt_t* ids, Float_t* values, UInt_t key)
97 {
98 /// Get the value corresponding to key, or zero if not found
99 Long64_t index = TMath::BinarySearch(n,ids,key);
100
101 Bool_t found = ( ( index >= 0 ) && ( ids[index] == key ) );
102
103 if ( found )
104 {
105 return values[index];
106 }
107 else
108 {
109 return 0.0;
110 }
111 }
112
113 void Insert(UInt_t n, UInt_t* ids, Float_t* values, UInt_t index, UInt_t key, Float_t value)
114 {
115 /// Insert (key,value) into arrays ids and values.
116
117 for ( UInt_t i = n; i > index; --i )
118 {
119 ids[i] = ids[i-1];
120 values[i] = values[i-1];
121 }
122 ids[index] = key;
123 values[index] = value;
124 }
125
126 Bool_t SetValue(UInt_t n, UInt_t* ids, Float_t* values, UInt_t key, Float_t value)
127 {
128 /// Set the value for a given key
129 Long64_t index = TMath::BinarySearch(n,ids, key);
130
131 Bool_t alreadyThere = ( ( index >= 0 ) && ( ids[index] == key ) );
132
133 if ( alreadyThere )
134 {
135 // replacement
136 values[index] = value;
137 return kFALSE;
138 }
139 Insert(n,ids,values,index+1,key,value);
140 return kTRUE;
141 }
142
143 void Copy(UInt_t n, UInt_t* src, UInt_t*& dest)
144 {
145 /// Copy src into dest
146 delete[] dest;
147 dest = new UInt_t[n];
148 memcpy(src,dest,n*sizeof(UInt_t));
149 }
150
151 void Copy(UInt_t n, Float_t* src, Float_t*& dest)
152 {
153 /// Copy src into dest
154 delete[] dest;
155 dest = new Float_t[n];
156 memcpy(src,dest,n*sizeof(Float_t));
157 }
158
159}
160
161//_____________________________________________________________________________
162AliMUONRejectList::AliMUONRejectList()
163: TObject(),
164fIsBinary(kTRUE),
165fMaxNofDEs(156), // not nice to put a constant here, but that way this object does not need the mapping at creation time...
166fMaxNofBPs(888), // same remark as above
167fMaxNofManus(16828), // same as above...
168fNofDEs(),
169fNofBPs(),
170fNofManus(),
171fDEIds(new UInt_t[fMaxNofDEs]),
172fDEProbas(new Float_t[fMaxNofDEs]),
173fBPIds(new UInt_t[fMaxNofBPs]),
174fBPProbas(new Float_t[fMaxNofBPs]),
175fManuIds(new UInt_t[fMaxNofManus]),
176fManuProbas(new Float_t[fMaxNofManus]),
177fChannels(new AliMUON2DMap(kTRUE))
178{
179 /// normal ctor
180 memset(fDEIds,0,fMaxNofDEs*sizeof(UInt_t));
74343395 181 memset(fDEProbas,0,fMaxNofDEs*sizeof(Float_t));
fe783497 182 memset(fBPIds,0,fMaxNofBPs*sizeof(UInt_t));
74343395 183 memset(fBPProbas,0,fMaxNofBPs*sizeof(Float_t));
fe783497 184 memset(fManuIds,0,fMaxNofManus*sizeof(UInt_t));
74343395 185 memset(fManuProbas,0,fMaxNofManus*sizeof(Float_t));
fe783497 186}
187
188//_____________________________________________________________________________
189AliMUONRejectList::AliMUONRejectList(TRootIOCtor* /*ioCtor*/)
190: TObject(),
191fIsBinary(kTRUE),
192fMaxNofDEs(),
193fMaxNofBPs(),
194fMaxNofManus(),
195fNofDEs(),
196fNofBPs(),
197fNofManus(0),
198fDEIds(0x0),
199fDEProbas(0x0),
200fBPIds(0x0),
201fBPProbas(0x0),
202fManuIds(0x0),
203fManuProbas(0x0),
204fChannels(0x0)
205{
206 /// ctor from root i/o
207}
208
209//_____________________________________________________________________________
210AliMUONRejectList::AliMUONRejectList(const AliMUONRejectList& rl)
211: TObject(rl),
212fIsBinary(kTRUE),
213fMaxNofDEs(),
214fMaxNofBPs(),
215fMaxNofManus(),
216fNofDEs(),
217fNofBPs(),
218fNofManus(0),
219fDEIds(0x0),
220fDEProbas(0x0),
221fBPIds(0x0),
222fBPProbas(0x0),
223fManuIds(0x0),
224fManuProbas(0x0),
225fChannels(0x0)
226{
227 /// Copy ctor
228 rl.CopyTo(*this);
229}
230
231//_____________________________________________________________________________
232AliMUONRejectList& AliMUONRejectList::operator=(const AliMUONRejectList& rl)
233{
234 /// assignement operator
6350d0c0 235 if ( this != &rl )
236 {
237 rl.CopyTo(*this);
238 }
fe783497 239 return *this;
240}
241
242//_____________________________________________________________________________
243void
244AliMUONRejectList::CopyTo(AliMUONRejectList& rl) const
245{
246 /// Copy this to rl
247 TObject::Copy(rl);
248
249 rl.fIsBinary = fIsBinary;
250
251 ::Copy(rl.fMaxNofDEs,fDEIds,rl.fDEIds);
252 ::Copy(rl.fMaxNofDEs,fDEProbas,rl.fDEProbas);
253 ::Copy(rl.fMaxNofBPs,fBPIds,rl.fBPIds);
254 ::Copy(rl.fMaxNofBPs,fBPProbas,rl.fBPProbas);
255 ::Copy(rl.fMaxNofManus,fManuIds,rl.fManuIds);
256 ::Copy(rl.fMaxNofManus,fManuProbas,rl.fManuProbas);
257
258 delete rl.fChannels;
259 rl.fChannels = static_cast<AliMUONVStore*>(fChannels->Clone());
260}
261
262//_____________________________________________________________________________
263AliMUONRejectList::~AliMUONRejectList()
264{
265 /// dtor
266 delete fChannels;
267 delete[] fDEIds;
268 delete[] fDEProbas;
269 delete[] fBPIds;
270 delete[] fBPProbas;
271 delete[] fManuIds;
272 delete[] fManuProbas;
273}
274
275//_____________________________________________________________________________
276Float_t AliMUONRejectList::DetectionElementProbability(Int_t detElemId) const
277{
278 /// Get the probability to reject a given detection element
279 return ::GetValue(fNofDEs,fDEIds,fDEProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,0));
280}
281
282//_____________________________________________________________________________
283Float_t AliMUONRejectList::BusPatchProbability(Int_t busPatchId) const
284{
285 /// Get the probability to reject a given bus patch
286 return ::GetValue(fNofBPs,fBPIds,fBPProbas,AliMUONVCalibParam::BuildUniqueID(busPatchId,0));
287}
288
289//_____________________________________________________________________________
290Float_t AliMUONRejectList::ManuProbability(Int_t detElemId, Int_t manuId) const
291{
292 /// Get the probability to reject a given manu
293 return ::GetValue(fNofManus,fManuIds,fManuProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,manuId));
294}
295
296//_____________________________________________________________________________
297Float_t AliMUONRejectList::ChannelProbability(Int_t detElemId, Int_t manuId, Int_t manuChannel) const
298{
299 /// Get the probability to reject a given channel
300 AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(fChannels->FindObject(detElemId,manuId));
301 if (!param) return 0.0;
302 return param->ValueAsFloat(manuChannel);
303}
304
305//_____________________________________________________________________________
306void AliMUONRejectList::SetDetectionElementProbability(Int_t detElemId, Float_t proba)
307{
308 /// Set the probability to reject a given detection element
309 if ( ::SetValue(fNofDEs,fDEIds,fDEProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,0),proba) )
310 {
311 ++fNofDEs;
312 }
313
314 ZeroOrOne(proba);
315}
316
317//_____________________________________________________________________________
318void AliMUONRejectList::ZeroOrOne(Float_t proba)
319{
320 /// If proba is anything else than 0 or 1, we set fIsBinary to kFALSe
321
322 Bool_t zeroorone = ( proba == 0.0 || proba == 1.0 );
323 if (!zeroorone) fIsBinary = kFALSE;
324}
325
326//_____________________________________________________________________________
327void AliMUONRejectList::SetBusPatchProbability(Int_t busPatchId, Float_t proba)
328{
329 /// Set the probability to reject a given bus patch
330 if ( ::SetValue(fNofBPs,fBPIds,fBPProbas,AliMUONVCalibParam::BuildUniqueID(busPatchId,0),proba) )
331 {
332 ++fNofBPs;
333 }
334 ZeroOrOne(proba);
335}
336
337//_____________________________________________________________________________
338void AliMUONRejectList::SetManuProbability(Int_t detElemId, Int_t manuId, Float_t proba)
339{
340 /// Set the probability to reject a given manu
341 if ( ::SetValue(fNofManus,fManuIds,fManuProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,manuId),proba) )
342 {
343 ++fNofManus;
344 }
345 ZeroOrOne(proba);
346}
347
348//_____________________________________________________________________________
349void AliMUONRejectList::SetChannelProbability(Int_t detElemId, Int_t manuId, Int_t manuChannel, Float_t proba)
350{
351 /// Set the probability to reject a given channel
352 AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(fChannels->FindObject(detElemId,manuId));
353 if (!param)
354 {
355 param = new AliMUONCalibParamNF(1,AliMpConstants::ManuNofChannels(),detElemId,manuId,0.0);
356 fChannels->Add(param);
357 }
358 param->SetValueAsFloat(manuChannel,0,proba);
359 ZeroOrOne(proba);
360}
361
362//_____________________________________________________________________________
363void
364AliMUONRejectList::Print(Option_t* opt) const
365{
366 /// Printout
367
368 TString sopt(opt);
369 sopt.ToUpper();
370 Bool_t debug(kFALSE);
371
372 if ( sopt.Contains("DEBUG") ) debug=kTRUE;
373
374 cout << Form("We have probabilities for %d detection element(s), %d bus patch(es), %d manu(s)",
375 fNofDEs,fNofBPs,fNofManus) << endl;
376
377 ::Dump("DE %04d",fNofDEs,fDEIds,fDEProbas,debug);
378 ::Dump("BusPatch %04d",fNofBPs,fBPIds,fBPProbas,debug);
379 ::Dump("DE %04d MANU %4d",fNofManus,fManuIds,fManuProbas,debug);
380}