[u/mrichter/AliRoot.git] / ITS / AliITSPlaneEffSPD.cxx

/**************************************************************************
 * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/
///////////////////////////////////////////////////////////////////////////
//  Plane Efficiency class for ITS                      
//  It is used for chip by chip efficiency of the SPD,        
//  evaluated by tracks
//  (Inherits from AliITSPlaneEff)
//  Author: G.E. Bruno 
//          giuseppe.bruno@ba.infn.it
//
///////////////////////////////////////////////////////////////////////////

/* $Id$ */

#include "AliITSPlaneEffSPD.h"
#include "AliLog.h"
#include "AliCDBStorage.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.h"
//#include "AliCDBRunRange.h"
#include "AliITSCalibrationSPD.h"

ClassImp(AliITSPlaneEffSPD)	
//______________________________________________________________________
AliITSPlaneEffSPD::AliITSPlaneEffSPD():
  AliITSPlaneEff(){
//  for (UInt_t im=0; im<kNModule; im++){
//  for (UInt_t ic=0; ic<kNChip; ic++){
//    fFound[im][ic]=0;
//    fTried[im][ic]=0;
//  }}
  for (UInt_t i=0; i<kNModule*kNChip; i++){
    fFound[i]=0;
    fTried[i]=0;
  }
  // default constructor
  AliDebug(1,Form("Calling default constructor"));
}
//______________________________________________________________________
AliITSPlaneEffSPD::~AliITSPlaneEffSPD(){
    // destructor
    // Inputs:
    //    none.
    // Outputs:
    //    none.
    // Return:
    //     none.
}
//______________________________________________________________________
AliITSPlaneEffSPD::AliITSPlaneEffSPD(const AliITSPlaneEffSPD &s) : AliITSPlaneEff(s) //,
//fHis(s.fHis),
{
    //     Copy Constructor
    // Inputs:
    //    AliITSPlaneEffSPD &s The original class for which
    //                                this class is a copy of
    // Outputs:
    //    none.
    // Return:

}
//_________________________________________________________________________
AliITSPlaneEffSPD& AliITSPlaneEffSPD::operator+=(const AliITSPlaneEffSPD &add){
    //    Add-to-me operator
    // Inputs:
    //    const AliITSPlaneEffSPD &add  simulation class to be added
    // Outputs:
    //    none.
    // Return:
    //    none
    for (UInt_t i=0; i<kNModule*kNChip; i++){
      fFound[i] += add.fFound[i];
      fTried[i] += add.fTried[i];
    }
    return *this;
}
//______________________________________________________________________
AliITSPlaneEffSPD&  AliITSPlaneEffSPD::operator=(const
                                           AliITSPlaneEffSPD &s){
    //    Assignment operator
    // Inputs:
    //    AliITSPlaneEffSPD &s The original class for which
    //                                this class is a copy of
    // Outputs:
    //    none.
    // Return:
 
    if(this==&s) return *this;
    s.Copy(*this);
//    if(&s == this) return *this;
//    for (UInt_t i=0; i<kNModule*kNChip; i++){
//      this->fFound[i] = s.fFound[i];
//      this->fTried[i] = s.fTried[i];
//    }
    return *this;
}
//______________________________________________________________________
void AliITSPlaneEffSPD::Copy(TObject &obj) const {
  // protected method. copy this to obj
  AliITSPlaneEff::Copy(obj);
  //((AliITSPlaneEffSPD& ) obj).fNpx  = fNpx;
  for(Int_t i=0;i<kNModule*kNChip;i++) {
      ((AliITSPlaneEffSPD& ) obj).fFound[i] = fFound[i];
      ((AliITSPlaneEffSPD& ) obj).fTried[i] = fTried[i];
  }
}
//______________________________________________________________________
AliITSPlaneEff&  AliITSPlaneEffSPD::operator=(const
                                           AliITSPlaneEff &s){
    //    Assignment operator
    // Inputs:
    //    AliITSPlaneEffSPD &s The original class for which
    //                                this class is a copy of
    // Outputs:
    //    none.
    // Return:

    if(&s == this) return *this;
    Error("AliITSPlaneEffSPD","Not allowed to make a = with "
          "AliITSPlaneEffSPD","Using default creater instead");

    return *this;
}
//_______________________________________________________________________
Int_t AliITSPlaneEffSPD::GetMissingTracksForGivenEff(Double_t eff, Double_t RelErr,
          UInt_t im, UInt_t ic) const {
   
  //   Estimate the number of tracks still to be collected to attain a 
  //   given efficiency eff, with relative error RelErr
  //   Inputs:
  //         eff    -> Expected efficiency (e.g. those from actual estimate)
  //         RelErr -> tollerance [0,1] 
  //         im     -> module number [0,249]
  //         ic     -> chip number [0,5]
  //   Outputs: none
  //   Return: the estimated n. of tracks 
  //
if (im>=kNModule || ic>=kNChip) 
 {Error("AliITSPlaneEffSPD","you asked for a non existing chip");
 return -1;}
else return GetNTracksForGivenEff(eff,RelErr)-fTried[GetKey(im,ic)];
}
//_________________________________________________________________________
Double_t  AliITSPlaneEffSPD::PlaneEff(const UInt_t im,const UInt_t ic) const {
// Compute the efficiency for a basic block, 
// Inputs:
//        number of associated cluslters (nf) 
//        number of used tracks (nt)
if (im>=kNModule || ic>=kNChip) 
 {Error("AliITSPlaneEffSPD","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);
}
//_________________________________________________________________________
Double_t  AliITSPlaneEffSPD::ErrPlaneEff(const UInt_t im,const UInt_t ic) const {
    // Compute the statistical error on efficiency for a basic block,
    // using binomial statistics 
    // Inputs:
    //        number of associated cluslters (nf)
    //        number of used tracks (nt)
if (im>=kNModule || ic>=kNChip) 
 {Error("AliITSPlaneEffSPD","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);
} 
//_________________________________________________________________________
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;}
 fTried[GetKey(im,ic)]++;
 if(Kfound) fFound[GetKey(im,ic)]++;
 return kTRUE;
}
//_________________________________________________________________________
UInt_t AliITSPlaneEffSPD::GetChip(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;}
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;}
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;}
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;}
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"); 
  mod=9999;
  chip=999;
  return;}
mod=key/kNChip;
chip=(key%(kNModule*kNChip))%kNChip;
return;
}
//____________________________________________________________________________
Double_t AliITSPlaneEffSPD::LivePlaneEff(UInt_t key) const {
  // returns plane efficieny multiplied by the fraction of sensor which is OK
if(key>=kNModule*kNChip)
  {Error("AliITSPlaneEffSPD::LivePlaneEff","you asked for a non existing key");
   return -1.;}
return PlaneEff(key)*GetFracLive(key);
}
//____________________________________________________________________________
Double_t AliITSPlaneEffSPD::ErrLivePlaneEff(UInt_t key) const {
  // returns error on live plane efficiency
if(key>=kNModule*kNChip)
  {Error("AliITSPlaneEffSPD::LivePlaneEff","you asked for a non existing key");
   return -1.;}
return ErrPlaneEff(key); // 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::GetRelLiveDetector","you asked for a non existing key");
   return -1.;}
    // Compute the fraction of bad (dead+noisy) detector 
UInt_t dead=0,noisy=0;
GetDeadAndNoisyInChip(key,dead,noisy);
Double_t live=dead+noisy;
live/=(kNRow*kNCol);
return 1.-live;
}
//_____________________________________________________________________________
void AliITSPlaneEffSPD::GetDeadAndNoisyInChip(const UInt_t key,
      UInt_t& nrDeadInChip, UInt_t& nrNoisyInChip) const {
  // returns the number of dead and noisy pixels
nrDeadInChip=0;
nrNoisyInChip=0;
if(key>=kNModule*kNChip)
  {Error("AliITSPlaneEffSPD::GetRelLiveDetector","you asked for a non existing key");
   return;}
    // Compute the number of bad (dead+noisy) pixel in a chip
//
if(!fInitCDBCalled) 
  {Error("AliITSPlaneEffSPD::GetRelLiveDetector","CDB not inizialized: call InitCDB first");
   return;};
AliCDBManager* man = AliCDBManager::Instance();
// retrieve map of dead Pixel 
AliCDBEntry *cdbSPDDead = man->Get("ITS/Calib/SPDDead", fRunNumber);
TObjArray* spdDead;
if(cdbSPDDead) {
  spdDead = (TObjArray*)cdbSPDDead->GetObject();
  if(!spdDead) 
  {Error("AliITSPlaneEffSPD::GetRelLiveDetector"," SPDDead not found in CDB");
   return;}
} else {
  Error("AliITSPlaneEffSPD::GetRelLiveDetector","Did not find Calib/SPDDead.");
  return;
}
// retrieve map of noisy Pixel 
AliCDBEntry *cdbSPDNoisy = man->Get("ITS/Calib/SPDNoisy", fRunNumber);
TObjArray* spdNoisy;
if(cdbSPDNoisy) {
  spdNoisy = (TObjArray*)cdbSPDNoisy->GetObject();
  if(!spdNoisy) 
  {Error("AliITSPlaneEffSPD::GetRelLiveDetector"," SPDNoisy not found in CDB");
   return;}
} else {
  Error("AliITSPlaneEffSPD::GetRelLiveDetector","Did not find Calib/SPDNoisy.");
  return;
}
//
UInt_t mod=GetModFromKey(key);
UInt_t chip=GetChipFromKey(key);
// count number of dead
AliITSCalibrationSPD* calibSPD=(AliITSCalibrationSPD*) spdDead->At(mod);
UInt_t nrDead = calibSPD->GetNrBad();
for (UInt_t index=0; index<nrDead; index++) {
  if(GetChip(calibSPD->GetBadColAt(index))==chip) nrDeadInChip++;
}
calibSPD=(AliITSCalibrationSPD*) spdNoisy->At(mod);
UInt_t nrNoisy = calibSPD->GetNrBad();
for (UInt_t index=0; index<nrNoisy; index++) {
  if(GetChip(calibSPD->GetBadColAt(index))==chip) nrNoisyInChip++;
}
return;
}
//_____________________________________________________________________________
Double_t AliITSPlaneEffSPD::GetFracBad(const UInt_t key) const {
  // returns 1-fractional live
if(key>=kNModule*kNChip)
  {Error("AliITSPlaneEffSPD::GetRelDeadDetector","you asked for a non existing key");
   return -1.;}
return 1.-GetFracLive(key);
}
//_____________________________________________________________________________
Bool_t AliITSPlaneEffSPD::WriteIntoCDB() const {
// write onto CDB
if(!fInitCDBCalled)
  {Error("AliITSPlaneEffSPD::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
  md->SetObjectClassName("AliITSPlaneEff");
  md->SetResponsible("Giuseppe Eugenio Bruno");
  md->SetBeamPeriod(0);
  md->SetAliRootVersion("head 19/11/07"); //root version
  AliCDBId id("ITS/PlaneEff/PlaneEffSPD",0,AliCDBRunRange::Infinity()); 
  AliITSPlaneEffSPD eff; 
  eff=*this;
  Bool_t r=AliCDBManager::Instance()->GetDefaultStorage()->Put(&eff,id,md);
  delete md;
  return r;
}
//_____________________________________________________________________________
Bool_t AliITSPlaneEffSPD::ReadFromCDB() {
// read from CDB
if(!fInitCDBCalled)
  {Error("AliITSPlaneEffSPD::ReadFromCDB","CDB not inizialized: call InitCDB first");
   return kFALSE;}
//if(!AliCDBManager::Instance()->IsDefaultStorageSet()) {
//    AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
//  }
AliCDBEntry *cdbEntry = AliCDBManager::Instance()->Get("ITS/PlaneEff/PlaneEffSPD",fRunNumber);
AliITSPlaneEffSPD* eff= (AliITSPlaneEffSPD*)cdbEntry->GetObject();
if(this==eff) return kFALSE;
eff->Copy(*this);
return kTRUE;
}
Commit	Line	Data
4a66240a	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	}