Plane efficiency framework (Guiseppe)
[u/mrichter/AliRoot.git] / ITS / AliITSPlaneEffSPD.cxx
index f41c9b5..26eca72 100644 (file)
@@ -31,6 +31,7 @@
 #include "AliCDBEntry.h"
 #include "AliCDBManager.h"
 //#include "AliCDBRunRange.h"
+//#include "AliITSsegmentationSPD.h"
 #include "AliITSCalibrationSPD.h"
 
 ClassImp(AliITSPlaneEffSPD)    
@@ -129,9 +130,7 @@ AliITSPlaneEff&  AliITSPlaneEffSPD::operator=(const
     // Return:
 
     if(&s == this) return *this;
-    Error("AliITSPlaneEffSPD","Not allowed to make a = with "
-          "AliITSPlaneEffSPD","Using default creater instead");
-
+    AliError("operator=: Not allowed to make a =, use default creater instead");
     return *this;
 }
 //_______________________________________________________________________
@@ -149,7 +148,7 @@ Int_t AliITSPlaneEffSPD::GetMissingTracksForGivenEff(Double_t eff, Double_t RelE
   //   Return: the estimated n. of tracks 
   //
 if (im>=kNModule || ic>=kNChip) 
- {Error("AliITSPlaneEffSPD","you asked for a non existing chip");
+ {AliError("GetMissingTracksForGivenEff: you asked for a non existing chip");
  return -1;}
 else return GetNTracksForGivenEff(eff,RelErr)-fTried[GetKey(im,ic)];
 }
@@ -160,7 +159,7 @@ Double_t  AliITSPlaneEffSPD::PlaneEff(const UInt_t im,const UInt_t ic) const {
 //        im     -> module number [0,249]
 //        ic     -> chip number [0,4] 
 if (im>=kNModule || ic>=kNChip) 
- {Error("AliITSPlaneEffSPD","you asked for a non existing chip"); return -1.;}
+ {AliError("PlaneEff(Uint_t,Uint_t): you asked for a non existing chip"); return -1.;}
  Int_t nf=fFound[GetKey(im,ic)];
  Int_t nt=fTried[GetKey(im,ic)];
 return AliITSPlaneEff::PlaneEff(nf,nt);
@@ -173,7 +172,7 @@ Double_t  AliITSPlaneEffSPD::ErrPlaneEff(const UInt_t im,const UInt_t ic) const
     //        im     -> module number [0,249]
     //        ic     -> chip number [0,4] 
 if (im>=kNModule || ic>=kNChip) 
- {Error("AliITSPlaneEffSPD","you asked for a non existing chip"); return -1.;}
+ {AliError("ErrPlaneEff(Uint_t,Uint_t): you asked for a non existing chip"); return -1.;}
 Int_t nf=fFound[GetKey(im,ic)];
 Int_t nt=fTried[GetKey(im,ic)];
 return AliITSPlaneEff::ErrPlaneEff(nf,nt);
@@ -183,7 +182,7 @@ Bool_t AliITSPlaneEffSPD::UpDatePlaneEff(const Bool_t Kfound,
                                          const UInt_t im, const UInt_t ic) {
   // Update efficiency for a basic block
 if (im>=kNModule || ic>=kNChip) 
- {Error("AliITSPlaneEffSPD","you asked for a non existing chip"); return kFALSE;}
+ {AliError("UpDatePlaneEff: you asked for a non existing chip"); return kFALSE;}
  fTried[GetKey(im,ic)]++;
  if(Kfound) fFound[GetKey(im,ic)]++;
  return kTRUE;
@@ -192,35 +191,35 @@ if (im>=kNModule || ic>=kNChip)
 UInt_t AliITSPlaneEffSPD::GetChipFromCol(const UInt_t col) const {
   // get chip given the column
 if(col>=kNCol*kNChip) 
- {Error("AliITSPlaneEffSPD","you asked for a non existing column"); return 10;}
+ {AliDebug(1,Form("GetChipFromCol: you asked for a non existing column %d",col)); return 10;}
 return col/kNCol;
 }
 //__________________________________________________________________________
 UInt_t AliITSPlaneEffSPD::GetKey(const UInt_t mod, const UInt_t chip) const {
   // get key given a basic block
 if(mod>=kNModule || chip>=kNChip)
-  {Error("AliITSPlaneEffSPD::GetKey","you asked for a non existing block"); return 99999;}
+  {AliWarning("GetKey: you asked for a non existing block"); return 99999;}
 return mod*kNChip+chip;
 }
 //__________________________________________________________________________
 UInt_t AliITSPlaneEffSPD::GetModFromKey(const UInt_t key) const {
   // get mod. from key
 if(key>=kNModule*kNChip)
-  {Error("AliITSPlaneEffSPD::GetModFromKey","you asked for a non existing key"); return 9999;}
+  {AliError("GetModFromKey: you asked for a non existing key"); return 9999;}
 return key/kNChip;
 }
 //__________________________________________________________________________
 UInt_t AliITSPlaneEffSPD::GetChipFromKey(const UInt_t key) const {
   // retrieves chip from key
 if(key>=kNModule*kNChip)
-  {Error("AliITSPlaneEffSPD::GetChipFromKey","you asked for a non existing key"); return 999;}
+  {AliError("GetChipFromKey: you asked for a non existing key"); return 999;}
 return (key%(kNModule*kNChip))%kNChip;
 }
 //__________________________________________________________________________
 void AliITSPlaneEffSPD::GetModAndChipFromKey(const UInt_t key,UInt_t& mod,UInt_t& chip) const {
   // get module and chip from a key
 if(key>=kNModule*kNChip)
-  {Error("AliITSPlaneEffSPD::GetModAndChipFromKey","you asked for a non existing key"); 
+  {AliError("GetModAndChipFromKey: you asked for a non existing key"); 
   mod=9999;
   chip=999;
   return;}
@@ -232,7 +231,7 @@ return;
 Double_t AliITSPlaneEffSPD::LivePlaneEff(UInt_t key) const {
   // returns plane efficieny after adding the fraction of sensor which is bad
 if(key>=kNModule*kNChip)
-  {Error("AliITSPlaneEffSPD::LivePlaneEff","you asked for a non existing key");
+  {AliError("LivePlaneEff: you asked for a non existing key");
    return -1.;}
 Double_t leff=AliITSPlaneEff::LivePlaneEff(0); // this just for the Warning
 leff=PlaneEff(key)+GetFracBad(key);
@@ -242,7 +241,7 @@ return leff>1?1:leff;
 Double_t AliITSPlaneEffSPD::ErrLivePlaneEff(UInt_t key) const {
   // returns error on live plane efficiency
 if(key>=kNModule*kNChip)
-  {Error("AliITSPlaneEffSPD::ErrLivePlaneEff","you asked for a non existing key");
+  {AliError("ErrLivePlaneEff: you asked for a non existing key");
    return -1.;}
 Int_t nf=fFound[key];
 Double_t triedInLive=GetFracLive(key)*fTried[key];
@@ -253,7 +252,7 @@ return AliITSPlaneEff::ErrPlaneEff(nf,nt); // for the time being: to be checked
 Double_t AliITSPlaneEffSPD::GetFracLive(const UInt_t key) const {
   // returns the fraction of the sensor which is OK
 if(key>=kNModule*kNChip)
-  {Error("AliITSPlaneEffSPD::GetFracLive","you asked for a non existing key");
+  {AliError("GetFracLive: you asked for a non existing key");
    return -1.;}
     // Compute the fraction of bad (dead+noisy) detector 
 UInt_t dead=0,noisy=0;
@@ -269,12 +268,12 @@ void AliITSPlaneEffSPD::GetDeadAndNoisyInChip(const UInt_t key,
 nrDeadInChip=0;
 nrNoisyInChip=0;
 if(key>=kNModule*kNChip)
-  {Error("AliITSPlaneEffSPD::GetDeadAndNoisyInChip","you asked for a non existing key");
+  {AliError("GetDeadAndNoisyInChip: you asked for a non existing key");
    return;}
     // Compute the number of bad (dead+noisy) pixel in a chip
 //
 if(!fInitCDBCalled) 
-  {Error("AliITSPlaneEffSPD::GetDeadAndNoisyInChip","CDB not inizialized: call InitCDB first");
+  {AliError("GetDeadAndNoisyInChip: CDB not inizialized: call InitCDB first");
    return;};
 AliCDBManager* man = AliCDBManager::Instance();
 // retrieve map of dead Pixel 
@@ -283,10 +282,10 @@ TObjArray* spdDead;
 if(cdbSPDDead) {
   spdDead = (TObjArray*)cdbSPDDead->GetObject();
   if(!spdDead) 
-  {Error("AliITSPlaneEffSPD::GetDeadAndNoisyInChip"," SPDDead not found in CDB");
+  {AliError("GetDeadAndNoisyInChip: SPDDead not found in CDB");
    return;}
 } else {
-  Error("AliITSPlaneEffSPD::GetDeadAndNoisyInChip","Did not find Calib/SPDDead.");
+  AliError("GetDeadAndNoisyInChip: did not find Calib/SPDDead.");
   return;
 }
 // retrieve map of noisy Pixel 
@@ -295,10 +294,10 @@ TObjArray* spdNoisy;
 if(cdbSPDNoisy) {
   spdNoisy = (TObjArray*)cdbSPDNoisy->GetObject();
   if(!spdNoisy) 
-  {Error("AliITSPlaneEffSPD::GetDeadAndNoisyInChip"," SPDNoisy not found in CDB");
+  {AliError("GetDeadAndNoisyInChip: SPDNoisy not found in CDB");
    return;}
 } else {
-  Error("AliITSPlaneEffSPD::GetDeadAndNoisyInChip","Did not find Calib/SPDNoisy.");
+  AliError("GetDeadAndNoisyInChip: did not find Calib/SPDNoisy.");
   return;
 }
 //
@@ -321,7 +320,7 @@ return;
 Double_t AliITSPlaneEffSPD::GetFracBad(const UInt_t key) const {
   // returns 1-fractional live
 if(key>=kNModule*kNChip)
-  {Error("AliITSPlaneEffSPD::GetFracBad","you asked for a non existing key");
+  {AliError("GetFracBad: you asked for a non existing key");
    return -1.;}
 return 1.-GetFracLive(key);
 }
@@ -329,7 +328,7 @@ return 1.-GetFracLive(key);
 Bool_t AliITSPlaneEffSPD::WriteIntoCDB() const {
 // write onto CDB
 if(!fInitCDBCalled)
-  {Error("AliITSPlaneEffSPD::WriteIntoCDB","CDB not inizialized: call InitCDB first");
+  {AliError("WriteIntoCDB: CDB not inizialized. Call InitCDB first");
    return kFALSE;}
 // to be written properly: now only for debugging 
   AliCDBMetaData *md= new AliCDBMetaData(); // metaData describing the object
@@ -348,7 +347,7 @@ if(!fInitCDBCalled)
 Bool_t AliITSPlaneEffSPD::ReadFromCDB() {
 // read from CDB
 if(!fInitCDBCalled)
-  {Error("AliITSPlaneEffSPD::ReadFromCDB","CDB not inizialized: call InitCDB first");
+  {AliError("ReadFromCDB: CDB not inizialized. Call InitCDB first");
    return kFALSE;}
 //if(!AliCDBManager::Instance()->IsDefaultStorageSet()) {
 //    AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
@@ -359,3 +358,60 @@ if(this==eff) return kFALSE;
 eff->Copy(*this);
 return kTRUE;
 }
+//_____________________________________________________________________________
+UInt_t AliITSPlaneEffSPD::GetKeyFromDetLocCoord(Int_t ilay, Int_t idet, 
+                                               Float_t, Float_t locz) const {
+// method to locate a basic block from Detector Local coordinate (to be used in tracking)
+UInt_t key=999999;
+if(ilay<0 || ilay>1) 
+  {AliError("GetKeyFromDetLocCoord: you asked for a non existing layer");
+   return key;}
+if(ilay==0 && (idet<0 || idet>79))
+ {AliError("GetKeyFromDetLocCoord: you asked for a non existing detector");
+   return key;}
+if(ilay==1 && (idet<0 || idet>159))
+ {AliError("GetKeyFromDetLocCoord: you asked for a non existing detector");
+   return key;}
+
+UInt_t mod=idet;
+if(ilay==1) mod+=80;
+key=GetKey(mod,GetChipFromCol(GetColFromLocZ(locz)));
+return key;
+}
+//_____________________________________________________________________________
+UInt_t AliITSPlaneEffSPD::GetColFromLocZ(Float_t zloc) const {
+UInt_t col=0;
+/* note: as it is now, the AliITSsegmentationSPD::Init() does not properly initialize (6 chips !!!)
+AliITSsegmentationSPD spd;
+spd.Init();
+Int_t ix,iz;
+if(spd.LocalToDet(0,zloc,ix,iz)) col+=iz;
+else {
+  AliError("GetColFromLocZ: cannot compute column number from local z");
+  col=99999;}
+return col;
+*/
+const Float_t kconv = 1.0E-04; // converts microns to cm.
+Float_t bz[160];
+for(Int_t i=000;i<160;i++) bz[i] = 425.0; // most are 425 microns except below
+bz[ 31] = bz[ 32] = 625.0; // first chip boundry
+bz[ 63] = bz[ 64] = 625.0; // first chip boundry
+bz[ 95] = bz[ 96] = 625.0; // first chip boundry
+bz[127] = bz[128] = 625.0; // first chip boundry
+//
+Int_t j=-1;
+Float_t dz=0;
+for(Int_t i=000;i<160;i++) dz+=bz[i];
+dz = -0.5*kconv*dz;
+if(zloc<dz || zloc>-1*dz) { // outside z range
+  AliDebug(1,Form("GetColFromLocZ: cannot compute column number from local z=%f",zloc));
+  return 99999;}
+for(j=0;j<160;j++){
+  dz += kconv*bz[j];
+  if(zloc<dz) break;
+} // end for j
+col+=j;
+//
+return col;
+}
+//________________________________________________________