Hopefully now Coverity will be happy
[u/mrichter/AliRoot.git] / MUON / AliMUONRejectList.cxx
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
50 ClassImp(AliMUONRejectList)
51 /// \endcond
52
53 namespace
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 = 0;
148     if ( src && n )
149     {
150       dest = new UInt_t[n];
151       memcpy(dest,src,n*sizeof(UInt_t));
152     }
153   }
154
155   void Copy(UInt_t n, Float_t* src, Float_t*& dest)
156   {
157     /// Copy src into dest
158     delete[] dest;
159     dest = 0;
160     if ( src && n )
161     {
162       dest = new Float_t[n];
163       memcpy(dest,src,n*sizeof(Float_t));
164     }
165   }
166   
167 }
168     
169 //_____________________________________________________________________________
170 AliMUONRejectList::AliMUONRejectList()
171 : TObject(),
172 fIsBinary(kTRUE),
173 fMaxNofDEs(156), // not nice to put a constant here, but that way this object does not need the mapping at creation time...
174 fMaxNofBPs(888), // same remark as above
175 fMaxNofManus(16828), // same as above...
176 fNofDEs(),
177 fNofBPs(),
178 fNofManus(),
179 fDEIds(new UInt_t[fMaxNofDEs]),
180 fDEProbas(new Float_t[fMaxNofDEs]),
181 fBPIds(new UInt_t[fMaxNofBPs]),
182 fBPProbas(new Float_t[fMaxNofBPs]),
183 fManuIds(new UInt_t[fMaxNofManus]),
184 fManuProbas(new Float_t[fMaxNofManus]),
185 fChannels(new AliMUON2DMap(kTRUE))
186 {
187   /// normal ctor
188   memset(fDEIds,0,fMaxNofDEs*sizeof(UInt_t));
189   memset(fDEProbas,0,fMaxNofDEs*sizeof(Float_t));
190   memset(fBPIds,0,fMaxNofBPs*sizeof(UInt_t));
191   memset(fBPProbas,0,fMaxNofBPs*sizeof(Float_t));
192   memset(fManuIds,0,fMaxNofManus*sizeof(UInt_t));
193   memset(fManuProbas,0,fMaxNofManus*sizeof(Float_t));
194 }
195
196 //_____________________________________________________________________________
197 AliMUONRejectList::AliMUONRejectList(TRootIOCtor* /*ioCtor*/)
198 : TObject(),
199 fIsBinary(kTRUE),
200 fMaxNofDEs(),
201 fMaxNofBPs(),
202 fMaxNofManus(),
203 fNofDEs(), 
204 fNofBPs(), 
205 fNofManus(0), 
206 fDEIds(0x0),
207 fDEProbas(0x0),
208 fBPIds(0x0),
209 fBPProbas(0x0),
210 fManuIds(0x0),
211 fManuProbas(0x0),
212 fChannels(0x0)
213 {
214   /// ctor from root i/o
215 }
216
217 //_____________________________________________________________________________
218 AliMUONRejectList::AliMUONRejectList(const AliMUONRejectList& rl)
219 : TObject(rl),
220 fIsBinary(rl.fIsBinary),
221 fMaxNofDEs(rl.fMaxNofDEs),
222 fMaxNofBPs(rl.fMaxNofBPs),
223 fMaxNofManus(rl.fMaxNofManus),
224 fNofDEs(rl.fNofDEs), 
225 fNofBPs(rl.fNofBPs), 
226 fNofManus(rl.fNofManus), 
227 fDEIds(0x0),
228 fDEProbas(0x0),
229 fBPIds(0x0),
230 fBPProbas(0x0),
231 fManuIds(0x0),
232 fManuProbas(0x0),
233 fChannels(0x0)
234 {
235   /// Copy ctor
236   
237   ::Copy(rl.fMaxNofDEs,rl.fDEIds,fDEIds);
238   ::Copy(rl.fMaxNofDEs,rl.fDEProbas,fDEProbas);
239   ::Copy(rl.fMaxNofBPs,rl.fBPIds,fBPIds);
240   ::Copy(rl.fMaxNofBPs,rl.fBPProbas,fBPProbas);
241   ::Copy(rl.fMaxNofManus,rl.fManuIds,fManuIds);
242   ::Copy(rl.fMaxNofManus,rl.fManuProbas,fManuProbas);
243   
244   if ( rl.fChannels ) 
245   {
246     fChannels = static_cast<AliMUONVStore*>(rl.fChannels->Clone());
247   }
248 }
249
250 //_____________________________________________________________________________
251 AliMUONRejectList& AliMUONRejectList::operator=(const AliMUONRejectList& rl)
252 {
253   /// assignement operator
254   if ( this != &rl ) 
255   {
256     static_cast<TObject&>(*this)=rl;
257     
258     fIsBinary = rl.fIsBinary;
259     fMaxNofDEs = rl.fMaxNofDEs;
260     fMaxNofBPs = rl.fMaxNofBPs;
261     fMaxNofManus = rl.fMaxNofManus;
262     fNofDEs = rl.fNofDEs;
263     fNofBPs = rl.fNofBPs;
264     fNofManus = rl.fNofManus;
265     
266     ::Copy(rl.fMaxNofDEs,rl.fDEIds,fDEIds);
267     ::Copy(rl.fMaxNofDEs,rl.fDEProbas,fDEProbas);
268     ::Copy(rl.fMaxNofBPs,rl.fBPIds,fBPIds);
269     ::Copy(rl.fMaxNofBPs,rl.fBPProbas,fBPProbas);
270     ::Copy(rl.fMaxNofManus,rl.fManuIds,fManuIds);
271     ::Copy(rl.fMaxNofManus,rl.fManuProbas,fManuProbas);
272     
273     delete fChannels;
274     fChannels = 0x0;
275     
276     if ( rl.fChannels ) 
277     {
278       fChannels = static_cast<AliMUONVStore*>(rl.fChannels->Clone());
279     }
280     
281   }  
282   return *this;
283 }
284
285 //_____________________________________________________________________________
286 AliMUONRejectList::~AliMUONRejectList()
287 {
288   /// dtor
289   delete fChannels;
290   delete[] fDEIds;
291   delete[] fDEProbas;
292   delete[] fBPIds;
293   delete[] fBPProbas;
294   delete[] fManuIds;
295   delete[] fManuProbas;
296 }
297
298 //_____________________________________________________________________________
299 Float_t AliMUONRejectList::DetectionElementProbability(Int_t detElemId) const
300 {
301   /// Get the probability to reject a given detection element
302   return ::GetValue(fNofDEs,fDEIds,fDEProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,0));
303 }
304
305 //_____________________________________________________________________________
306 Float_t AliMUONRejectList::BusPatchProbability(Int_t busPatchId) const
307 {
308   /// Get the probability to reject a given bus patch
309   return ::GetValue(fNofBPs,fBPIds,fBPProbas,AliMUONVCalibParam::BuildUniqueID(busPatchId,0));
310 }
311
312 //_____________________________________________________________________________
313 Float_t AliMUONRejectList::ManuProbability(Int_t detElemId, Int_t manuId) const
314 {
315   /// Get the probability to reject a given manu
316   return ::GetValue(fNofManus,fManuIds,fManuProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,manuId));
317 }
318
319 //_____________________________________________________________________________
320 Float_t AliMUONRejectList::ChannelProbability(Int_t detElemId, Int_t manuId, Int_t manuChannel) const
321 {
322   /// Get the probability to reject a given channel
323   AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(fChannels->FindObject(detElemId,manuId));
324   if (!param) return 0.0;
325   return param->ValueAsFloat(manuChannel);
326 }
327
328 //_____________________________________________________________________________
329 void AliMUONRejectList::SetDetectionElementProbability(Int_t detElemId, Float_t proba)
330 {
331   /// Set the probability to reject a given detection element
332   if ( ::SetValue(fNofDEs,fDEIds,fDEProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,0),proba) ) 
333   {
334     ++fNofDEs;
335   }
336   
337   ZeroOrOne(proba);
338 }
339
340 //_____________________________________________________________________________
341 void AliMUONRejectList::ZeroOrOne(Float_t proba)
342 {
343   /// If proba is anything else than 0 or 1, we set fIsBinary to kFALSe
344   
345   Bool_t zeroorone = ( proba == 0.0 || proba == 1.0 );
346   if (!zeroorone) fIsBinary = kFALSE;
347 }
348
349 //_____________________________________________________________________________
350 void AliMUONRejectList::SetBusPatchProbability(Int_t busPatchId, Float_t proba)
351 {
352   /// Set the probability to reject a given bus patch
353   if ( ::SetValue(fNofBPs,fBPIds,fBPProbas,AliMUONVCalibParam::BuildUniqueID(busPatchId,0),proba) )
354   {
355     ++fNofBPs;
356   }
357   ZeroOrOne(proba);
358 }
359
360 //_____________________________________________________________________________
361 void AliMUONRejectList::SetManuProbability(Int_t detElemId, Int_t manuId, Float_t proba)
362 {
363   /// Set the probability to reject a given manu
364   if ( ::SetValue(fNofManus,fManuIds,fManuProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,manuId),proba) )
365   {
366     ++fNofManus;
367   }
368   ZeroOrOne(proba);
369 }
370
371 //_____________________________________________________________________________
372 void AliMUONRejectList::SetChannelProbability(Int_t detElemId, Int_t manuId, Int_t manuChannel, Float_t proba)
373 {
374   /// Set the probability to reject a given channel
375   AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(fChannels->FindObject(detElemId,manuId));
376   if (!param) 
377   {
378     param = new AliMUONCalibParamNF(1,AliMpConstants::ManuNofChannels(),detElemId,manuId,0.0);    
379     fChannels->Add(param);
380   }
381   param->SetValueAsFloat(manuChannel,0,proba);
382   ZeroOrOne(proba);
383 }
384
385 //_____________________________________________________________________________
386 void 
387 AliMUONRejectList::Print(Option_t* opt) const
388 {
389   /// Printout
390
391   TString sopt(opt);  
392   sopt.ToUpper();
393   Bool_t debug(kFALSE);
394   
395   if ( sopt.Contains("DEBUG") ) debug=kTRUE;
396   
397   cout << Form("We have probabilities for %d detection element(s), %d bus patch(es), %d manu(s)",
398                fNofDEs,fNofBPs,fNofManus) << endl;
399   
400   ::Dump("DE %04d",fNofDEs,fDEIds,fDEProbas,debug);
401   ::Dump("BusPatch %04d",fNofBPs,fBPIds,fBPProbas,debug);
402   ::Dump("DE %04d MANU %4d",fNofManus,fManuIds,fManuProbas,debug);
403 }