ITS/AliITSPlaneEffSPD.cxx

   1 /**************************************************************************
   2  * Copyright(c) 2007-2009, 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 //  Plane Efficiency class for ITS
  17 //  It is used for chip by chip efficiency of the SPD,
  18 //  evaluated by tracks
  19 //  (Inherits from AliITSPlaneEff)
  20 //  Author: G.E. Bruno
  21 //          giuseppe.bruno@ba.infn.it
  22 //
  23 ///////////////////////////////////////////////////////////////////////////
  24
  25 /* $Id$ */
  26
  27 #include "AliITSPlaneEffSPD.h"
  28 #include "AliLog.h"
  29 #include "AliCDBStorage.h"
  30 #include "AliCDBEntry.h"
  31 #include "AliCDBManager.h"
  32 //#include "AliCDBRunRange.h"
  33 #include "AliITSCalibrationSPD.h"
  34
  35 ClassImp(AliITSPlaneEffSPD)
  36 //______________________________________________________________________
  37 AliITSPlaneEffSPD::AliITSPlaneEffSPD():
  38   AliITSPlaneEff(){
  39 //  for (UInt_t im=0; im<kNModule; im++){
  40 //  for (UInt_t ic=0; ic<kNChip; ic++){
  41 //    fFound[im][ic]=0;
  42 //    fTried[im][ic]=0;
  43 //  }}
  44   for (UInt_t i=0; i<kNModule*kNChip; i++){
  45     fFound[i]=0;
  46     fTried[i]=0;
  47   }
  48   // default constructor
  49   AliDebug(1,Form("Calling default constructor"));
  50 }
  51 //______________________________________________________________________
  52 AliITSPlaneEffSPD::~AliITSPlaneEffSPD(){
  53     // destructor
  54     // Inputs:
  55     //    none.
  56     // Outputs:
  57     //    none.
  58     // Return:
  59     //     none.
  60 }
  61 //______________________________________________________________________
  62 AliITSPlaneEffSPD::AliITSPlaneEffSPD(const AliITSPlaneEffSPD &s) : AliITSPlaneEff(s) //,
  63 //fHis(s.fHis),
  64 {
  65     //     Copy Constructor
  66     // Inputs:
  67     //    AliITSPlaneEffSPD &s The original class for which
  68     //                                this class is a copy of
  69     // Outputs:
  70     //    none.
  71     // Return:
  72
  73 }
  74 //_________________________________________________________________________
  75 AliITSPlaneEffSPD& AliITSPlaneEffSPD::operator+=(const AliITSPlaneEffSPD &add){
  76     //    Add-to-me operator
  77     // Inputs:
  78     //    const AliITSPlaneEffSPD &add  simulation class to be added
  79     // Outputs:
  80     //    none.
  81     // Return:
  82     //    none
  83     for (UInt_t i=0; i<kNModule*kNChip; i++){
  84       fFound[i] += add.fFound[i];
  85       fTried[i] += add.fTried[i];
  86     }
  87     return *this;
  88 }
  89 //______________________________________________________________________
  90 AliITSPlaneEffSPD&  AliITSPlaneEffSPD::operator=(const
  91                                            AliITSPlaneEffSPD &s){
  92     //    Assignment operator
  93     // Inputs:
  94     //    AliITSPlaneEffSPD &s The original class for which
  95     //                                this class is a copy of
  96     // Outputs:
  97     //    none.
  98     // Return:
  99
 100     if(this==&s) return *this;
 101     s.Copy(*this);
 102 //    if(&s == this) return *this;
 103 //    for (UInt_t i=0; i<kNModule*kNChip; i++){
 104 //      this->fFound[i] = s.fFound[i];
 105 //      this->fTried[i] = s.fTried[i];
 106 //    }
 107     return *this;
 108 }
 109 //______________________________________________________________________
 110 void AliITSPlaneEffSPD::Copy(TObject &obj) const {
 111   // protected method. copy this to obj
 112   AliITSPlaneEff::Copy(obj);
 113   //((AliITSPlaneEffSPD& ) obj).fNpx  = fNpx;
 114   for(Int_t i=0;i<kNModule*kNChip;i++) {
 115       ((AliITSPlaneEffSPD& ) obj).fFound[i] = fFound[i];
 116       ((AliITSPlaneEffSPD& ) obj).fTried[i] = fTried[i];
 117   }
 118 }
 119 //______________________________________________________________________
 120 AliITSPlaneEff&  AliITSPlaneEffSPD::operator=(const
 121                                            AliITSPlaneEff &s){
 122     //    Assignment operator
 123     // Inputs:
 124     //    AliITSPlaneEffSPD &s The original class for which
 125     //                                this class is a copy of
 126     // Outputs:
 127     //    none.
 128     // Return:
 129
 130     if(&s == this) return *this;
 131     Error("AliITSPlaneEffSPD","Not allowed to make a = with "
 132           "AliITSPlaneEffSPD","Using default creater instead");
 133
 134     return *this;
 135 }
 136 //_______________________________________________________________________
 137 Int_t AliITSPlaneEffSPD::GetMissingTracksForGivenEff(Double_t eff, Double_t RelErr,
 138           UInt_t im, UInt_t ic) const {
 139
 140   //   Estimate the number of tracks still to be collected to attain a
 141   //   given efficiency eff, with relative error RelErr
 142   //   Inputs:
 143   //         eff    -> Expected efficiency (e.g. those from actual estimate)
 144   //         RelErr -> tollerance [0,1]
 145   //         im     -> module number [0,249]
 146   //         ic     -> chip number [0,5]
 147   //   Outputs: none
 148   //   Return: the estimated n. of tracks
 149   //
 150 if (im>=kNModule || ic>=kNChip)
 151  {Error("AliITSPlaneEffSPD","you asked for a non existing chip");
 152  return -1;}
 153 else return GetNTracksForGivenEff(eff,RelErr)-fTried[GetKey(im,ic)];
 154 }
 155 //_________________________________________________________________________
 156 Double_t  AliITSPlaneEffSPD::PlaneEff(const UInt_t im,const UInt_t ic) const {
 157 // Compute the efficiency for a basic block,
 158 // Inputs:
 159 //        number of associated cluslters (nf)
 160 //        number of used tracks (nt)
 161 if (im>=kNModule || ic>=kNChip)
 162  {Error("AliITSPlaneEffSPD","you asked for a non existing chip"); return -1.;}
 163  Int_t nf=fFound[GetKey(im,ic)];
 164  Int_t nt=fTried[GetKey(im,ic)];
 165 return AliITSPlaneEff::PlaneEff(nf,nt);
 166 }
 167 //_________________________________________________________________________
 168 Double_t  AliITSPlaneEffSPD::ErrPlaneEff(const UInt_t im,const UInt_t ic) const {
 169     // Compute the statistical error on efficiency for a basic block,
 170     // using binomial statistics
 171     // Inputs:
 172     //        number of associated cluslters (nf)
 173     //        number of used tracks (nt)
 174 if (im>=kNModule || ic>=kNChip)
 175  {Error("AliITSPlaneEffSPD","you asked for a non existing chip"); return -1.;}
 176 Int_t nf=fFound[GetKey(im,ic)];
 177 Int_t nt=fTried[GetKey(im,ic)];
 178 return AliITSPlaneEff::ErrPlaneEff(nf,nt);
 179 }
 180 //_________________________________________________________________________
 181 Bool_t AliITSPlaneEffSPD::UpDatePlaneEff(const Bool_t Kfound,
 182                                          const UInt_t im, const UInt_t ic) {
 183   // Update efficiency for a basic block
 184 if (im>=kNModule || ic>=kNChip)
 185  {Error("AliITSPlaneEffSPD","you asked for a non existing chip"); return kFALSE;}
 186  fTried[GetKey(im,ic)]++;
 187  if(Kfound) fFound[GetKey(im,ic)]++;
 188  return kTRUE;
 189 }
 190 //_________________________________________________________________________
 191 UInt_t AliITSPlaneEffSPD::GetChip(const UInt_t col) const {
 192   // get chip given the column
 193 if(col>=kNCol*kNChip)
 194  {Error("AliITSPlaneEffSPD","you asked for a non existing column"); return 10;}
 195 return col/kNCol;
 196 }
 197 //__________________________________________________________________________
 198 UInt_t AliITSPlaneEffSPD::GetKey(const UInt_t mod, const UInt_t chip) const {
 199   // get key given a basic block
 200 if(mod>=kNModule || chip>=kNChip)
 201   {Error("AliITSPlaneEffSPD::GetKey","you asked for a non existing block"); return 99999;}
 202 return mod*kNChip+chip;
 203 }
 204 //__________________________________________________________________________
 205 UInt_t AliITSPlaneEffSPD::GetModFromKey(const UInt_t key) const {
 206   // get mod. from key
 207 if(key>=kNModule*kNChip)
 208   {Error("AliITSPlaneEffSPD::GetModFromKey","you asked for a non existing key"); return 9999;}
 209 return key/kNChip;
 210 }
 211 //__________________________________________________________________________
 212 UInt_t AliITSPlaneEffSPD::GetChipFromKey(const UInt_t key) const {
 213   // retrieves chip from key
 214 if(key>=kNModule*kNChip)
 215   {Error("AliITSPlaneEffSPD::GetChipFromKey","you asked for a non existing key"); return 999;}
 216 return (key%(kNModule*kNChip))%kNChip;
 217 }
 218 //__________________________________________________________________________
 219 void AliITSPlaneEffSPD::GetModAndChipFromKey(const UInt_t key,UInt_t& mod,UInt_t& chip) const {
 220   // get module and chip from a key
 221 if(key>=kNModule*kNChip)
 222   {Error("AliITSPlaneEffSPD::GetModAndChipFromKey","you asked for a non existing key");
 223   mod=9999;
 224   chip=999;
 225   return;}
 226 mod=key/kNChip;
 227 chip=(key%(kNModule*kNChip))%kNChip;
 228 return;
 229 }
 230 //____________________________________________________________________________
 231 Double_t AliITSPlaneEffSPD::LivePlaneEff(UInt_t key) const {
 232   // returns plane efficieny multiplied by the fraction of sensor which is OK
 233 if(key>=kNModule*kNChip)
 234   {Error("AliITSPlaneEffSPD::LivePlaneEff","you asked for a non existing key");
 235    return -1.;}
 236 return PlaneEff(key)*GetFracLive(key);
 237 }
 238 //____________________________________________________________________________
 239 Double_t AliITSPlaneEffSPD::ErrLivePlaneEff(UInt_t key) const {
 240   // returns error on live plane efficiency
 241 if(key>=kNModule*kNChip)
 242   {Error("AliITSPlaneEffSPD::LivePlaneEff","you asked for a non existing key");
 243    return -1.;}
 244 return ErrPlaneEff(key); // for the time being: to be checked
 245 }
 246 //_____________________________________________________________________________
 247 Double_t AliITSPlaneEffSPD::GetFracLive(const UInt_t key) const {
 248   // returns the fraction of the sensor which is OK
 249 if(key>=kNModule*kNChip)
 250   {Error("AliITSPlaneEffSPD::GetRelLiveDetector","you asked for a non existing key");
 251    return -1.;}
 252     // Compute the fraction of bad (dead+noisy) detector
 253 UInt_t dead=0,noisy=0;
 254 GetDeadAndNoisyInChip(key,dead,noisy);
 255 Double_t live=dead+noisy;
 256 live/=(kNRow*kNCol);
 257 return 1.-live;
 258 }
 259 //_____________________________________________________________________________
 260 void AliITSPlaneEffSPD::GetDeadAndNoisyInChip(const UInt_t key,
 261       UInt_t& nrDeadInChip, UInt_t& nrNoisyInChip) const {
 262   // returns the number of dead and noisy pixels
 263 nrDeadInChip=0;
 264 nrNoisyInChip=0;
 265 if(key>=kNModule*kNChip)
 266   {Error("AliITSPlaneEffSPD::GetRelLiveDetector","you asked for a non existing key");
 267    return;}
 268     // Compute the number of bad (dead+noisy) pixel in a chip
 269 //
 270 if(!fInitCDBCalled)
 271   {Error("AliITSPlaneEffSPD::GetRelLiveDetector","CDB not inizialized: call InitCDB first");
 272    return;};
 273 AliCDBManager* man = AliCDBManager::Instance();
 274 // retrieve map of dead Pixel
 275 AliCDBEntry *cdbSPDDead = man->Get("ITS/Calib/SPDDead", fRunNumber);
 276 TObjArray* spdDead;
 277 if(cdbSPDDead) {
 278   spdDead = (TObjArray*)cdbSPDDead->GetObject();
 279   if(!spdDead)
 280   {Error("AliITSPlaneEffSPD::GetRelLiveDetector"," SPDDead not found in CDB");
 281    return;}
 282 } else {
 283   Error("AliITSPlaneEffSPD::GetRelLiveDetector","Did not find Calib/SPDDead.");
 284   return;
 285 }
 286 // retrieve map of noisy Pixel
 287 AliCDBEntry *cdbSPDNoisy = man->Get("ITS/Calib/SPDNoisy", fRunNumber);
 288 TObjArray* spdNoisy;
 289 if(cdbSPDNoisy) {
 290   spdNoisy = (TObjArray*)cdbSPDNoisy->GetObject();
 291   if(!spdNoisy)
 292   {Error("AliITSPlaneEffSPD::GetRelLiveDetector"," SPDNoisy not found in CDB");
 293    return;}
 294 } else {
 295   Error("AliITSPlaneEffSPD::GetRelLiveDetector","Did not find Calib/SPDNoisy.");
 296   return;
 297 }
 298 //
 299 UInt_t mod=GetModFromKey(key);
 300 UInt_t chip=GetChipFromKey(key);
 301 // count number of dead
 302 AliITSCalibrationSPD* calibSPD=(AliITSCalibrationSPD*) spdDead->At(mod);
 303 UInt_t nrDead = calibSPD->GetNrBad();
 304 for (UInt_t index=0; index<nrDead; index++) {
 305   if(GetChip(calibSPD->GetBadColAt(index))==chip) nrDeadInChip++;
 306 }
 307 calibSPD=(AliITSCalibrationSPD*) spdNoisy->At(mod);
 308 UInt_t nrNoisy = calibSPD->GetNrBad();
 309 for (UInt_t index=0; index<nrNoisy; index++) {
 310   if(GetChip(calibSPD->GetBadColAt(index))==chip) nrNoisyInChip++;
 311 }
 312 return;
 313 }
 314 //_____________________________________________________________________________
 315 Double_t AliITSPlaneEffSPD::GetFracBad(const UInt_t key) const {
 316   // returns 1-fractional live
 317 if(key>=kNModule*kNChip)
 318   {Error("AliITSPlaneEffSPD::GetRelDeadDetector","you asked for a non existing key");
 319    return -1.;}
 320 return 1.-GetFracLive(key);
 321 }
 322 //_____________________________________________________________________________
 323 Bool_t AliITSPlaneEffSPD::WriteIntoCDB() const {
 324 // write onto CDB
 325 if(!fInitCDBCalled)
 326   {Error("AliITSPlaneEffSPD::WriteIntoCDB","CDB not inizialized: call InitCDB first");
 327    return kFALSE;}
 328 // to be written properly: now only for debugging
 329   AliCDBMetaData *md= new AliCDBMetaData(); // metaData describing the object
 330   md->SetObjectClassName("AliITSPlaneEff");
 331   md->SetResponsible("Giuseppe Eugenio Bruno");
 332   md->SetBeamPeriod(0);
 333   md->SetAliRootVersion("head 19/11/07"); //root version
 334   AliCDBId id("ITS/PlaneEff/PlaneEffSPD",0,AliCDBRunRange::Infinity());
 335   AliITSPlaneEffSPD eff;
 336   eff=*this;
 337   Bool_t r=AliCDBManager::Instance()->GetDefaultStorage()->Put(&eff,id,md);
 338   delete md;
 339   return r;
 340 }
 341 //_____________________________________________________________________________
 342 Bool_t AliITSPlaneEffSPD::ReadFromCDB() {
 343 // read from CDB
 344 if(!fInitCDBCalled)
 345   {Error("AliITSPlaneEffSPD::ReadFromCDB","CDB not inizialized: call InitCDB first");
 346    return kFALSE;}
 347 //if(!AliCDBManager::Instance()->IsDefaultStorageSet()) {
 348 //    AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
 349 //  }
 350 AliCDBEntry *cdbEntry = AliCDBManager::Instance()->Get("ITS/PlaneEff/PlaneEffSPD",fRunNumber);
 351 AliITSPlaneEffSPD* eff= (AliITSPlaneEffSPD*)cdbEntry->GetObject();
 352 if(this==eff) return kFALSE;
 353 eff->Copy(*this);
 354 return kTRUE;
 355 }