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, pcbs (for slats) and HV channels,
  25 /// or all of them.
  26 ///
  27 /// (we do not consider the next level, chamber, because if a full
  28 /// chamber is missing, we assume we'll remove that run from the
  29 /// list of usable runs anyway).
  30 ///
  31 /// The probability of rejection can be different from 0.0 or 1.0 only for
  32 /// simulations, in which case it means that :
  33 /// - this object was created from inspection of real data occupancy maps + ad-hoc rejections over
  34 /// several runs
  35 /// - the probability then reflects the chance a given element was useable
  36 /// during data taking. For instance, if one DE has a probability of 0.8, it means
  37 /// it was on (or correctly behaving during data taking) only for 20% of the
  38 /// events.
  39 ///
  40 /// \author Laurent Aphecetche, Subatech
  41 ///
  42
  43 #include "AliMUONRejectList.h"
  44
  45 #include "AliLog.h"
  46 #include "AliMpArea.h"
  47 #include "AliMpConstants.h"
  48 #include "AliMpDCSNamer.h"
  49 #include "AliMpDDLStore.h"
  50 #include "AliMpDEStore.h"
  51 #include "AliMpDetElement.h"
  52 #include "AliMpMotifPosition.h"
  53 #include "AliMpPCB.h"
  54 #include "AliMpSegmentation.h"
  55 #include "AliMpSlat.h"
  56 #include "AliMpVSegmentation.h"
  57 #include "AliMUON2DMap.h"
  58 #include "AliMUONCalibParamNF.h"
  59 #include "Riostream.h"
  60 #include "TMath.h"
  61
  62 using std::cout;
  63 using std::endl;
  64 /// \cond CLASSIMP
  65 ClassImp(AliMUONRejectList)
  66 /// \endcond
  67
  68 namespace
  69 {
  70   /// The functions below are here to help re-invent the wheel,
  71   /// i.e. code something which acts as std::map<int,float>
  72   /// to circumvent the fact that AliRoot does not allow STL to be used.
  73
  74   void Dump(const char* str, UInt_t n, UInt_t* ids, Float_t* values, Bool_t debug)
  75   {
  76     /// Dump the values array
  77
  78     TString s(str);
  79     s += " PROBA %e";
  80
  81     for ( UInt_t i = 0; i < n; ++i )
  82     {
  83       UInt_t key = ids[i];
  84       Int_t a,b;
  85       AliMUONVCalibParam::DecodeUniqueID(key,a,b);
  86       if ( s.CountChar('%')==3 )
  87       {
  88         cout << Form(s.Data(),a,b,values[i]) << endl;
  89       }
  90       else
  91       {
  92         cout << Form(s.Data(),a,values[i]) << endl;
  93       }
  94     }
  95
  96     if ( debug )
  97     {
  98       cout << "------" << endl;
  99       for ( UInt_t i = 0; i < n; ++i )
 100       {
 101         UInt_t key = ids[i];
 102         Int_t a,b;
 103         AliMUONVCalibParam::DecodeUniqueID(key,a,b);
 104         cout << Form("ids[%5d]=%d values[%5d]=%e (a,b)=(%5d,%5d)",
 105         i,ids[i],i,values[i],a,b) << endl;
 106       }
 107
 108     }
 109   }
 110
 111   Float_t GetValue(UInt_t n, UInt_t* ids, Float_t* values, UInt_t key)
 112   {
 113     /// Get the value corresponding to key, or zero if not found
 114     Long64_t index = TMath::BinarySearch(n,ids,key);
 115
 116     Bool_t found = ( ( index >= 0 ) && ( ids[index] == key ) );
 117
 118     if ( found )
 119     {
 120       return values[index];
 121     }
 122     else
 123     {
 124       return 0.0;
 125     }
 126   }
 127
 128   void Insert(UInt_t n, UInt_t* ids, Float_t* values, UInt_t index, UInt_t key, Float_t value)
 129   {
 130     /// Insert (key,value) into arrays ids and values.
 131
 132     for ( UInt_t i = n; i > index; --i )
 133     {
 134       ids[i] = ids[i-1];
 135       values[i] = values[i-1];
 136     }
 137     ids[index] = key;
 138     values[index] = value;
 139   }
 140
 141   Bool_t SetValue(UInt_t n, UInt_t* ids, Float_t* values, UInt_t key, Float_t value)
 142   {
 143     /// Set the value for a given key
 144     Long64_t index = TMath::BinarySearch(n,ids, key);
 145
 146     Bool_t alreadyThere = ( ( index >= 0 ) && ( ids[index] == key ) );
 147
 148     if ( alreadyThere )
 149     {
 150       // replacement
 151       values[index] = value;
 152       return kFALSE;
 153     }
 154     Insert(n,ids,values,index+1,key,value);
 155     return kTRUE;
 156   }
 157
 158   void Copy(UInt_t n, UInt_t* src, UInt_t*& dest)
 159   {
 160     /// Copy src into dest
 161     delete[] dest;
 162     dest = 0;
 163     if ( src && n )
 164     {
 165       dest = new UInt_t[n];
 166       memcpy(dest,src,n*sizeof(UInt_t));
 167     }
 168   }
 169
 170   void Copy(UInt_t n, Float_t* src, Float_t*& dest)
 171   {
 172     /// Copy src into dest
 173     delete[] dest;
 174     dest = 0;
 175     if ( src && n )
 176     {
 177       dest = new Float_t[n];
 178       memcpy(dest,src,n*sizeof(Float_t));
 179     }
 180   }
 181
 182 }
 183
 184 //_____________________________________________________________________________
 185 AliMUONRejectList::AliMUONRejectList()
 186 : TObject(),
 187 fIsBinary(kTRUE),
 188 fMaxNofDEs(156), // not nice to put a constant here, but that way this object does not need the mapping at creation time...
 189 fMaxNofBPs(888), // same remark as above
 190 fMaxNofManus(16828), // same as above...
 191 fNofDEs(),
 192 fNofBPs(),
 193 fNofManus(),
 194 fDEIds(new UInt_t[fMaxNofDEs]),
 195 fDEProbas(new Float_t[fMaxNofDEs]),
 196 fBPIds(new UInt_t[fMaxNofBPs]),
 197 fBPProbas(new Float_t[fMaxNofBPs]),
 198 fManuIds(new UInt_t[fMaxNofManus]),
 199 fManuProbas(new Float_t[fMaxNofManus]),
 200 fChannels(new AliMUON2DMap(kTRUE))
 201 {
 202   /// normal ctor
 203   memset(fDEIds,0,fMaxNofDEs*sizeof(UInt_t));
 204   memset(fDEProbas,0,fMaxNofDEs*sizeof(Float_t));
 205   memset(fBPIds,0,fMaxNofBPs*sizeof(UInt_t));
 206   memset(fBPProbas,0,fMaxNofBPs*sizeof(Float_t));
 207   memset(fManuIds,0,fMaxNofManus*sizeof(UInt_t));
 208   memset(fManuProbas,0,fMaxNofManus*sizeof(Float_t));
 209 }
 210
 211 //_____________________________________________________________________________
 212 AliMUONRejectList::AliMUONRejectList(TRootIOCtor* /*ioCtor*/)
 213 : TObject(),
 214 fIsBinary(kTRUE),
 215 fMaxNofDEs(),
 216 fMaxNofBPs(),
 217 fMaxNofManus(),
 218 fNofDEs(),
 219 fNofBPs(),
 220 fNofManus(0),
 221 fDEIds(0x0),
 222 fDEProbas(0x0),
 223 fBPIds(0x0),
 224 fBPProbas(0x0),
 225 fManuIds(0x0),
 226 fManuProbas(0x0),
 227 fChannels(0x0)
 228 {
 229   /// ctor from root i/o
 230 }
 231
 232 //_____________________________________________________________________________
 233 AliMUONRejectList::AliMUONRejectList(const AliMUONRejectList& rl)
 234 : TObject(rl),
 235 fIsBinary(rl.fIsBinary),
 236 fMaxNofDEs(rl.fMaxNofDEs),
 237 fMaxNofBPs(rl.fMaxNofBPs),
 238 fMaxNofManus(rl.fMaxNofManus),
 239 fNofDEs(rl.fNofDEs),
 240 fNofBPs(rl.fNofBPs),
 241 fNofManus(rl.fNofManus),
 242 fDEIds(0x0),
 243 fDEProbas(0x0),
 244 fBPIds(0x0),
 245 fBPProbas(0x0),
 246 fManuIds(0x0),
 247 fManuProbas(0x0),
 248 fChannels(0x0)
 249 {
 250   /// Copy ctor
 251
 252   ::Copy(rl.fMaxNofDEs,rl.fDEIds,fDEIds);
 253   ::Copy(rl.fMaxNofDEs,rl.fDEProbas,fDEProbas);
 254   ::Copy(rl.fMaxNofBPs,rl.fBPIds,fBPIds);
 255   ::Copy(rl.fMaxNofBPs,rl.fBPProbas,fBPProbas);
 256   ::Copy(rl.fMaxNofManus,rl.fManuIds,fManuIds);
 257   ::Copy(rl.fMaxNofManus,rl.fManuProbas,fManuProbas);
 258
 259   if ( rl.fChannels )
 260   {
 261     fChannels = static_cast<AliMUONVStore*>(rl.fChannels->Clone());
 262   }
 263 }
 264
 265 //_____________________________________________________________________________
 266 AliMUONRejectList& AliMUONRejectList::operator=(const AliMUONRejectList& rl)
 267 {
 268   /// assignement operator
 269   if ( this != &rl )
 270   {
 271     static_cast<TObject&>(*this)=rl;
 272
 273     fIsBinary = rl.fIsBinary;
 274     fMaxNofDEs = rl.fMaxNofDEs;
 275     fMaxNofBPs = rl.fMaxNofBPs;
 276     fMaxNofManus = rl.fMaxNofManus;
 277     fNofDEs = rl.fNofDEs;
 278     fNofBPs = rl.fNofBPs;
 279     fNofManus = rl.fNofManus;
 280
 281     ::Copy(rl.fMaxNofDEs,rl.fDEIds,fDEIds);
 282     ::Copy(rl.fMaxNofDEs,rl.fDEProbas,fDEProbas);
 283     ::Copy(rl.fMaxNofBPs,rl.fBPIds,fBPIds);
 284     ::Copy(rl.fMaxNofBPs,rl.fBPProbas,fBPProbas);
 285     ::Copy(rl.fMaxNofManus,rl.fManuIds,fManuIds);
 286     ::Copy(rl.fMaxNofManus,rl.fManuProbas,fManuProbas);
 287
 288     delete fChannels;
 289     fChannels = 0x0;
 290
 291     if ( rl.fChannels )
 292     {
 293       fChannels = static_cast<AliMUONVStore*>(rl.fChannels->Clone());
 294     }
 295
 296   }
 297   return *this;
 298 }
 299
 300 //_____________________________________________________________________________
 301 AliMUONRejectList::~AliMUONRejectList()
 302 {
 303   /// dtor
 304   delete fChannels;
 305   delete[] fDEIds;
 306   delete[] fDEProbas;
 307   delete[] fBPIds;
 308   delete[] fBPProbas;
 309   delete[] fManuIds;
 310   delete[] fManuProbas;
 311 }
 312
 313 //_____________________________________________________________________________
 314 Float_t AliMUONRejectList::DetectionElementProbability(Int_t detElemId) const
 315 {
 316   /// Get the probability to reject a given detection element
 317   return ::GetValue(fNofDEs,fDEIds,fDEProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,0));
 318 }
 319
 320 //_____________________________________________________________________________
 321 Float_t AliMUONRejectList::BusPatchProbability(Int_t busPatchId) const
 322 {
 323   /// Get the probability to reject a given bus patch
 324   return ::GetValue(fNofBPs,fBPIds,fBPProbas,AliMUONVCalibParam::BuildUniqueID(busPatchId,0));
 325 }
 326
 327 //_____________________________________________________________________________
 328 Float_t AliMUONRejectList::ManuProbability(Int_t detElemId, Int_t manuId) const
 329 {
 330   /// Get the probability to reject a given manu
 331   return ::GetValue(fNofManus,fManuIds,fManuProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,manuId));
 332 }
 333
 334 //_____________________________________________________________________________
 335 Float_t AliMUONRejectList::ChannelProbability(Int_t detElemId, Int_t manuId, Int_t manuChannel) const
 336 {
 337   /// Get the probability to reject a given channel
 338   AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(fChannels->FindObject(detElemId,manuId));
 339   if (!param) return 0.0;
 340   return param->ValueAsFloat(manuChannel);
 341 }
 342
 343 //_____________________________________________________________________________
 344 void AliMUONRejectList::SetDetectionElementProbability(Int_t detElemId, Float_t proba)
 345 {
 346   /// Set the probability to reject a given detection element
 347   if ( ::SetValue(fNofDEs,fDEIds,fDEProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,0),proba) )
 348   {
 349     ++fNofDEs;
 350   }
 351
 352   ZeroOrOne(proba);
 353 }
 354
 355 //_____________________________________________________________________________
 356 void AliMUONRejectList::ZeroOrOne(Float_t proba)
 357 {
 358   /// If proba is anything else than 0 or 1, we set fIsBinary to kFALSe
 359
 360   Bool_t zeroorone = ( proba == 0.0 || proba == 1.0 );
 361   if (!zeroorone) fIsBinary = kFALSE;
 362 }
 363
 364 //_____________________________________________________________________________
 365 void AliMUONRejectList::SetBusPatchProbability(Int_t busPatchId, Float_t proba)
 366 {
 367   /// Set the probability to reject a given bus patch
 368   if ( ::SetValue(fNofBPs,fBPIds,fBPProbas,AliMUONVCalibParam::BuildUniqueID(busPatchId,0),proba) )
 369   {
 370     ++fNofBPs;
 371   }
 372   ZeroOrOne(proba);
 373 }
 374
 375 //_____________________________________________________________________________
 376 void AliMUONRejectList::SetManuProbability(Int_t detElemId, Int_t manuId, Float_t proba)
 377 {
 378   /// Set the probability to reject a given manu
 379   if ( ::SetValue(fNofManus,fManuIds,fManuProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,manuId),proba) )
 380   {
 381     ++fNofManus;
 382   }
 383   ZeroOrOne(proba);
 384 }
 385
 386 //_____________________________________________________________________________
 387 void AliMUONRejectList::SetChannelProbability(Int_t detElemId, Int_t manuId, Int_t manuChannel, Float_t proba)
 388 {
 389   /// Set the probability to reject a given channel
 390   AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(fChannels->FindObject(detElemId,manuId));
 391   if (!param)
 392   {
 393     param = new AliMUONCalibParamNF(1,AliMpConstants::ManuNofChannels(),detElemId,manuId,0.0);
 394     fChannels->Add(param);
 395   }
 396   param->SetValueAsFloat(manuChannel,0,proba);
 397   ZeroOrOne(proba);
 398 }
 399
 400 //_____________________________________________________________________________
 401 void AliMUONRejectList::SetPCBProbability(Int_t detElemId, Int_t pcbNumber, Float_t proba)
 402 {
 403   /// Set the probability to reject all the manus of a given (slat) PCB
 404   AliMpSegmentation* seg = AliMpSegmentation::Instance();
 405   AliMp::CathodType ct[] = { AliMp::kCath0, AliMp::kCath1 };
 406
 407   for ( Int_t i = 0; i < 2; ++i )
 408   {
 409     const AliMpVSegmentation* vseg = seg->GetMpSegmentation(detElemId,ct[i]);
 410     if (!vseg)
 411     {
 412       AliError(Form("Could not get segmentation of DE %d",detElemId));
 413       continue;
 414     }
 415     const AliMpSlat* slat = seg->GetSlat(vseg);
 416     if (!slat)
 417     {
 418       AliError(Form("Could not get slat from DE %d",detElemId));
 419       continue;
 420     }
 421     AliMpPCB* pcb = slat->GetPCB(pcbNumber);
 422     for ( Int_t j = 0; j < pcb->GetSize(); ++j )
 423     {
 424       AliMpMotifPosition* mp = pcb->GetMotifPosition(j);
 425       SetManuProbability(detElemId,mp->GetID(),proba);
 426     }
 427   }
 428 }
 429
 430 //_____________________________________________________________________________
 431 void AliMUONRejectList::SetHVProbability(const char* dcsName, Float_t proba)
 432 {
 433   /// Set the probability to reject all the manus of a given HV part
 434   /// Caution : the dcs string is a dcs NAME, _not_ an alias
 435
 436   AliMpDCSNamer hv("TRACKER");
 437
 438   TString alias = hv.DCSAliasFromName(dcsName);
 439
 440   Int_t detElemId = hv.DetElemIdFromDCSAlias(alias.Data());
 441   Int_t index = hv.DCSIndexFromDCSAlias(alias.Data());
 442
 443   AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
 444
 445   const AliMpArrayI* manus = de->ManusForHV(index);
 446
 447   for ( Int_t i = 0; i < manus->GetSize(); ++ i )
 448   {
 449     Int_t manuId = manus->GetValue(i);
 450     SetManuProbability(detElemId,manuId,proba);
 451   }
 452 }
 453
 454 //_____________________________________________________________________________
 455 void
 456 AliMUONRejectList::Print(Option_t* opt) const
 457 {
 458   /// Printout
 459
 460   TString sopt(opt);
 461   sopt.ToUpper();
 462   Bool_t debug(kFALSE);
 463
 464   if ( sopt.Contains("DEBUG") ) debug=kTRUE;
 465
 466   cout << Form("We have probabilities for %d detection element(s), %d bus patch(es), %d manu(s)",
 467                fNofDEs,fNofBPs,fNofManus) << endl;
 468
 469   ::Dump("DE %04d",fNofDEs,fDEIds,fDEProbas,debug);
 470   ::Dump("BusPatch %04d",fNofBPs,fBPIds,fBPProbas,debug);
 471   ::Dump("DE %04d MANU %4d",fNofManus,fManuIds,fManuProbas,debug);
 472 }