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 }