/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * *
+ * *
* Author: The ALICE Off-line Project. *
* Contributors are mentioned in the code where appropriate. *
* *
#include "AliITSBadChannelsSSD.h"
-ClassImp(AliITSBadChannelsSSD)
+//////////////////////////////////////////////////////
+// Author: Enrico Fragiacomo
+// Date: 23/08/2007
+// Modified: 08/07/2008
+// //
+//////////////////////////////////////////////////////
+//const Int_t AliITSBadChannelsSSD::fgkDefaultNModulesSSD = 1698;
+//const Int_t AliITSBadChannelsSSD::fgkDefaultNStripsSSD = 768;
+
+ClassImp(AliITSBadChannelsSSD)
+
//______________________________________________________________________
-AliITSBadChannelsSSD::AliITSBadChannelsSSD():
-fMod(0),
-fBadNChannelsList(0),
-fBadPChannelsList(0){
- // Default Constructor
+ AliITSBadChannelsSSD::AliITSBadChannelsSSD()
+ // Default Constructor
+{
+ for(Int_t i=0; i<2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD; i++)
+ fBadChannels[i]=0;
+ }
+//______________________________________________________________________
+AliITSBadChannelsSSD::AliITSBadChannelsSSD(const AliITSBadChannelsSSD &source):
+ TObject(source)
+{
+ // copy Constructor
+ memcpy(fBadChannels,source.fBadChannels,
+ 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Char_t));
}
//______________________________________________________________________
AliITSBadChannelsSSD::~AliITSBadChannelsSSD(){
// destructor
-
}
+//______________________________________________________________________
+AliITSBadChannelsSSD& AliITSBadChannelsSSD::operator=(const AliITSBadChannelsSSD &source) {
+ // ass. op.
+ if (this == &source)return *this;
+ memcpy(fBadChannels,source.fBadChannels,
+ 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Char_t));
+
+ return *this;
+}
#ifndef ALIITSBADCHANNELSSSD_H
#define ALIITSBADCHANNELSSSD_H
-#include "TObjArray.h"
-#include "TArrayI.h"
-
//////////////////////////////////////////////
-// Response class for SSD //
+// Author: Enrico Fragiacomo
+// Date: 23/08/2007
+// Modified: 08/07/2008
// //
//////////////////////////////////////////////
+#include "TObject.h"
+
class AliITSBadChannelsSSD : public TObject {
public:
+
AliITSBadChannelsSSD();
virtual ~AliITSBadChannelsSSD();
+ AliITSBadChannelsSSD(const AliITSBadChannelsSSD &source); // copy constructor
+ AliITSBadChannelsSSD& operator=(const AliITSBadChannelsSSD &source); // ass. op.
- void SetNBadPChannelsList(Int_t n) { fBadPChannelsList.Set(n); }
- void AddBadPChannel(Int_t c, Int_t n) { fBadPChannelsList.AddAt(n,c);}
- TArrayI GetBadPChannelsList() const {return fBadPChannelsList; }
- Int_t GetBadPChannel(Int_t n) {return fBadPChannelsList.At(n); }
- void SetNBadNChannelsList(Int_t n) { fBadNChannelsList.Set(n); }
- void AddBadNChannel(Int_t c, Int_t n) { fBadNChannelsList.AddAt(n,c);}
- TArrayI GetBadNChannelsList() const {return fBadNChannelsList; }
- Int_t GetBadNChannel(Int_t n) {return fBadNChannelsList.At(n); }
- //
+ void AddBadChannelP(Int_t module, Int_t strip, Char_t value) {
+ fBadChannels[module*2*fgkDefaultNStripsSSD+strip] = value;
+ }
+ Char_t GetBadChannelP(Int_t module, Int_t strip) {
+ return fBadChannels[module*2*fgkDefaultNStripsSSD+strip];
+ }
- void SetMod(UShort_t mod) {fMod = mod;}
- UShort_t GetMod() { return fMod;}
+ void AddBadChannelN(Int_t module, Int_t strip, Char_t value) {
+ fBadChannels[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip] = value;
+ }
+ Char_t GetBadChannelN(Int_t module, Int_t strip) {
+ return fBadChannels[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip];
+ }
protected:
- UShort_t fMod; // module number (from 0 to 1535). Needed by the preprocessor to
- // extract the information from the Detector Algorithm
-
- TArrayI fBadNChannelsList; // list of P side dead channels
- TArrayI fBadPChannelsList; // list of N side dead channels
-
+ static const Int_t fgkDefaultNModulesSSD = 1698;
+ static const Int_t fgkDefaultNStripsSSD = 768;
+ //static const Int_t fgkDefaultNModulesSSD; // Total numbers of SSD modules
+ // static const Int_t fgkDefaultNStripsSSD; // Total numbers of SSD modules
+ Char_t fBadChannels[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD];
+ // Char_t *fBadChannels;
+
private:
- AliITSBadChannelsSSD(const AliITSBadChannelsSSD &source); // copy constructor
- AliITSBadChannelsSSD& operator=(const AliITSBadChannelsSSD &source); // ass. op.
+
+ ClassDef(AliITSBadChannelsSSD,1) // BadChannels class for SSD
+ };
- ClassDef(AliITSBadChannelsSSD,1) //Response class for SSD
-};
#endif
// //
//////////////////////////////////////////////////////
-const Double_t AliITSCalibrationSSD::fgkNoiseNDefault = 625.;
-const Double_t AliITSCalibrationSSD::fgkNoisePDefault = 420.;
const Int_t AliITSCalibrationSSD::fgkNParDefault = 6;
-const Double_t AliITSCalibrationSSD::fgkSigmaPDefault = 3.;
-const Double_t AliITSCalibrationSSD::fgkSigmaNDefault = 2.;
ClassImp(AliITSCalibrationSSD)
//______________________________________________________________________
AliITSCalibrationSSD::AliITSCalibrationSSD():
+ fModule(0),
fNPar(0),
fDetPar(0),
-fNoiseP(0),
-fNoiseN(0),
-fSigmaP(0),
-fSigmaN(0),
fNoise(0),
fPedestal(),
fGain(0),
fBadChannels(0),
-fIsBad(kFALSE),
-fGainP(0),
-fGainN(0),
-fNoisP(0),
-fNoisN(0),
-fPedP(),
-fPedN(),
-fNoisePThreshold(0),
-fNoisyPChannelsList(0),
-fNoiseNThreshold(0),
-fNoisyNChannelsList(0),
-fDeadNChannelsList(0),
-fDeadPChannelsList(0){
+fIsBad(kFALSE){
// Default Constructor
- SetNoiseParam(fgkNoisePDefault,fgkNoiseNDefault);
for(Int_t i=0;i<fgkChipsPerModule;i++){
fIsChipBad[i]=kFALSE;
}
}
//______________________________________________________________________
AliITSCalibrationSSD::AliITSCalibrationSSD(const char *dataType):
+ fModule(0),
fNPar(0),
fDetPar(0),
-fNoiseP(0),
-fNoiseN(0),
-fSigmaP(0),
-fSigmaN(0),
fNoise(0),
fPedestal(0),
fGain(0),
fBadChannels(0),
-fIsBad(kFALSE),
-fGainP(0),
-fGainN(0),
-fNoisP(0),
-fNoisN(0),
-fPedP(0),
-fPedN(0),
-fNoisePThreshold(0),
-fNoisyPChannelsList(0),
-fNoiseNThreshold(0),
-fNoisyNChannelsList(0),
-fDeadNChannelsList(0),
-fDeadPChannelsList(0){
+fIsBad(kFALSE){
// constructor
- SetNoiseParam(fgkNoisePDefault,fgkNoiseNDefault);
SetDataType(dataType);
- SetSigmaSpread(fgkSigmaPDefault,fgkSigmaNDefault);
SetNDetParam(fgkNParDefault); // Sets fNPar=6 by default.
fDetPar = new Double_t[fNPar];
if (fNPar==6) {
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;
- }
+ virtual void SetNoiseParam(Double_t , Double_t ) {
+ NotImplemented("SetNoiseParam");}
+
+ virtual void GetNoiseParam(Double_t &, Double_t &) const {
+ NotImplemented("SetNoiseParam");}
- 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); }
+ Float_t GetNoiseP(Int_t n) {return fNoise->GetNoiseP(fModule,n); }
+ Float_t GetNoiseN(Int_t n) {return fNoise->GetNoiseN(fModule,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); }
+ Float_t GetPedestalP(Int_t n) {return fPedestal->GetPedestalP(fModule,n); }
+ Float_t GetPedestalN(Int_t n) {return fPedestal->GetPedestalN(fModule,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); }
+ Float_t GetGainP(Int_t n) {return fGain->GetGainP(fModule,n); }
+ Float_t GetGainN(Int_t n) {return fGain->GetGainN(fModule,n); }
+ void SetGainP(Int_t n, Float_t value) {fGain->AddGainP(fModule,n,value);}
+ void SetGainN(Int_t n, Float_t value) {fGain->AddGainN(fModule,n,value);}
void SetGain( AliITSGainSSD* gain) {fGain=gain;}
void SetBad() {
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; }
- //
-
+ Int_t ChipsPerModule() const{return fgkChipsPerModule;} // # chips/module
+ Int_t ChannelsPerChip() const{ return fgkChannelsPerChip;}// #channels/chip
+
+ void SetBadChannels( AliITSBadChannelsSSD* badchannels) {
+ fBadChannels=badchannels;}
+ Char_t GetBadPChannel(Int_t n) {
+ return fBadChannels->GetBadChannelP(fModule,n); }
+ Char_t GetBadNChannel(Int_t n) {
+ return fBadChannels->GetBadChannelN(fModule,n); }
+ Bool_t IsPChannelBad(Int_t n) {
+ return fBadChannels->GetBadChannelP(fModule,n)&1; }
+ Bool_t IsNChannelBad(Int_t n) {
+ return fBadChannels->GetBadChannelN(fModule,n)&1; }
+ //
virtual void SetNDetParam(Int_t npar) {
// set number of param
fNPar=npar;
}
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 SetSigmaSpread(Double_t, Double_t) {
+ NotImplemented("SetSigmaSpread");}
+
+ virtual void SigmaSpread(Double_t &, Double_t &) const {
+ NotImplemented("SetSigmaSpread");}
+
+
virtual void SetThresholds(Double_t /* a */, Double_t /* b */)
{NotImplemented("SetThresholds");}
virtual void Thresholds(Double_t & /* a */, Double_t & /* b */) const
virtual void SetZSThreshold(Int_t zsth)
{ ((AliITSresponseSSD*)fResponse)->SetZSThreshold(zsth);}
+ void SetModule(Int_t mod){fModule = mod;}
+
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 fModule; //! module number (range 0 -> 1697)
+
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;
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
noise = cal->GetNoiseP(istrip); if(noise<1.) signal = 65535;
if(signal<3*noise) signal = 65535; // in case ZS was not done in hw do it now
- // if(cal->IsPChannelB ad(istrip)) signal=0;
+ // if(cal->IsPChannelBad(istrip)) signal=0;
if (signal!=65535) {
gain = cal->GetGainP(istrip);
fReconstruction(0),
fSegmentation(0),
fCalibration(0),
+fSSDCalibration(0),
fSPDDead(0),
fPreProcess(0),
fPostProcess(0),
fDigClassName[i]=0;
fRecPointClassName[i]=0;
}
+ fSSDCalibration=new AliITSCalibrationSSD();
fNdtype = new Int_t[fgkNdettypes];
fCtype = new TObjArray(fgkNdettypes);
fNctype = new Int_t[fgkNdettypes];
fReconstruction(rec.fReconstruction),
fSegmentation(rec.fSegmentation),
fCalibration(rec.fCalibration),
+fSSDCalibration(rec.fSSDCalibration),
fSPDDead(rec.fSPDDead),
fPreProcess(rec.fPreProcess),
fPostProcess(rec.fPostProcess),
if(fDDLMapSDD) delete fDDLMapSDD;
}
}
- if(fSPDDead){
+ if(fSSDCalibration) delete fSSDCalibration;
+ if(fSPDDead){
if(!(AliCDBManager::Instance()->GetCacheFlag())) {
fSPDDead->Delete();
delete fSPDDead;
return 0;
}
- return (AliITSCalibration*)fCalibration->At(iMod);
+ if(iMod<fgkDefaultNModulesSPD+fgkDefaultNModulesSDD){
+ return (AliITSCalibration*)fCalibration->At(iMod);
+ }else{
+ Int_t i=iMod-(fgkDefaultNModulesSPD+fgkDefaultNModulesSDD);
+ fSSDCalibration->SetModule(i);
+ return (AliITSCalibration*)fSSDCalibration;
+ }
+
}
//_______________________________________________________________________
AliITSCalibration* AliITSDetTypeRec::GetSPDDeadModel(Int_t iMod){
if(!cacheStatus)mapTSDD->SetObject(NULL);
mapTSDD->SetOwner(kTRUE);
- TObjArray *noiseSSD = (TObjArray *)entryNoiseSSD->GetObject();
+ AliITSNoiseSSD *noiseSSD = (AliITSNoiseSSD *)entryNoiseSSD->GetObject();
if(!cacheStatus)entryNoiseSSD->SetObject(NULL);
entryNoiseSSD->SetOwner(kTRUE);
- TObjArray *pedestalSSD = (TObjArray *)entryPedestalSSD->GetObject();
+ AliITSPedestalSSD *pedestalSSD =
+ (AliITSPedestalSSD*)entryPedestalSSD->GetObject();
if(!cacheStatus)entryPedestalSSD->SetObject(NULL);
entryPedestalSSD->SetOwner(kTRUE);
- TObjArray *gainSSD = (TObjArray *)entryGainSSD->GetObject();
+ AliITSGainSSD *gainSSD = (AliITSGainSSD *)entryGainSSD->GetObject();
if(!cacheStatus)entryGainSSD->SetObject(NULL);
entryGainSSD->SetOwner(kTRUE);
- TObjArray *badchannelsSSD = (TObjArray *)entryBadChannelsSSD->GetObject();
+ AliITSBadChannelsSSD *badchannelsSSD =
+ (AliITSBadChannelsSSD*)entryBadChannelsSSD->GetObject();
if(!cacheStatus)entryBadChannelsSSD->SetObject(NULL);
entryBadChannelsSSD->SetOwner(kTRUE);
fNMod[0] = calSPD->GetEntries();
fNMod[1] = calSDD->GetEntries();
- fNMod[2] = noiseSSD->GetEntries();
+ //fNMod[2] = noiseSSD->GetEntries();
AliInfo(Form("%i SPD, %i SDD and %i SSD in calibration database",
fNMod[0], fNMod[1], fNMod[2]));
AliITSCalibration* cal;
SetCalibrationModel(iMod, cal);
}
}
+
+ fSSDCalibration->SetResponse((AliITSresponse*)pSSD);
+ fSSDCalibration->SetNoise(noiseSSD);
+ fSSDCalibration->SetPedestal(pedestalSSD);
+ fSSDCalibration->SetGain(gainSSD);
+ fSSDCalibration->SetBadChannels(badchannelsSSD);
+ //fSSDCalibration->FillBadChipMap();
+
+
+ /*
for (Int_t i=0; i<fNMod[2]; i++) {
AliITSCalibrationSSD *calibSSD = new AliITSCalibrationSSD();
Int_t iMod = i + fgkDefaultNModulesSPD + fgkDefaultNModulesSDD;
SetCalibrationModel(iMod, calibSSD);
}
+ */
return kTRUE;
}
#include "AliITSDDLModuleMapSDD.h"
#include "AliITSresponseSDD.h"
#include "AliITSgeom.h"
-
class TTree;
class TBranch;
class AliITSsegmentation;
class AliITSCalibration;
+class AliITSCalibrationSSD;
class AliITSresponseSDD;
class AliITSClusterFinder;
class AliITSRawCluster;
TObjArray *fReconstruction;//! [NDet]
TObjArray *fSegmentation; //! [NDet]
TObjArray *fCalibration; //! [NMod]
+ AliITSCalibrationSSD* fSSDCalibration; //! SSD calibration object
TObjArray *fSPDDead; //! [fgkDefaultNModulesSPD]
TObjArray *fPreProcess; //! [] e.g. Find Calibration values
TObjArray *fPostProcess; //! [] e.g. find primary vertex
fSimulation(), // [NDet]
fSegmentation(), // [NDet]
fCalibration(), // [NMod]
+fSSDCalibration(0),
fPreProcess(), // [] e.g. Fill fHitModule with hits
fPostProcess(), // [] e.g. Wright Raw data
fNSDigits(0), //! number of SDigits
fNDigits = new Int_t[fgkNdettypes];
fDDLMapSDD=new AliITSDDLModuleMapSDD();
fSimuPar= new AliITSSimuParam();
+ fSSDCalibration=new AliITSCalibrationSSD();
fNMod[0] = fgkDefaultNModulesSPD;
fNMod[1] = fgkDefaultNModulesSDD;
fNMod[2] = fgkDefaultNModulesSSD;
delete fCalibration;
}
fCalibration = 0;
- if(fPreProcess){
+ if(fSSDCalibration) delete fSSDCalibration;
+ if(fPreProcess){
fPreProcess->Delete();
delete fPreProcess;
}
fSimulation(source.fSimulation), // [NDet]
fSegmentation(source.fSegmentation), // [NDet]
fCalibration(source.fCalibration), // [NMod]
+fSSDCalibration(source.fSSDCalibration),
fPreProcess(source.fPreProcess), // [] e.g. Fill fHitModule with hits
fPostProcess(source.fPostProcess), // [] e.g. Wright Raw data
fNSDigits(source.fNSDigits), //! number of SDigits
AliError("fCalibration is 0!");
return 0;
}
- return (AliITSCalibration*)(fCalibration->At(iMod));
+ if(iMod<fgkDefaultNModulesSPD+fgkDefaultNModulesSDD){
+ return (AliITSCalibration*)fCalibration->At(iMod);
+ }else{
+ Int_t i=iMod-(fgkDefaultNModulesSPD+fgkDefaultNModulesSDD);
+ fSSDCalibration->SetModule(i);
+ return (AliITSCalibration*)fSSDCalibration;
+ }
+
}
//_______________________________________________________________________
void AliITSDetTypeSim::SetDefaults(){
entrySSD->SetOwner(kTRUE);
*/
- TObjArray *noiseSSD = (TObjArray *)entryNoiseSSD->GetObject();
+ AliITSNoiseSSD *noiseSSD = (AliITSNoiseSSD *)entryNoiseSSD->GetObject();
if(!isCacheActive)entryNoiseSSD->SetObject(NULL);
entryNoiseSSD->SetOwner(kTRUE);
- TObjArray *gainSSD = (TObjArray *)entryGainSSD->GetObject();
+ AliITSGainSSD *gainSSD = (AliITSGainSSD *)entryGainSSD->GetObject();
if(!isCacheActive)entryGainSSD->SetObject(NULL);
entryGainSSD->SetOwner(kTRUE);
- TObjArray *badchannelsSSD = (TObjArray *)entryBadChannelsSSD->GetObject();
+ AliITSBadChannelsSSD *badchannelsSSD =
+ (AliITSBadChannelsSSD *)entryBadChannelsSSD->GetObject();
if(!isCacheActive)entryBadChannelsSSD->SetObject(NULL);
entryBadChannelsSSD->SetOwner(kTRUE);
fNMod[0] = calSPD->GetEntries();
fNMod[1] = calSDD->GetEntries();
- fNMod[2] = noiseSSD->GetEntries();
+ // fNMod[2] = noiseSSD->GetEntries();
AliInfo(Form("%i SPD, %i SDD and %i SSD in calibration database",
fNMod[0], fNMod[1], fNMod[2]));
AliITSCalibration* cal;
}
}
+ fSSDCalibration->SetResponse((AliITSresponse*)pSSD);
+ fSSDCalibration->SetNoise(noiseSSD);
+ fSSDCalibration->SetGain(gainSSD);
+ fSSDCalibration->SetBadChannels(badchannelsSSD);
+ //fSSDCalibration->FillBadChipMap();
+
+
+ /*
for (Int_t i=0; i<fNMod[2]; i++) {
AliITSCalibrationSSD *calibSSD = new AliITSCalibrationSSD();
calibSSD->SetResponse((AliITSresponse*)pSSD);
Int_t iMod = i + fgkDefaultNModulesSPD + fgkDefaultNModulesSDD;
SetCalibrationModel(iMod, calibSSD);
- }
+ }
+ */
+
+
return kTRUE;
}
//_______________________________________________________________________
//////////////////////////////////////////////////////
// Author: Enrico Fragiacomo
// Date: 23/08/2007
+// Modified: 08/07/2008
// //
//////////////////////////////////////////////////////
+//const Int_t AliITSGainSSD::fgkDefaultNModulesSSD = 1698;
+//const Int_t AliITSGainSSD::fgkDefaultNStripsSSD = 768;
+
ClassImp(AliITSGainSSD)
+
+//______________________________________________________________________
+ AliITSGainSSD::AliITSGainSSD()
+{
+ // Default Constructor
+ for(Int_t i=0; i<2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD; i++)
+ fGain[i]=0;
+}
//______________________________________________________________________
-AliITSGainSSD::AliITSGainSSD():
-fMod(0),
-fGainP(0),
-fGainN(0) {
- // Default Constructor
+AliITSGainSSD::AliITSGainSSD(const AliITSGainSSD &source):
+ TObject(source)
+{
+ // copy Constructor
+ memcpy(fGain,source.fGain,
+ 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(UShort_t));
}
//______________________________________________________________________
}
+//______________________________________________________________________
+AliITSGainSSD& AliITSGainSSD::operator=(const AliITSGainSSD &source) {
+ // ass. op.
+ if (this == &source)return *this;
+
+ memcpy(fGain,source.fGain,
+ 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(UShort_t));
+
+ return *this;
+}
#ifndef ALIITSGAINSSD_H
#define ALIITSGAINSSD_H
-#include "TObjArray.h"
-#include "TArrayF.h"
-
//////////////////////////////////////////////
// Author: Enrico Fragiacomo
// Date: 23/08/2007
+// Modified: 08/07/2008
// //
//////////////////////////////////////////////
+#include "TObject.h"
+
class AliITSGainSSD : public TObject {
public:
AliITSGainSSD();
virtual ~AliITSGainSSD();
-
- void SetNGainP(Int_t n) { fGainP.Set(n); }
- void AddGainP(Int_t c, Float_t n) { fGainP.AddAt(n,c);}
- TArrayF GetGainP() const {return fGainP; }
- Float_t GetGainP(Int_t n) {return fGainP.At(n); }
- void SetNGainN(Int_t n) { fGainN.Set(n); }
- void AddGainN(Int_t c, Float_t n) { fGainN.AddAt(n,c);}
- TArrayF GetGainN() const {return fGainN; }
- Float_t GetGainN(Int_t n) {return fGainN.At(n); }
-
- void SetMod(UShort_t mod) {fMod = mod;}
- UShort_t GetMod() { return fMod;}
-
-protected:
-
- UShort_t fMod; // module number (from 0 to 1535). Needed by the preprocessor to
- // extract the information from the Detector Algorithm
-
- TArrayF fGainP; // Gain for P side channels
- TArrayF fGainN; // Gain for N side channels
-
- private:
AliITSGainSSD(const AliITSGainSSD &source); // copy constructor
AliITSGainSSD& operator=(const AliITSGainSSD &source); // ass. op.
- ClassDef(AliITSGainSSD,1) //Response class for SSD
-};
+ void AddGainP(Int_t module, Int_t strip, Float_t value) {
+ fGain[module*2*fgkDefaultNStripsSSD+strip] = (UShort_t) (1000.*value);
+ }
+ Float_t GetGainP(Int_t module, Int_t strip) {
+ return ((Float_t) ( (Float_t) fGain[module*2*fgkDefaultNStripsSSD+strip] ) /1000.);
+ }
+
+ void AddGainN(Int_t module, Int_t strip, Float_t value) {
+ fGain[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip] =
+ (UShort_t) (1000.*value);
+ }
+ Float_t GetGainN(Int_t module, Int_t strip) {
+ return ( (Float_t) ((Float_t) fGain[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip])/1000.);
+ }
+
+ protected:
+
+ static const Int_t fgkDefaultNModulesSSD = 1698;
+ static const Int_t fgkDefaultNStripsSSD = 768;
+
+ //static const Int_t fgkDefaultNModulesSSD; // Total numbers of SSD modules
+ //static const Int_t fgkDefaultNStripsSSD; // Total numbers of SSD modules
+
+ UShort_t fGain[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD];
+ // UShort_t *fGain;
+
+ private:
+
+ ClassDef(AliITSGainSSD,1) // Gain class for SSD
+ };
#endif
Int_t AliITSHandleDaSSD::ChannelIsBad(const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const
{
// Check if the channel is bad
- AliITSBadChannelsSSD *badch = NULL;
- TArrayI bcharray;
- Int_t strsiden, modn = -1;
+// AliITSBadChannelsSSD *badch = NULL;
+ // TArrayI bcharray;
+ // Int_t strsiden;
+ Int_t modn = -1;
if (fStaticBadChannelsMap && fDDLModuleMap) {
modn = RetrieveModuleId(ddl, ad, adc);
+
+ /*
if (modn < 0) return -1;
Int_t modind = 0;
while ((modind < fStaticBadChannelsMap->GetEntriesFast() && (!badch))) {
}
} else {
AliError("Error ether bad channels list or DDLMap is not initialized or both, return 0!");
+
+ */
return 0;
}
+ return 0;
}
// Calculate the offset value to be upload to FEROM
AliITSChannelDaSSD *strip = NULL;
AliITSModuleDaSSD *module = NULL;
- if (module = GetModule(ddl, ad, adc)) {
- if (strip = module->GetStrip(strn)) return OffsetValue(strip, ddl, ad, adc, strn);
+ if ((module = GetModule(ddl, ad, adc))) {
+ if ((strip = module->GetStrip(strn))) return OffsetValue(strip, ddl, ad, adc, strn);
else {
AliWarning(Form("There is no calibration data for ddl = %i, ad = %i, adc = %i, strip = %i, 0 is used!", ddl, ad, adc, strn));
return 0ul;
// Calculate the value of zero suppression threshold to be upload to FEROM, account bad channels list
AliITSChannelDaSSD *strip = NULL;
AliITSModuleDaSSD *module = NULL;
- if (ChannelIsBad(ddl, ad, adc, strn)) return fgkZsBitMask;
- if (module = GetModule(ddl, ad, adc)) {
- if (strip = module->GetStrip(strn)) return ZsThreshold(strip);
+ if ((ChannelIsBad(ddl, ad, adc, strn))) return fgkZsBitMask;
+ if ((module = GetModule(ddl, ad, adc))) {
+ if ((strip = module->GetStrip(strn))) return ZsThreshold(strip);
else {
AliWarning(Form("There is no calibration data for ddl = %i, ad = %i, adc = %i, strip = %i, 0 is used!", ddl, ad, adc, strn));
return 0ul;
{
// Creates the AliITSNoiseSSD objects with callibration data
AliITSNoiseSSD *mc;
- Float_t noise;
+ // Float_t noise;
if (!fStrips) return NULL;
mc = new AliITSNoiseSSD();
+
+ /*
mc->SetMod(fModuleId);
mc->SetNNoiseP(fgkPNStripsPerModule);
mc->SetNNoiseN(fgkPNStripsPerModule);
mc->AddNoiseP(i, noise);
else mc->AddNoiseN((AliITSChannelDaSSD::GetMaxStripIdConst() - i), noise);
}
+ */
+
return mc;
}
{
// Creates the AliITSPedestalSSD objects with callibration data
AliITSPedestalSSD *mc;
- Float_t ped;
+ // Float_t ped;
if (!fStrips) return NULL;
mc = new AliITSPedestalSSD();
+
+ /*
mc->SetMod(fModuleId);
mc->SetNPedestalP(fgkPNStripsPerModule);
mc->SetNPedestalN(fgkPNStripsPerModule);
mc->AddPedestalP(i, ped);
else mc->AddPedestalN((AliITSChannelDaSSD::GetMaxStripIdConst() - i), ped);
}
+ */
+
return mc;
}
{ chlist[nch++] = i; if (i < fgkPNStripsPerModule) nchp++; else nchn++; }
}
mc = new AliITSBadChannelsSSD();
+
+ /*
mc->SetMod(fModuleId);
if (!nch) return mc;
mc->SetNBadPChannelsList(nchp);
if (chlist[i] < fgkPNStripsPerModule) mc->AddBadPChannel(chlist[i], i);
else mc->AddBadNChannel((AliITSChannelDaSSD::GetMaxStripIdConst() - chlist[i]), (i-nchp));
}
+ */
+
return mc;
}
//////////////////////////////////////////////////////
// Author: Enrico Fragiacomo
// Date: 23/08/2007
+// Modified: 08/07/2008
// //
//////////////////////////////////////////////////////
-ClassImp(AliITSNoiseSSD)
+//const Int_t AliITSNoiseSSD::fgkDefaultNModulesSSD = 1698;
+//const Int_t AliITSNoiseSSD::fgkDefaultNStripsSSD = 768;
+ClassImp(AliITSNoiseSSD)
+
//______________________________________________________________________
-AliITSNoiseSSD::AliITSNoiseSSD():
-fMod(0),
-fNoisP(0),
-fNoisN(0) {
- // Default Constructor
+ AliITSNoiseSSD::AliITSNoiseSSD() {
+ // Default Constructor
+ for(Int_t i=0; i<2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD; i++)
+ fNois[i]=0;
}
//______________________________________________________________________
-AliITSNoiseSSD::AliITSNoiseSSD(const AliITSNoiseSSD &source): TObject(source),
-fMod(source.fMod),
-fNoisP(source.fNoisP),
-fNoisN(source.fNoisN) {
+AliITSNoiseSSD::AliITSNoiseSSD(const AliITSNoiseSSD &source):
+ TObject(source)
+{
// copy Constructor
+ memcpy(fNois,source.fNois,
+ 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Float_t));
}
+
//______________________________________________________________________
AliITSNoiseSSD::~AliITSNoiseSSD(){
// destructor
// ass. op.
if (this == &source)
return *this;
- fMod = source.fMod;
- fNoisP = source.fMod;
- fNoisN = source.fMod;
+
+ memcpy(fNois,source.fNois,
+ 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Float_t));
+
return *this;
}
#ifndef ALIITSNOISESSD_H
#define ALIITSNOISESSD_H
-#include "TObjArray.h"
-#include "TArrayF.h"
-
//////////////////////////////////////////////
// Author: Enrico Fragiacomo
// Date: 23/08/2007
+// Modified: 08/07/2008
// //
//////////////////////////////////////////////
+#include "TObject.h"
+
class AliITSNoiseSSD : public TObject {
public:
AliITSNoiseSSD(const AliITSNoiseSSD &source); // copy constructor
AliITSNoiseSSD& operator=(const AliITSNoiseSSD &source); // ass. op.
- void SetNNoiseP(Int_t n) { fNoisP.Set(n); }
- void AddNoiseP(Int_t c, Float_t n) { fNoisP.AddAt(n,c);}
- TArrayF GetNoiseP() const {return fNoisP; }
- Float_t GetNoiseP(Int_t n) {return fNoisP.At(n); }
- void SetNNoiseN(Int_t n) { fNoisN.Set(n); }
- void AddNoiseN(Int_t c, Float_t n) { fNoisN.AddAt(n,c);}
- TArrayF GetNoiseN() const {return fNoisN; }
- Float_t GetNoiseN(Int_t n) {return fNoisN.At(n); }
-
- void SetMod(UShort_t mod) {fMod = mod;}
- UShort_t GetMod() { return fMod;}
-
-protected:
-
- UShort_t fMod; // module number (from 0 to 1535). Needed by the preprocessor to
- // extract the information from the Detector Algorithm
-
- TArrayF fNoisP; // Noise for P side channels
- TArrayF fNoisN; // Noise for N side channels
-
- private:
+ void AddNoiseP(Int_t module, Int_t strip, Float_t value) {
+ fNois[module*2*fgkDefaultNStripsSSD+strip] = value;
+ }
+ Float_t GetNoiseP(Int_t module, Int_t strip) {
+ return fNois[module*2*fgkDefaultNStripsSSD+strip];
+ }
+
+ void AddNoiseN(Int_t module, Int_t strip, Float_t value) {
+ fNois[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip] = value;
+ }
+ Float_t GetNoiseN(Int_t module, Int_t strip) {
+ return fNois[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip];
+ }
+
+ protected:
+ static const Int_t fgkDefaultNModulesSSD = 1698;
+ static const Int_t fgkDefaultNStripsSSD = 768;
+
+ // static const Int_t fgkDefaultNModulesSSD; // Total numbers of SSD modules
+ //static const Int_t fgkDefaultNStripsSSD; // Total numbers of SSD modules
+
+ Float_t fNois[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD];
+ //Float_t *fNois;
+
+ private:
+
ClassDef(AliITSNoiseSSD,1) // Noise class for SSD
-};
+ };
#endif
/**************************************************************************
- * Copyright(c) 2007-9, ALICE Experiment at CERN, All rights reserved. *
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* *
* Author: The ALICE Off-line Project. *
* Contributors are mentioned in the code where appropriate. *
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/* $Id$ */
#include "AliITSPedestalSSD.h"
//////////////////////////////////////////////////////
// Author: Enrico Fragiacomo
-// Date: 12/12/2007
+// Date: 23/08/2007
+// Modified: 08/07/2008
// //
//////////////////////////////////////////////////////
-ClassImp(AliITSPedestalSSD)
+//const Int_t AliITSPedestalSSD::fgkDefaultNModulesSSD = 1698;
+//const Int_t AliITSPedestalSSD::fgkDefaultNStripsSSD = 768;
+ClassImp(AliITSPedestalSSD)
+
//______________________________________________________________________
-AliITSPedestalSSD::AliITSPedestalSSD():
-fMod(0),
-fPedP(0),
-fPedN(0) {
+ AliITSPedestalSSD::AliITSPedestalSSD()
// Default Constructor
-}
+ //: fPedestal(new Float_t[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD])
+{
+ for(Int_t i=0; i<2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD; i++)
+ fPedestal[i]=0;
+ }
//______________________________________________________________________
-AliITSPedestalSSD::AliITSPedestalSSD(const AliITSPedestalSSD &source): TObject(source),
-fMod(source.fMod),
-fPedP(source.fPedP),
-fPedN(source.fPedN) {
+AliITSPedestalSSD::AliITSPedestalSSD(const AliITSPedestalSSD &source):
+ TObject(source)
+ //, fPedestal(new Float_t[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD])
+{
// copy Constructor
+ memcpy(fPedestal,source.fPedestal,
+ 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Float_t));
}
+
//______________________________________________________________________
AliITSPedestalSSD::~AliITSPedestalSSD(){
// destructor
//______________________________________________________________________
AliITSPedestalSSD& AliITSPedestalSSD::operator=(const AliITSPedestalSSD &source) {
// ass. op.
- if (this == &source)
- return *this;
- fMod = source.fMod;
- fPedP = source.fMod;
- fPedN = source.fMod;
+ if (this == &source)return *this;
+
+ memcpy(fPedestal,source.fPedestal,
+ 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Float_t));
+
return *this;
}
#ifndef ALIITSPEDESTALSSD_H
#define ALIITSPEDESTALSSD_H
-#include "TObjArray.h"
-#include "TArrayF.h"
-
//////////////////////////////////////////////
// Author: Enrico Fragiacomo
-// Date: 12/12/2007
+// Date: 23/08/2007
+// Modified: 08/07/2008
// //
//////////////////////////////////////////////
-
-/* $Id$ */
+#include "TObject.h"
class AliITSPedestalSSD : public TObject {
AliITSPedestalSSD(const AliITSPedestalSSD &source); // copy constructor
AliITSPedestalSSD& operator=(const AliITSPedestalSSD &source); // ass. op.
- void SetNPedestalP(Int_t n) { fPedP.Set(n); }
- void AddPedestalP(Int_t c, Float_t n) { fPedP.AddAt(n,c);}
- TArrayF GetPedestalP() const {return fPedP; }
- Float_t GetPedestalP(Int_t n) {return fPedP.At(n); }
- void SetNPedestalN(Int_t n) { fPedN.Set(n); }
- void AddPedestalN(Int_t c, Float_t n) { fPedN.AddAt(n,c);}
- TArrayF GetPedestalN() const {return fPedN; }
- Float_t GetPedestalN(Int_t n) {return fPedN.At(n); }
-
- void SetMod(UShort_t mod) {fMod = mod;}
- UShort_t GetMod() { return fMod;}
-
-protected:
-
- UShort_t fMod; // module number (from 0 to 1535). Needed by the preprocessor to
- // extract the information from the Detector Algorithm
-
- TArrayF fPedP; // Pedestal for P side channels
- TArrayF fPedN; // Pedestal for N side channels
-
- private:
+ void AddPedestalP(Int_t module, Int_t strip, Float_t value) {
+ fPedestal[module*2*fgkDefaultNStripsSSD+strip] = value;
+ }
+ Float_t GetPedestalP(Int_t module, Int_t strip) {
+ return fPedestal[module*2*fgkDefaultNStripsSSD+strip];
+ }
+
+ void AddPedestalN(Int_t module, Int_t strip, Float_t value) {
+ fPedestal[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip] = value;
+ }
+ Float_t GetPedestalN(Int_t module, Int_t strip) {
+ return fPedestal[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip];
+ }
+
+ protected:
+ static const Int_t fgkDefaultNModulesSSD = 1698;
+ static const Int_t fgkDefaultNStripsSSD = 768;
+
+ // static const Int_t fgkDefaultNModulesSSD; // Total numbers of SSD modules
+ //static const Int_t fgkDefaultNStripsSSD; // Total numbers of SSD modules
+
+Float_t fPedestal[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD];
+
+ private:
+
ClassDef(AliITSPedestalSSD,1) // Pedestal class for SSD
-};
+ };
#endif
return;
}
//
-UInt_t mod=GetModFromKey(key);
+//UInt_t mod=GetModFromKey(key);
//
-AliITSBadChannelsSSD* badchannels=(AliITSBadChannelsSSD*) ssdEntry->At(mod);
+//AliITSBadChannelsSSD* badchannels=(AliITSBadChannelsSSD*) ssdEntry->At(mod);
// count the number of bad channels on the p side
-nrBadInMod += (badchannels->GetBadPChannelsList()).GetSize();
+//nrBadInMod += (badchannels->GetBadPChannelsList()).GetSize();
// add the number of bad channels on the s side
-nrBadInMod += (badchannels->GetBadNChannelsList()).GetSize();
+//nrBadInMod += (badchannels->GetBadNChannelsList()).GetSize();
return;
}
//_____________________________________________________________________________
// Note. To be modified: dcsAliasMap is not needed but I can not get rid
// of it unless the base class AliPreprocessor is modified accordingly.
- TObjArray calib_array(fgkNumberOfSSD);
- TObjArray badch_array(fgkNumberOfSSD);
- TObjArray ped_array(fgkNumberOfSSD);
+ // TObjArray calib_array(fgkNumberOfSSD);
+ //TObjArray badch_array(fgkNumberOfSSD);
+ //TObjArray ped_array(fgkNumberOfSSD);
//Float_t noise=0, gain=0;
+ //---------------------------------------
+ // initialize the calibration objects
+ AliITSNoiseSSD *calib = new AliITSNoiseSSD();
+ AliITSBadChannelsSSD *badch = new AliITSBadChannelsSSD();
+ AliITSPedestalSSD *pedel = new AliITSPedestalSSD();
+
TString runType = GetRunType();
if(runType == "ELECTRONICS_CALIBRATION_RUN") {
TIter next(list);
TObjString *ok;
- //---------------------------------------
- // in case some module was not calibrated!
- for(Int_t i=0; i<fgkNumberOfSSD; i++) {
- AliITSNoiseSSD *calib = new AliITSNoiseSSD();
- calib->SetMod((UShort_t) i+500);
- calib->SetNNoiseP(768);
- calib->SetNNoiseN(768);
- // take a reasonable averaged value for the noise on P- and N-side strips
- for(Int_t j=0; j<768; j++) {
- calib->AddNoiseP(j,1000.);
- calib->AddNoiseN(j,1000.);
- }
- calib_array.AddAt(calib,i);
- }
- //-----------------------------------------
- //---------------------------------------
- // in case some module was not calibrated!
- for(Int_t i=0; i<fgkNumberOfSSD; i++) {
- AliITSBadChannelsSSD *badch = new AliITSBadChannelsSSD();
- badch->SetMod((UShort_t) i+500);
- badch->SetNBadPChannelsList(768);
- badch->SetNBadNChannelsList(768);
- badch_array.AddAt(badch,i);
- }
- //-----------------------------------------
-
- //---------------------------------------
- // in case some module was not calibrated!
- for(Int_t i=0; i<fgkNumberOfSSD; i++) {
- AliITSPedestalSSD *pedel = new AliITSPedestalSSD();
- pedel->SetMod((UShort_t) i+500);
- pedel->SetNPedestalP(768);
- pedel->SetNPedestalN(768);
- for(Int_t j=0; j<768; j++) {
- pedel->AddPedestalP(j,0.);
- pedel->AddPedestalN(j,0.);
- }
- ped_array.AddAt(pedel,i);
- }
- //-----------------------------------------
-
-
-
// expect to iterate 3 times (LDC0, LDC1, LDC2)
while ( (ok = (TObjString*) next()) ) {
return 2;
}
- TObjArray *cal;
+ AliITSNoiseSSD *cal;
f->GetObject("Noise;1", cal);
if(!cal) {
Log("File does not contain expected data for the noise!");
delete list;
return 3;
}
-
- Int_t nmod = cal->GetEntries();
- Log(Form("\n#Mod %d", nmod ));
- for(Int_t mod=0; mod<nmod; mod++) {
- AliITSNoiseSSD *calib = (AliITSNoiseSSD*) cal->At(mod);
- Log(Form("\nModId %d", calib->GetMod() ));
- if((calib->GetMod()<500)||(calib->GetMod()>2198)) continue;
- calib_array.AddAt(calib,calib->GetMod()-500);
- }
-
- TObjArray *bad;
+ AliITSPedestalSSD *ped;
+ f->GetObject("Pedestal;1", ped);
+ if(!ped) {
+ Log("File does not contain expected data for the pedestals!");
+ delete list;
+ return 5;
+ }
+ AliITSBadChannelsSSD *bad;
f->GetObject("BadChannels;1", bad);
if(!bad) {
Log("File does not contain expected data for bad channels !");
delete list;
return 4;
}
- nmod = bad->GetEntries();
- for(Int_t mod=0; mod<nmod; mod++) {
- AliITSBadChannelsSSD *badch = (AliITSBadChannelsSSD*) bad->At(mod);
- if((badch->GetMod()<500)||(badch->GetMod()>2198)) continue;
- badch_array.AddAt(badch,badch->GetMod()-500);
- }
- TObjArray *ped;
- f->GetObject("Pedestal;1", ped);
- if(!ped) {
- Log("File does not contain expected data for the pedestals!");
- delete list;
- return 5;
- }
- nmod = ped->GetEntries();
- for(Int_t mod=0; mod<nmod; mod++) {
- AliITSPedestalSSD *pedel = (AliITSPedestalSSD*) ped->At(mod);
- if((pedel->GetMod()<500)||(pedel->GetMod()>2198)) continue;
- ped_array.AddAt(pedel,pedel->GetMod()-500);
+ for(Int_t module=0; module<fgkNumberOfSSD; module++) {
+ for(Int_t strip=0; strip<768; strip++) {
+ if(cal->GetNoiseP(module,strip))
+ calib->AddNoiseP(module,strip,cal->GetNoiseP(module,strip));
+ if(cal->GetNoiseN(module,strip))
+ calib->AddNoiseN(module,strip,cal->GetNoiseN(module,strip));
+ if(ped->GetPedestalP(module,strip))
+ pedel->AddPedestalP(module,strip,
+ ped->GetPedestalP(module,strip));
+ if(ped->GetPedestalN(module,strip))
+ pedel->AddPedestalN(module,strip,
+ ped->GetPedestalN(module,strip));
+ if(bad->GetBadChannelP(module,strip))
+ badch->AddBadChannelP(module,strip,
+ bad->GetBadChannelP(module,strip));
+ if(bad->GetBadChannelN(module,strip))
+ badch->AddBadChannelN(module,strip,
+ bad->GetBadChannelN(module,strip));
+ }
}
f->Close(); delete f;
metaData.SetResponsible("Enrico Fragiacomo");
metaData.SetComment("Fills noise, pedestal and bad channels TObjArray");
- if(!Store("Calib", "NoiseSSD", &calib_array, &metaData, 0, 1)) {
+ if(!Store("Calib", "NoiseSSD", (TObject*) &calib, &metaData, 0, 1)) {
Log("no store");
return 1;
}
- if(!Store("Calib", "BadChannelsSSD", &badch_array, &metaData, 0, 1)) {
+ if(!Store("Calib", "BadChannelsSSD", (TObject*) &badch, &metaData, 0, 1)) {
Log("no store");
return 1;
}
- if(!StoreReferenceData("Calib","PedestalSSD", &ped_array, &metaData)) {
+ if(!StoreReferenceData("Calib","PedestalSSD", (TObject*) &pedel, &metaData)) {
Log("no store");
return 1;
}
for(ix=0;ix<GetNStrips();ix++){ // loop over strips
// noise is gaussian
- noise = (Double_t) gRandom->Gaus(0,res->GetNoiseP().At(ix));
+ noise = (Double_t) gRandom->Gaus(0,res->GetNoiseP(ix));
// need to calibrate noise
// NOTE. noise from the calibration database comes uncalibrated,
// Nside
for(ix=0;ix<GetNStrips();ix++){ // loop over strips
- noise = (Double_t) gRandom->Gaus(0,res->GetNoiseN().At(ix));// give noise to signal
+ noise = (Double_t) gRandom->Gaus(0,res->GetNoiseN(ix));// give noise to signal
noise *= (Double_t) res->GetGainN(ix);
noise /= res->GetDEvToADC(1.);
signal = noise + fMapA2->GetSignal(1,ix);//get signal from map
for(Int_t i=0;i<GetNStrips();i++){
- if(res->IsPChannelBad(i)) res->AddGainP(i,0.0);
- if(res->IsNChannelBad(i)) res->AddGainN(i,0.0);
+ if(res->IsPChannelBad(i)) res->SetGainP(i,0.0);
+ if(res->IsNChannelBad(i)) res->SetGainN(i,0.0);
} // loop over strips
// threshold for zero suppression is set on the basis of the noise
// A good value is 3*sigma_noise
- if(k==0) threshold = res->GetNoiseP().At(ix);
- else threshold = res->GetNoiseN().At(ix);
+ if(k==0) threshold = res->GetNoiseP(ix);
+ else threshold = res->GetNoiseN(ix);
+
threshold *= res->GetZSThreshold(); // threshold at 3 sigma noise
+
if(signal < threshold) continue;
+ //cout<<signal<<" "<<threshold<<endl;
digits[0] = k;
digits[1] = ix;
-void MakeCalibrationSSD(Int_t firstRun=0,Int_t lastRun=9999999 ){
+void MakeCalibrationSSD(Int_t firstRun=0,Int_t lastRun=999999999 ){
if(!AliCDBManager::Instance()->IsDefaultStorageSet()) {
AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/");
md1->SetObjectClassName("AliITSCalibration");
md1->SetResponsible("Enrico Fragiacomo");
md1->SetBeamPeriod(0);
- md1->SetAliRootVersion("head 23/08/07"); //root version
+ md1->SetAliRootVersion("trunk090708"); //root version
AliCDBId idNoiseSSD("ITS/Calib/NoiseSSD",firstRun, lastRun);
+ AliCDBId idPedestalSSD("ITS/Calib/PedestalSSD",firstRun, lastRun);
AliCDBId idGainSSD("ITS/Calib/GainSSD",firstRun, lastRun);
AliCDBId idBadChannelsSSD("ITS/Calib/BadChannelsSSD",firstRun, lastRun);
- TObjArray noiseSSD(1698);
- TObjArray gainSSD(1698);
- TObjArray badchannelsSSD(1698);
+ AliITSNoiseSSD *noiseSSD = new AliITSNoiseSSD();
+ AliITSPedestalSSD *pedestalSSD = new AliITSPedestalSSD();
+ AliITSGainSSD *gainSSD = new AliITSGainSSD();
+ AliITSBadChannelsSSD *badchannelsSSD = new AliITSBadChannelsSSD();
- noiseSSD.SetOwner(kFALSE);
- gainSSD.SetOwner(kFALSE);
- badchannelsSSD.SetOwner(kFALSE);
-
- Double_t noiseP[768];
- Double_t noiseN[768];
-
- Double_t gainP[768];
- Double_t gainN[768];
-
- // loop over SSD modules
- for(Int_t i=0;i<1698;i++){
-
- AliITSNoiseSSD* noise = new AliITSNoiseSSD();
- AliITSGainSSD* gain = new AliITSGainSSD();
- AliITSBadChannelsSSD* badchannels = new AliITSBadChannelsSSD();
-
- // 768 strips on P- and N-side
- noise->SetNNoiseP(768);
- noise->SetNNoiseN(768);
- gain->SetNGainP(768);
- gain->SetNGainN(768);
- badchannels->SetNBadPChannelsList(10);
- badchannels->SetNBadNChannelsList(10);
-
- // take a reasonable averaged value for the noise on P- and N-side strips
+ for(Int_t i=0; i<1698; i++) {
for(Int_t j=0; j<768; j++) {
- noise->AddNoiseP(j,2.);
- gain->AddGainP(j,1.);
- noise->AddNoiseN(j,4.);
- gain->AddGainN(j,1.);
+ noiseSSD->AddNoiseP(i,j,3.);
+ noiseSSD->AddNoiseN(i,j,5.);
+ gainSSD->AddGainP(i,j,0.8);
+ gainSSD->AddGainN(i,j,1.2);
}
-
- // 10 random strips per module tagged as "bad"
- for(Int_t j=0; j<10; j++) {
- badchannels->AddBadPChannel(j,gRandom->Uniform(0,767));
- badchannels->AddBadNChannel(j,gRandom->Uniform(0,767));
- }
-
- noiseSSD.Add(noise);
- gainSSD.Add(gain);
- badchannelsSSD.Add(badchannels);
-
}
- AliCDBManager::Instance()->GetDefaultStorage()->Put(&noiseSSD, idNoiseSSD, md1);
- AliCDBManager::Instance()->GetDefaultStorage()->Put(&gainSSD, idGainSSD, md1);
- AliCDBManager::Instance()->GetDefaultStorage()->Put(&badchannelsSSD, idBadChannelsSSD, md1);
-
+ AliCDBManager::Instance()->GetDefaultStorage()->Put( (TObject*) noiseSSD, idNoiseSSD, md1);
+ AliCDBManager::Instance()->GetDefaultStorage()->Put( (TObject*) gainSSD, idGainSSD, md1);
+ AliCDBManager::Instance()->GetDefaultStorage()->Put( (TObject*) badchannelsSSD, idBadChannelsSSD, md1);
+ AliCDBManager::Instance()->GetDefaultStorage()->Put( (TObject*) pedestalSSD, idPedestalSSD, md1);
+
}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff