[u/mrichter/AliRoot.git] / ITS / AliITSCalibrationSSD.h

#ifndef ALIITSCALIBRATIONSSD_H
#define ALIITSCALIBRATIONSSD_H
/* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */ 
#include "AliITSCalibration.h"
#include "AliITSNoiseSSD.h"
#include "AliITSPedestalSSD.h"
#include "AliITSGainSSD.h"
#include "AliITSBadChannelsSSD.h"
#include "AliITSresponseSSD.h"
#include "TArrayF.h"
#include "TArrayI.h"

/* $Id$ */
//////////////////////////////////////////////
// Response class for SSD                   //
//                                          //
//////////////////////////////////////////////
class AliITSCalibrationSSD : public AliITSCalibration {

 public:
    AliITSCalibrationSSD();
    AliITSCalibrationSSD(const char *dataType);
    virtual ~AliITSCalibrationSSD();

    virtual  void   SetNoiseParam(Double_t np, Double_t nn) {
    	// set noise par
    	fNoiseP=np; fNoiseN=nn;
    }

    virtual void    GetNoiseParam(Double_t &np, Double_t &nn) const {
    	// get noise par
    	np=fNoiseP; nn=fNoiseN;
    }

    void AddNoiseP(Int_t c, Float_t n) { fNoise->AddNoiseP(c,n);}       
    TArrayF GetNoiseP() {return fNoise->GetNoiseP(); }
    Float_t GetNoiseP(Int_t n) {return fNoise->GetNoiseP(n); }
    void AddNoiseN(Int_t c, Float_t n) { fNoise->AddNoiseN(c,n);}
    TArrayF GetNoiseN() {return fNoise->GetNoiseN(); }
    Float_t GetNoiseN(Int_t n) {return fNoise->GetNoiseN(n); }
    void SetNoise( AliITSNoiseSSD* noise) {fNoise=noise;}

    void AddPedestalP(Int_t c, Float_t n) { fPedestal->AddPedestalP(c,n);}       
    TArrayF GetPedestalP() {return fPedestal->GetPedestalP(); }
    Float_t GetPedestalP(Int_t n) {return fPedestal->GetPedestalP(n); }
    void AddPedestalN(Int_t c, Float_t n) { fPedestal->AddPedestalN(c,n);}
    TArrayF GetPedestalN() {return fPedestal->GetPedestalN(); }
    Float_t GetPedestalN(Int_t n) {return fPedestal->GetPedestalN(n); }
    void SetPedestal( AliITSPedestalSSD* pedestal) {fPedestal=pedestal;}

    void AddGainP(Int_t c, Float_t n) { fGain->AddGainP(c,n);}       
    TArrayF GetGainP() {return fGain->GetGainP(); }
    Float_t GetGainP(Int_t n) {return fGain->GetGainP(n); }
    void AddGainN(Int_t c, Float_t n) { fGain->AddGainN(c,n);}
    TArrayF GetGainN() {return fGain->GetGainN(); }
    Float_t GetGainN(Int_t n) {return fGain->GetGainN(n); }
    void SetGain( AliITSGainSSD* gain) {fGain=gain;}

    void   SetBad() {
      fIsBad = kTRUE;
      for(Int_t i=0;i<fgkChipsPerModule;i++) fIsChipBad[i]=kTRUE;
    }
    virtual Bool_t IsBad() const { return fIsBad; }
    void   SetChipBad(Int_t nChip) {
      fIsChipBad[nChip] = kTRUE;
    }
    virtual Bool_t IsChipBad(Int_t nChip) const {
      return fIsChipBad[nChip];
    }
    Int_t ChipsPerModule() const{return fgkChipsPerModule;} // Number of chips/module
    Int_t ChannelsPerChip() const{ return fgkChannelsPerChip;}//Number of channels/chip

    TArrayI GetBadPChannelsList() { return fBadChannels->GetBadPChannelsList(); } const
    TArrayI GetBadNChannelsList() { return fBadChannels->GetBadNChannelsList(); } const
    void SetBadChannels( AliITSBadChannelsSSD* badchannels) {fBadChannels=badchannels;}
    Int_t GetBadPChannel(Int_t n) {return fBadChannels->GetBadPChannel(n); }
    Int_t GetBadNChannel(Int_t n) {return fBadChannels->GetBadNChannel(n); }
    Bool_t IsPChannelBad(Int_t n) {return fBadChannels->GetBadPChannel(n)&1; }
    Bool_t IsNChannelBad(Int_t n) {return fBadChannels->GetBadNChannel(n)&1; }

    void SetNoisePThreshold(Int_t threshold) { fNoisePThreshold = threshold;}
    void AddNoisyPChannel(Int_t c, Int_t n) { fNoisyPChannelsList.AddAt(n,c);}
    TArrayI GetNoisyPChannelsList() const {return fNoisyPChannelsList; }
    void SetNoiseNThreshold(Int_t threshold) { fNoiseNThreshold = threshold;}
    void AddNoisyNChannel(Int_t c, Int_t n) { fNoisyNChannelsList.AddAt(n,c);}
    TArrayI GetNoisyNChannelsList() const {return fNoisyNChannelsList; }

    void SetNDeadPChannelsList(Int_t n) { fDeadPChannelsList.Set(n); }
    void AddDeadPChannel(Int_t c, Int_t n) { fDeadPChannelsList.AddAt(n,c);}
    TArrayI GetDeadPChannelsList() const {return fDeadPChannelsList; }
    void SetNDeadNChannelsList(Int_t n) { fDeadNChannelsList.Set(n); }
    void AddDeadNChannel(Int_t c, Int_t n) { fDeadNChannelsList.AddAt(n,c);}
    TArrayI GetDeadNChannelsList() const {return fDeadNChannelsList; }
    //


    virtual  void   SetNDetParam(Int_t npar) {
	// set number of param
	fNPar=npar;
    }
    virtual  void   SetDetParam(Double_t *par);

    // Parameters options
    virtual Int_t   NDetParam() const {
	// number of param
	return fNPar;
    }
    virtual void    GetDetParam(Double_t *dpar) const; 

    virtual void    SetSigmaSpread(Double_t p1, Double_t p2) {
    	// Set sigmas of the charge spread function: Pside-Nside
    	// square of (microns)
    	fSigmaP=p1; fSigmaN=p2;
    }

    virtual void    SigmaSpread(Double_t &sP, Double_t &sN) const {
      // Get sigmas for the charge spread 
      sP=fSigmaP; sN=fSigmaN;
    }

    virtual void   SetThresholds(Double_t /* a */, Double_t /* b */)
      {NotImplemented("SetThresholds");}
    virtual void   Thresholds(Double_t & /* a */, Double_t & /* b */) const 
      {NotImplemented("Thresholds");}
  
    virtual void SetParamOptions(const char *opt1, const char *opt2) {((AliITSresponseSSD*)fResponse)->SetParamOptions(opt1,opt2);}
    virtual void GetParamOptions(char *opt1,char *opt2) const {((AliITSresponseSSD*)fResponse)->ParamOptions(opt1,opt2);}
    virtual void SetADCpereV(Double_t a=120./24888.9) {((AliITSresponseSSD*)fResponse)->SetADCpereV(a);}
    virtual Double_t GetDEvToADC(Double_t eV) const {return ((AliITSresponseSSD*)fResponse)->DEvToADC(eV);}
    virtual Int_t IEvToADC(Double_t eV) const {return ((AliITSresponseSSD*)fResponse)->IEvToADC(eV);} 

    virtual void SetKeVperADC(Double_t a=86.4/120.0) {((AliITSresponseSSD*)fResponse)->SetKeVperADC(a);}
    virtual Double_t ADCToKeV(Double_t adc) const {return ((AliITSresponseSSD*)fResponse)->ADCToKeV(adc);}

  virtual Double_t GetCouplingPR() const {return ((AliITSresponseSSD*)fResponse)->GetCouplingPR();}
  virtual Double_t GetCouplingPL() const {return ((AliITSresponseSSD*)fResponse)->GetCouplingPL();}
  virtual Double_t GetCouplingNR() const {return ((AliITSresponseSSD*)fResponse)->GetCouplingNR();}
  virtual Double_t GetCouplingNL() const {return ((AliITSresponseSSD*)fResponse)->GetCouplingNL();}
  virtual void SetCouplings(Double_t pr, Double_t pl, Double_t nr, Double_t nl) 
    { ((AliITSresponseSSD*)fResponse)->SetCouplings(pr,pl,nr,nl);}

  virtual Int_t GetZSThreshold() const {return ((AliITSresponseSSD*)fResponse)->GetZSThreshold();}
  virtual void SetZSThreshold(Int_t zsth) 
    { ((AliITSresponseSSD*)fResponse)->SetZSThreshold(zsth);}

protected:

    static const Int_t fgkChipsPerModule  = 12;    // Number of chips/module
    static const Int_t fgkChannelsPerChip = 128;   // Number of channels/chip

    static const Double_t fgkNoiseNDefault; // default for fNoiseN
    static const Double_t fgkNoisePDefault; // default for fNoiseP
    static const Int_t fgkNParDefault; // default for fNPar
    static const Double_t fgkSigmaPDefault; //default for fSigmaP
    static const Double_t fgkSigmaNDefault; //default for fSigmaP

    Int_t   fNPar;            // Number of detector param 
    Double_t *fDetPar;         //[fNPar] Array of parameters

    Double_t fNoiseP;          // Noise on Pside
    Double_t fNoiseN;          // Noise on Nside
    Double_t fSigmaP;          // Sigma charge spread on Pside
    Double_t fSigmaN;          // Sigma charge spread on Nside
    
    AliITSNoiseSSD *fNoise;
    AliITSPedestalSSD *fPedestal;
    AliITSGainSSD *fGain;
    AliITSBadChannelsSSD *fBadChannels;

    Bool_t   fIsBad;                         // module is dead or alive ?
    Bool_t   fIsChipBad[fgkChipsPerModule];  // chip is dead or alive ?

    TArrayF fGainP;           // Gain for P side channels
    TArrayF fGainN;           // Gain for N side channels

    TArrayF fNoisP;           // Noise for P side channels
    TArrayF fNoisN;           // Noise for N side channels

    TArrayF fPedP;
    TArrayF fPedN;

    Float_t fNoisePThreshold;     // need to decide if channel is noisy  
    TArrayI  fNoisyPChannelsList; // list of P side noisy channels
    Float_t fNoiseNThreshold;     // need to decide if channel is noisy  
    TArrayI  fNoisyNChannelsList; // list of N side noisy channels

    TArrayI  fDeadNChannelsList;  // list of P side dead channels
    TArrayI  fDeadPChannelsList;  // list of N side dead channels

 private:
    AliITSCalibrationSSD(const AliITSCalibrationSSD &source); // copy constructor
    AliITSCalibrationSSD& operator=(const AliITSCalibrationSSD &source); // ass. op.

    ClassDef(AliITSCalibrationSSD,3) //Response class for SSD
};
#endif
Commit	Line	Data
fcf95fc7	1	#ifndef ALIITSCALIBRATIONSSD_H
fcf95fc7	2	#define ALIITSCALIBRATIONSSD_H
b42cfa25	3	/* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
b42cfa25	4	* See cxx source for full Copyright notice */
fcf95fc7	5	#include "AliITSCalibration.h"
fb4dfab9	6	#include "AliITSNoiseSSD.h"
b42cfa25	7	#include "AliITSPedestalSSD.h"
fb4dfab9	8	#include "AliITSGainSSD.h"
fb4dfab9	9	#include "AliITSBadChannelsSSD.h"
fcf95fc7	10	#include "AliITSresponseSSD.h"
569a17d8	11	#include "TArrayF.h"
14a74335	12	#include "TArrayI.h"
fcf95fc7	13
b42cfa25	14	/* $Id$ */
fcf95fc7	15	//////////////////////////////////////////////
	16	// Response class for SSD //
	17	// //
	18	//////////////////////////////////////////////
	19	class AliITSCalibrationSSD : public AliITSCalibration {
	20
	21	public:
	22	AliITSCalibrationSSD();
	23	AliITSCalibrationSSD(const char *dataType);
	24	virtual ~AliITSCalibrationSSD();
14a74335	25
fcf95fc7	26	virtual void SetNoiseParam(Double_t np, Double_t nn) {
14a74335	27	// set noise par
14a74335	28	fNoiseP=np; fNoiseN=nn;
fcf95fc7	29	}
14a74335	30
fcf95fc7	31	virtual void GetNoiseParam(Double_t &np, Double_t &nn) const {
14a74335	32	// get noise par
14a74335	33	np=fNoiseP; nn=fNoiseN;
fcf95fc7	34	}
fcf95fc7	35
fb4dfab9	36	void AddNoiseP(Int_t c, Float_t n) { fNoise->AddNoiseP(c,n);}
	37	TArrayF GetNoiseP() {return fNoise->GetNoiseP(); }
	38	Float_t GetNoiseP(Int_t n) {return fNoise->GetNoiseP(n); }
	39	void AddNoiseN(Int_t c, Float_t n) { fNoise->AddNoiseN(c,n);}
	40	TArrayF GetNoiseN() {return fNoise->GetNoiseN(); }
	41	Float_t GetNoiseN(Int_t n) {return fNoise->GetNoiseN(n); }
	42	void SetNoise( AliITSNoiseSSD* noise) {fNoise=noise;}
	43
b42cfa25	44	void AddPedestalP(Int_t c, Float_t n) { fPedestal->AddPedestalP(c,n);}
	45	TArrayF GetPedestalP() {return fPedestal->GetPedestalP(); }
	46	Float_t GetPedestalP(Int_t n) {return fPedestal->GetPedestalP(n); }
	47	void AddPedestalN(Int_t c, Float_t n) { fPedestal->AddPedestalN(c,n);}
	48	TArrayF GetPedestalN() {return fPedestal->GetPedestalN(); }
	49	Float_t GetPedestalN(Int_t n) {return fPedestal->GetPedestalN(n); }
	50	void SetPedestal( AliITSPedestalSSD* pedestal) {fPedestal=pedestal;}
	51
fb4dfab9	52	void AddGainP(Int_t c, Float_t n) { fGain->AddGainP(c,n);}
	53	TArrayF GetGainP() {return fGain->GetGainP(); }
	54	Float_t GetGainP(Int_t n) {return fGain->GetGainP(n); }
	55	void AddGainN(Int_t c, Float_t n) { fGain->AddGainN(c,n);}
	56	TArrayF GetGainN() {return fGain->GetGainN(); }
	57	Float_t GetGainN(Int_t n) {return fGain->GetGainN(n); }
	58	void SetGain( AliITSGainSSD* gain) {fGain=gain;}
	59
df1d5598	60	void SetBad() {
	61	fIsBad = kTRUE;
	62	for(Int_t i=0;i<fgkChipsPerModule;i++) fIsChipBad[i]=kTRUE;
	63	}
	64	virtual Bool_t IsBad() const { return fIsBad; }
	65	void SetChipBad(Int_t nChip) {
	66	fIsChipBad[nChip] = kTRUE;
	67	}
	68	virtual Bool_t IsChipBad(Int_t nChip) const {
	69	return fIsChipBad[nChip];
	70	}
	71	Int_t ChipsPerModule() const{return fgkChipsPerModule;} // Number of chips/module
	72	Int_t ChannelsPerChip() const{ return fgkChannelsPerChip;}//Number of channels/chip
	73
ad2b76cb	74	TArrayI GetBadPChannelsList() { return fBadChannels->GetBadPChannelsList(); } const
ad2b76cb	75	TArrayI GetBadNChannelsList() { return fBadChannels->GetBadNChannelsList(); } const
fb4dfab9	76	void SetBadChannels( AliITSBadChannelsSSD* badchannels) {fBadChannels=badchannels;}
a64f9843	77	Int_t GetBadPChannel(Int_t n) {return fBadChannels->GetBadPChannel(n); }
	78	Int_t GetBadNChannel(Int_t n) {return fBadChannels->GetBadNChannel(n); }
	79	Bool_t IsPChannelBad(Int_t n) {return fBadChannels->GetBadPChannel(n)&1; }
	80	Bool_t IsNChannelBad(Int_t n) {return fBadChannels->GetBadNChannel(n)&1; }
14a74335	81
	82	void SetNoisePThreshold(Int_t threshold) { fNoisePThreshold = threshold;}
	83	void AddNoisyPChannel(Int_t c, Int_t n) { fNoisyPChannelsList.AddAt(n,c);}
	84	TArrayI GetNoisyPChannelsList() const {return fNoisyPChannelsList; }
	85	void SetNoiseNThreshold(Int_t threshold) { fNoiseNThreshold = threshold;}
	86	void AddNoisyNChannel(Int_t c, Int_t n) { fNoisyNChannelsList.AddAt(n,c);}
	87	TArrayI GetNoisyNChannelsList() const {return fNoisyNChannelsList; }
	88
	89	void SetNDeadPChannelsList(Int_t n) { fDeadPChannelsList.Set(n); }
	90	void AddDeadPChannel(Int_t c, Int_t n) { fDeadPChannelsList.AddAt(n,c);}
	91	TArrayI GetDeadPChannelsList() const {return fDeadPChannelsList; }
	92	void SetNDeadNChannelsList(Int_t n) { fDeadNChannelsList.Set(n); }
	93	void AddDeadNChannel(Int_t c, Int_t n) { fDeadNChannelsList.AddAt(n,c);}
	94	TArrayI GetDeadNChannelsList() const {return fDeadNChannelsList; }
	95	//
	96
	97
fcf95fc7	98	virtual void SetNDetParam(Int_t npar) {
	99	// set number of param
	100	fNPar=npar;
	101	}
	102	virtual void SetDetParam(Double_t *par);
	103
	104	// Parameters options
	105	virtual Int_t NDetParam() const {
	106	// number of param
	107	return fNPar;
	108	}
	109	virtual void GetDetParam(Double_t *dpar) const;
	110
	111	virtual void SetSigmaSpread(Double_t p1, Double_t p2) {
14a74335	112	// Set sigmas of the charge spread function: Pside-Nside
	113	// square of (microns)
	114	fSigmaP=p1; fSigmaN=p2;
fcf95fc7	115	}
14a74335	116
fcf95fc7	117	virtual void SigmaSpread(Double_t &sP, Double_t &sN) const {
14a74335	118	// Get sigmas for the charge spread
14a74335	119	sP=fSigmaP; sN=fSigmaN;
fcf95fc7	120	}
	121
	122	virtual void SetThresholds(Double_t /* a /, Double_t / b */)
	123	{NotImplemented("SetThresholds");}
	124	virtual void Thresholds(Double_t & /* a /, Double_t & / b */) const
	125	{NotImplemented("Thresholds");}
	126
	127	virtual void SetParamOptions(const char opt1, const char opt2) {((AliITSresponseSSD*)fResponse)->SetParamOptions(opt1,opt2);}
	128	virtual void GetParamOptions(char opt1,char opt2) const {((AliITSresponseSSD*)fResponse)->ParamOptions(opt1,opt2);}
9acf2ecc	129	virtual void SetADCpereV(Double_t a=120./24888.9) {((AliITSresponseSSD*)fResponse)->SetADCpereV(a);}
fcf95fc7	130	virtual Double_t GetDEvToADC(Double_t eV) const {return ((AliITSresponseSSD*)fResponse)->DEvToADC(eV);}
	131	virtual Int_t IEvToADC(Double_t eV) const {return ((AliITSresponseSSD*)fResponse)->IEvToADC(eV);}
	132
9acf2ecc	133	virtual void SetKeVperADC(Double_t a=86.4/120.0) {((AliITSresponseSSD*)fResponse)->SetKeVperADC(a);}
	134	virtual Double_t ADCToKeV(Double_t adc) const {return ((AliITSresponseSSD*)fResponse)->ADCToKeV(adc);}
	135
14a74335	136	virtual Double_t GetCouplingPR() const {return ((AliITSresponseSSD*)fResponse)->GetCouplingPR();}
	137	virtual Double_t GetCouplingPL() const {return ((AliITSresponseSSD*)fResponse)->GetCouplingPL();}
	138	virtual Double_t GetCouplingNR() const {return ((AliITSresponseSSD*)fResponse)->GetCouplingNR();}
	139	virtual Double_t GetCouplingNL() const {return ((AliITSresponseSSD*)fResponse)->GetCouplingNL();}
	140	virtual void SetCouplings(Double_t pr, Double_t pl, Double_t nr, Double_t nl)
	141	{ ((AliITSresponseSSD*)fResponse)->SetCouplings(pr,pl,nr,nl);}
	142
	143	virtual Int_t GetZSThreshold() const {return ((AliITSresponseSSD*)fResponse)->GetZSThreshold();}
	144	virtual void SetZSThreshold(Int_t zsth)
	145	{ ((AliITSresponseSSD*)fResponse)->SetZSThreshold(zsth);}
	146
	147	protected:
df1d5598	148
	149	static const Int_t fgkChipsPerModule = 12; // Number of chips/module
	150	static const Int_t fgkChannelsPerChip = 128; // Number of channels/chip
	151
fcf95fc7	152	static const Double_t fgkNoiseNDefault; // default for fNoiseN
	153	static const Double_t fgkNoisePDefault; // default for fNoiseP
	154	static const Int_t fgkNParDefault; // default for fNPar
	155	static const Double_t fgkSigmaPDefault; //default for fSigmaP
	156	static const Double_t fgkSigmaNDefault; //default for fSigmaP
14a74335	157
fcf95fc7	158	Int_t fNPar; // Number of detector param
	159	Double_t *fDetPar; //[fNPar] Array of parameters
	160
	161	Double_t fNoiseP; // Noise on Pside
	162	Double_t fNoiseN; // Noise on Nside
fcf95fc7	163	Double_t fSigmaP; // Sigma charge spread on Pside
	164	Double_t fSigmaN; // Sigma charge spread on Nside
	165
fb4dfab9	166	AliITSNoiseSSD *fNoise;
b42cfa25	167	AliITSPedestalSSD *fPedestal;
fb4dfab9	168	AliITSGainSSD *fGain;
	169	AliITSBadChannelsSSD *fBadChannels;
	170
df1d5598	171	Bool_t fIsBad; // module is dead or alive ?
	172	Bool_t fIsChipBad[fgkChipsPerModule]; // chip is dead or alive ?
	173
569a17d8	174	TArrayF fGainP; // Gain for P side channels
569a17d8	175	TArrayF fGainN; // Gain for N side channels
14a74335	176
569a17d8	177	TArrayF fNoisP; // Noise for P side channels
569a17d8	178	TArrayF fNoisN; // Noise for N side channels
14a74335	179
b42cfa25	180	TArrayF fPedP;
	181	TArrayF fPedN;
	182
569a17d8	183	Float_t fNoisePThreshold; // need to decide if channel is noisy
14a74335	184	TArrayI fNoisyPChannelsList; // list of P side noisy channels
569a17d8	185	Float_t fNoiseNThreshold; // need to decide if channel is noisy
14a74335	186	TArrayI fNoisyNChannelsList; // list of N side noisy channels
	187
	188	TArrayI fDeadNChannelsList; // list of P side dead channels
	189	TArrayI fDeadPChannelsList; // list of N side dead channels
	190
fcf95fc7	191	private:
	192	AliITSCalibrationSSD(const AliITSCalibrationSSD &source); // copy constructor
	193	AliITSCalibrationSSD& operator=(const AliITSCalibrationSSD &source); // ass. op.
	194
df1d5598	195	ClassDef(AliITSCalibrationSSD,3) //Response class for SSD
fcf95fc7	196	};
fcf95fc7	197	#endif