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 using std::cout;
  50 using std::endl;
  51 /// \cond CLASSIMP
  52 ClassImp(AliMUONRejectList)
  53 /// \endcond
  54
  55 namespace
  56 {
  57   /// The functions below are here to help re-invent the wheel,
  58   /// i.e. code something which acts as std::map<int,float>
  59   /// to circumvent the fact that AliRoot does not allow STL to be used.
  60
  61   void Dump(const char* str, UInt_t n, UInt_t* ids, Float_t* values, Bool_t debug)
  62   {
  63     /// Dump the values array
  64
  65     TString s(str);
  66     s += " PROBA %e";
  67
  68     for ( UInt_t i = 0; i < n; ++i )
  69     {
  70       UInt_t key = ids[i];
  71       Int_t a,b;
  72       AliMUONVCalibParam::DecodeUniqueID(key,a,b);
  73       if ( s.CountChar('%')==3 )
  74       {
  75         cout << Form(s.Data(),a,b,values[i]) << endl;
  76       }
  77       else
  78       {
  79         cout << Form(s.Data(),a,values[i]) << endl;
  80       }
  81     }
  82
  83     if ( debug )
  84     {
  85       cout << "------" << endl;
  86       for ( UInt_t i = 0; i < n; ++i )
  87       {
  88         UInt_t key = ids[i];
  89         Int_t a,b;
  90         AliMUONVCalibParam::DecodeUniqueID(key,a,b);
  91         cout << Form("ids[%5d]=%d values[%5d]=%e (a,b)=(%5d,%5d)",
  92         i,ids[i],i,values[i],a,b) << endl;
  93       }
  94
  95     }
  96   }
  97
  98   Float_t GetValue(UInt_t n, UInt_t* ids, Float_t* values, UInt_t key)
  99   {
 100     /// Get the value corresponding to key, or zero if not found
 101     Long64_t index = TMath::BinarySearch(n,ids,key);
 102
 103     Bool_t found = ( ( index >= 0 ) && ( ids[index] == key ) );
 104
 105     if ( found )
 106     {
 107       return values[index];
 108     }
 109     else
 110     {
 111       return 0.0;
 112     }
 113   }
 114
 115   void Insert(UInt_t n, UInt_t* ids, Float_t* values, UInt_t index, UInt_t key, Float_t value)
 116   {
 117     /// Insert (key,value) into arrays ids and values.
 118
 119     for ( UInt_t i = n; i > index; --i )
 120     {
 121       ids[i] = ids[i-1];
 122       values[i] = values[i-1];
 123     }
 124     ids[index] = key;
 125     values[index] = value;
 126   }
 127
 128   Bool_t SetValue(UInt_t n, UInt_t* ids, Float_t* values, UInt_t key, Float_t value)
 129   {
 130     /// Set the value for a given key
 131     Long64_t index = TMath::BinarySearch(n,ids, key);
 132
 133     Bool_t alreadyThere = ( ( index >= 0 ) && ( ids[index] == key ) );
 134
 135     if ( alreadyThere )
 136     {
 137       // replacement
 138       values[index] = value;
 139       return kFALSE;
 140     }
 141     Insert(n,ids,values,index+1,key,value);
 142     return kTRUE;
 143   }
 144
 145   void Copy(UInt_t n, UInt_t* src, UInt_t*& dest)
 146   {
 147     /// Copy src into dest
 148     delete[] dest;
 149     dest = 0;
 150     if ( src && n )
 151     {
 152       dest = new UInt_t[n];
 153       memcpy(dest,src,n*sizeof(UInt_t));
 154     }
 155   }
 156
 157   void Copy(UInt_t n, Float_t* src, Float_t*& dest)
 158   {
 159     /// Copy src into dest
 160     delete[] dest;
 161     dest = 0;
 162     if ( src && n )
 163     {
 164       dest = new Float_t[n];
 165       memcpy(dest,src,n*sizeof(Float_t));
 166     }
 167   }
 168
 169 }
 170
 171 //_____________________________________________________________________________
 172 AliMUONRejectList::AliMUONRejectList()
 173 : TObject(),
 174 fIsBinary(kTRUE),
 175 fMaxNofDEs(156), // not nice to put a constant here, but that way this object does not need the mapping at creation time...
 176 fMaxNofBPs(888), // same remark as above
 177 fMaxNofManus(16828), // same as above...
 178 fNofDEs(),
 179 fNofBPs(),
 180 fNofManus(),
 181 fDEIds(new UInt_t[fMaxNofDEs]),
 182 fDEProbas(new Float_t[fMaxNofDEs]),
 183 fBPIds(new UInt_t[fMaxNofBPs]),
 184 fBPProbas(new Float_t[fMaxNofBPs]),
 185 fManuIds(new UInt_t[fMaxNofManus]),
 186 fManuProbas(new Float_t[fMaxNofManus]),
 187 fChannels(new AliMUON2DMap(kTRUE))
 188 {
 189   /// normal ctor
 190   memset(fDEIds,0,fMaxNofDEs*sizeof(UInt_t));
 191   memset(fDEProbas,0,fMaxNofDEs*sizeof(Float_t));
 192   memset(fBPIds,0,fMaxNofBPs*sizeof(UInt_t));
 193   memset(fBPProbas,0,fMaxNofBPs*sizeof(Float_t));
 194   memset(fManuIds,0,fMaxNofManus*sizeof(UInt_t));
 195   memset(fManuProbas,0,fMaxNofManus*sizeof(Float_t));
 196 }
 197
 198 //_____________________________________________________________________________
 199 AliMUONRejectList::AliMUONRejectList(TRootIOCtor* /*ioCtor*/)
 200 : TObject(),
 201 fIsBinary(kTRUE),
 202 fMaxNofDEs(),
 203 fMaxNofBPs(),
 204 fMaxNofManus(),
 205 fNofDEs(),
 206 fNofBPs(),
 207 fNofManus(0),
 208 fDEIds(0x0),
 209 fDEProbas(0x0),
 210 fBPIds(0x0),
 211 fBPProbas(0x0),
 212 fManuIds(0x0),
 213 fManuProbas(0x0),
 214 fChannels(0x0)
 215 {
 216   /// ctor from root i/o
 217 }
 218
 219 //_____________________________________________________________________________
 220 AliMUONRejectList::AliMUONRejectList(const AliMUONRejectList& rl)
 221 : TObject(rl),
 222 fIsBinary(rl.fIsBinary),
 223 fMaxNofDEs(rl.fMaxNofDEs),
 224 fMaxNofBPs(rl.fMaxNofBPs),
 225 fMaxNofManus(rl.fMaxNofManus),
 226 fNofDEs(rl.fNofDEs),
 227 fNofBPs(rl.fNofBPs),
 228 fNofManus(rl.fNofManus),
 229 fDEIds(0x0),
 230 fDEProbas(0x0),
 231 fBPIds(0x0),
 232 fBPProbas(0x0),
 233 fManuIds(0x0),
 234 fManuProbas(0x0),
 235 fChannels(0x0)
 236 {
 237   /// Copy ctor
 238
 239   ::Copy(rl.fMaxNofDEs,rl.fDEIds,fDEIds);
 240   ::Copy(rl.fMaxNofDEs,rl.fDEProbas,fDEProbas);
 241   ::Copy(rl.fMaxNofBPs,rl.fBPIds,fBPIds);
 242   ::Copy(rl.fMaxNofBPs,rl.fBPProbas,fBPProbas);
 243   ::Copy(rl.fMaxNofManus,rl.fManuIds,fManuIds);
 244   ::Copy(rl.fMaxNofManus,rl.fManuProbas,fManuProbas);
 245
 246   if ( rl.fChannels )
 247   {
 248     fChannels = static_cast<AliMUONVStore*>(rl.fChannels->Clone());
 249   }
 250 }
 251
 252 //_____________________________________________________________________________
 253 AliMUONRejectList& AliMUONRejectList::operator=(const AliMUONRejectList& rl)
 254 {
 255   /// assignement operator
 256   if ( this != &rl )
 257   {
 258     static_cast<TObject&>(*this)=rl;
 259
 260     fIsBinary = rl.fIsBinary;
 261     fMaxNofDEs = rl.fMaxNofDEs;
 262     fMaxNofBPs = rl.fMaxNofBPs;
 263     fMaxNofManus = rl.fMaxNofManus;
 264     fNofDEs = rl.fNofDEs;
 265     fNofBPs = rl.fNofBPs;
 266     fNofManus = rl.fNofManus;
 267
 268     ::Copy(rl.fMaxNofDEs,rl.fDEIds,fDEIds);
 269     ::Copy(rl.fMaxNofDEs,rl.fDEProbas,fDEProbas);
 270     ::Copy(rl.fMaxNofBPs,rl.fBPIds,fBPIds);
 271     ::Copy(rl.fMaxNofBPs,rl.fBPProbas,fBPProbas);
 272     ::Copy(rl.fMaxNofManus,rl.fManuIds,fManuIds);
 273     ::Copy(rl.fMaxNofManus,rl.fManuProbas,fManuProbas);
 274
 275     delete fChannels;
 276     fChannels = 0x0;
 277
 278     if ( rl.fChannels )
 279     {
 280       fChannels = static_cast<AliMUONVStore*>(rl.fChannels->Clone());
 281     }
 282
 283   }
 284   return *this;
 285 }
 286
 287 //_____________________________________________________________________________
 288 AliMUONRejectList::~AliMUONRejectList()
 289 {
 290   /// dtor
 291   delete fChannels;
 292   delete[] fDEIds;
 293   delete[] fDEProbas;
 294   delete[] fBPIds;
 295   delete[] fBPProbas;
 296   delete[] fManuIds;
 297   delete[] fManuProbas;
 298 }
 299
 300 //_____________________________________________________________________________
 301 Float_t AliMUONRejectList::DetectionElementProbability(Int_t detElemId) const
 302 {
 303   /// Get the probability to reject a given detection element
 304   return ::GetValue(fNofDEs,fDEIds,fDEProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,0));
 305 }
 306
 307 //_____________________________________________________________________________
 308 Float_t AliMUONRejectList::BusPatchProbability(Int_t busPatchId) const
 309 {
 310   /// Get the probability to reject a given bus patch
 311   return ::GetValue(fNofBPs,fBPIds,fBPProbas,AliMUONVCalibParam::BuildUniqueID(busPatchId,0));
 312 }
 313
 314 //_____________________________________________________________________________
 315 Float_t AliMUONRejectList::ManuProbability(Int_t detElemId, Int_t manuId) const
 316 {
 317   /// Get the probability to reject a given manu
 318   return ::GetValue(fNofManus,fManuIds,fManuProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,manuId));
 319 }
 320
 321 //_____________________________________________________________________________
 322 Float_t AliMUONRejectList::ChannelProbability(Int_t detElemId, Int_t manuId, Int_t manuChannel) const
 323 {
 324   /// Get the probability to reject a given channel
 325   AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(fChannels->FindObject(detElemId,manuId));
 326   if (!param) return 0.0;
 327   return param->ValueAsFloat(manuChannel);
 328 }
 329
 330 //_____________________________________________________________________________
 331 void AliMUONRejectList::SetDetectionElementProbability(Int_t detElemId, Float_t proba)
 332 {
 333   /// Set the probability to reject a given detection element
 334   if ( ::SetValue(fNofDEs,fDEIds,fDEProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,0),proba) )
 335   {
 336     ++fNofDEs;
 337   }
 338
 339   ZeroOrOne(proba);
 340 }
 341
 342 //_____________________________________________________________________________
 343 void AliMUONRejectList::ZeroOrOne(Float_t proba)
 344 {
 345   /// If proba is anything else than 0 or 1, we set fIsBinary to kFALSe
 346
 347   Bool_t zeroorone = ( proba == 0.0 || proba == 1.0 );
 348   if (!zeroorone) fIsBinary = kFALSE;
 349 }
 350
 351 //_____________________________________________________________________________
 352 void AliMUONRejectList::SetBusPatchProbability(Int_t busPatchId, Float_t proba)
 353 {
 354   /// Set the probability to reject a given bus patch
 355   if ( ::SetValue(fNofBPs,fBPIds,fBPProbas,AliMUONVCalibParam::BuildUniqueID(busPatchId,0),proba) )
 356   {
 357     ++fNofBPs;
 358   }
 359   ZeroOrOne(proba);
 360 }
 361
 362 //_____________________________________________________________________________
 363 void AliMUONRejectList::SetManuProbability(Int_t detElemId, Int_t manuId, Float_t proba)
 364 {
 365   /// Set the probability to reject a given manu
 366   if ( ::SetValue(fNofManus,fManuIds,fManuProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,manuId),proba) )
 367   {
 368     ++fNofManus;
 369   }
 370   ZeroOrOne(proba);
 371 }
 372
 373 //_____________________________________________________________________________
 374 void AliMUONRejectList::SetChannelProbability(Int_t detElemId, Int_t manuId, Int_t manuChannel, Float_t proba)
 375 {
 376   /// Set the probability to reject a given channel
 377   AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(fChannels->FindObject(detElemId,manuId));
 378   if (!param)
 379   {
 380     param = new AliMUONCalibParamNF(1,AliMpConstants::ManuNofChannels(),detElemId,manuId,0.0);
 381     fChannels->Add(param);
 382   }
 383   param->SetValueAsFloat(manuChannel,0,proba);
 384   ZeroOrOne(proba);
 385 }
 386
 387 //_____________________________________________________________________________
 388 void
 389 AliMUONRejectList::Print(Option_t* opt) const
 390 {
 391   /// Printout
 392
 393   TString sopt(opt);
 394   sopt.ToUpper();
 395   Bool_t debug(kFALSE);
 396
 397   if ( sopt.Contains("DEBUG") ) debug=kTRUE;
 398
 399   cout << Form("We have probabilities for %d detection element(s), %d bus patch(es), %d manu(s)",
 400                fNofDEs,fNofBPs,fNofManus) << endl;
 401
 402   ::Dump("DE %04d",fNofDEs,fDEIds,fDEProbas,debug);
 403   ::Dump("BusPatch %04d",fNofBPs,fBPIds,fBPProbas,debug);
 404   ::Dump("DE %04d MANU %4d",fNofManus,fManuIds,fManuProbas,debug);
 405 }