--- /dev/null
+/**************************************************************************
+ * 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. *
+ * *
+ * 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. *
+ **************************************************************************/
+
+
+#include "AliITSBadChannelsSSD.h"
+
+ClassImp(AliITSBadChannelsSSD)
+
+//______________________________________________________________________
+AliITSBadChannelsSSD::AliITSBadChannelsSSD():
+fMod(0),
+fBadNChannelsList(0),
+fBadPChannelsList(0){
+ // Default Constructor
+
+}
+
+//______________________________________________________________________
+AliITSBadChannelsSSD::~AliITSBadChannelsSSD(){
+ // destructor
+
+}
+
--- /dev/null
+#ifndef ALIITSBADCHANNELSSSD_H
+#define ALIITSBADCHANNELSSSD_H
+
+#include "TObjArray.h"
+#include "TArrayI.h"
+
+//////////////////////////////////////////////
+// Response class for SSD //
+// //
+//////////////////////////////////////////////
+class AliITSBadChannelsSSD : public TObject {
+
+ public:
+ AliITSBadChannelsSSD();
+ virtual ~AliITSBadChannelsSSD();
+
+ 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; }
+ 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; }
+ //
+
+ 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
+
+ TArrayI fBadNChannelsList; // list of P side dead channels
+ TArrayI fBadPChannelsList; // list of N side dead channels
+
+ private:
+ AliITSBadChannelsSSD(const AliITSBadChannelsSSD &source); // copy constructor
+ AliITSBadChannelsSSD& operator=(const AliITSBadChannelsSSD &source); // ass. op.
+
+ ClassDef(AliITSBadChannelsSSD,1) //Response class for SSD
+};
+#endif
fNoiseN(0),
fSigmaP(0),
fSigmaN(0),
+fNoise(0),
+fGain(0),
+fBadChannels(0),
fGainP(0),
fGainN(0),
fNoisP(0),
fNoiseN(0),
fSigmaP(0),
fSigmaN(0),
+fNoise(0),
+fGain(0),
+fBadChannels(0),
fGainP(0),
fGainN(0),
fNoisP(0),
#define ALIITSCALIBRATIONSSD_H
#include "AliITSCalibration.h"
+#include "AliITSNoiseSSD.h"
+#include "AliITSGainSSD.h"
+#include "AliITSBadChannelsSSD.h"
#include "AliITSresponseSSD.h"
#include "TArrayF.h"
#include "TArrayI.h"
np=fNoiseP; nn=fNoiseN;
}
- // EF
- 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 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 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 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;}
+
+ TArrayI GetBadPChannelsList() { fBadChannels->GetBadPChannelsList(); }
+ TArrayI GetBadNChannelsList() { fBadChannels->GetBadNChannelsList(); }
+ void SetBadChannels( AliITSBadChannelsSSD* badchannels) {fBadChannels=badchannels;}
void SetNoisePThreshold(Int_t threshold) { fNoisePThreshold = threshold;}
void AddNoisyPChannel(Int_t c, Int_t n) { fNoisyPChannelsList.AddAt(n,c);}
Double_t fSigmaP; // Sigma charge spread on Pside
Double_t fSigmaN; // Sigma charge spread on Nside
+ AliITSNoiseSSD *fNoise;
+ AliITSGainSSD *fGain;
+ AliITSBadChannelsSSD *fBadChannels;
+
TArrayF fGainP; // Gain for P side channels
TArrayF fGainN; // Gain for N side channels
#include "AliITSRawClusterSSD.h"
#include "AliITSRecPoint.h"
#include "AliITSCalibrationSDD.h"
+#include "AliITSCalibrationSSD.h"
+#include "AliITSNoiseSSD.h"
+#include "AliITSGainSSD.h"
+#include "AliITSBadChannelsSSD.h"
#include "AliITSsegmentationSPD.h"
#include "AliITSsegmentationSDD.h"
#include "AliITSsegmentationSSD.h"
AliCDBEntry *entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSPD");
AliCDBEntry *entrySDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD");
- AliCDBEntry *entrySSD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSSD");
+
+ // AliCDBEntry *entrySSD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSSD");
+ AliCDBEntry *entryNoiseSSD = AliCDBManager::Instance()->Get("ITS/Calib/NoiseSSD");
+ AliCDBEntry *entryGainSSD = AliCDBManager::Instance()->Get("ITS/Calib/GainSSD");
+ AliCDBEntry *entryBadChannelsSSD = AliCDBManager::Instance()->Get("ITS/Calib/BadChannelsSSD");
+
AliCDBEntry *entry2SPD = AliCDBManager::Instance()->Get("ITS/Calib/RespSPD");
AliCDBEntry *entry2SDD = AliCDBManager::Instance()->Get("ITS/Calib/RespSDD");
AliCDBEntry *entry2SSD = AliCDBManager::Instance()->Get("ITS/Calib/RespSSD");
- if(!entrySPD || !entrySDD || !entrySSD || !entry2SPD || !entry2SDD || !entry2SSD){
+ if(!entrySPD || !entrySDD || !entryNoiseSSD || !entryGainSSD || !entryBadChannelsSSD ||
+ !entry2SPD || !entry2SDD || !entry2SSD){
AliFatal("Calibration object retrieval failed! ");
return kFALSE;
}
if(!cacheStatus)entry2SDD->SetObject(NULL);
entry2SDD->SetOwner(kTRUE);
- TObjArray *calSSD = (TObjArray *)entrySSD->GetObject();
- if(!cacheStatus)entrySSD->SetObject(NULL);
- entrySSD->SetOwner(kTRUE);
+ TObjArray *noiseSSD = (TObjArray *)entryNoiseSSD->GetObject();
+ if(!cacheStatus)entryNoiseSSD->SetObject(NULL);
+ entryNoiseSSD->SetOwner(kTRUE);
+
+ TObjArray *gainSSD = (TObjArray *)entryGainSSD->GetObject();
+ if(!cacheStatus)entryGainSSD->SetObject(NULL);
+ entryGainSSD->SetOwner(kTRUE);
+
+ TObjArray *badchannelsSSD = (TObjArray *)entryBadChannelsSSD->GetObject();
+ if(!cacheStatus)entryBadChannelsSSD->SetObject(NULL);
+ entryBadChannelsSSD->SetOwner(kTRUE);
AliITSresponseSSD *pSSD = (AliITSresponseSSD*)entry2SSD->GetObject();
if(!cacheStatus)entry2SSD->SetObject(NULL);
if(!cacheStatus){
delete entrySPD;
delete entrySDD;
- delete entrySSD;
+ delete entryNoiseSSD;
+ delete entryGainSSD;
+ delete entryBadChannelsSSD;
delete entry2SPD;
delete entry2SDD;
delete entry2SSD;
}
- if ((!pSPD)||(!pSDD)||(!pSSD) || (!calSPD) || (!calSDD) || (!calSSD)) {
+ if ((!pSPD)||(!pSDD)||(!pSSD) || (!calSPD) || (!calSDD)
+ || (!noiseSSD)|| (!gainSSD)|| (!badchannelsSSD)) {
AliWarning("Can not get calibration from calibration database !");
return kFALSE;
}
fNMod[0] = calSPD->GetEntries();
fNMod[1] = calSDD->GetEntries();
- fNMod[2] = calSSD->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);
}
for (Int_t i=0; i<fNMod[2]; i++) {
- cal = (AliITSCalibration*) calSSD->At(i);
- cal->SetResponse((AliITSresponse*)pSSD);
+
+ AliITSCalibrationSSD *calibSSD = new AliITSCalibrationSSD();
+ calibSSD->SetResponse((AliITSresponse*)pSSD);
+
+ AliITSNoiseSSD *noise = (AliITSNoiseSSD*) (noiseSSD->At(i));
+ calibSSD->SetNoise(noise);
+ AliITSGainSSD *gain = (AliITSGainSSD*) (gainSSD->At(i));
+ calibSSD->SetGain(gain);
+ AliITSBadChannelsSSD *bad = (AliITSBadChannelsSSD*) (badchannelsSSD->At(i));
+ calibSSD->SetBadChannels(bad);
+
Int_t iMod = i + fNMod[0] + fNMod[1];
- SetCalibrationModel(iMod, cal);
+ SetCalibrationModel(iMod, calibSSD);
}
return kTRUE;
#include "AliITSresponseSDD.h"
#include "AliITSCalibrationSDD.h"
#include "AliITSCalibrationSSD.h"
+#include "AliITSNoiseSSD.h"
+#include "AliITSGainSSD.h"
+#include "AliITSBadChannelsSSD.h"
+#include "AliITSCalibrationSSD.h"
#include "AliITSsegmentationSPD.h"
#include "AliITSsegmentationSDD.h"
#include "AliITSsegmentationSSD.h"
AliCDBEntry *entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSPD", run);
AliCDBEntry *entrySDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD", run);
- AliCDBEntry *entrySSD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSSD", run);
+ // AliCDBEntry *entrySSD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSSD", run);
+ AliCDBEntry *entryNoiseSSD = AliCDBManager::Instance()->Get("ITS/Calib/NoiseSSD");
+ AliCDBEntry *entryGainSSD = AliCDBManager::Instance()->Get("ITS/Calib/GainSSD");
+ AliCDBEntry *entryBadChannelsSSD = AliCDBManager::Instance()->Get("ITS/Calib/BadChannelsSSD");
+
AliCDBEntry *entry2SPD = AliCDBManager::Instance()->Get("ITS/Calib/RespSPD", run);
AliCDBEntry *entry2SDD = AliCDBManager::Instance()->Get("ITS/Calib/RespSDD", run);
AliCDBEntry *entry2SSD = AliCDBManager::Instance()->Get("ITS/Calib/RespSSD", run);
- if(!entrySPD || !entrySDD || !entrySSD || !entry2SPD || !entry2SDD || !entry2SSD){
- AliFatal("Calibration object retrieval failed!");
- return kFALSE;
- }
+ if(!entrySPD || !entrySDD || !entryNoiseSSD || !entryGainSSD || !entryBadChannelsSSD ||
+ !entry2SPD || !entry2SDD || !entry2SSD){
+ AliFatal("Calibration object retrieval failed! ");
+ return kFALSE;
+ }
- if(!entrySPD || !entrySDD || !entrySSD || !entry2SPD || !entry2SDD || !entry2SSD){
- AliError("Calibration data was not found in $ALICE_ROOT!");
+ if(!entrySPD || !entrySDD || !entryNoiseSSD || !entryGainSSD || !entryBadChannelsSSD ||
+ !entry2SPD || !entry2SDD || !entry2SSD){
+ AliFatal("Calibration object retrieval failed! ");
return kFALSE;
- }
+ }
TObjArray *calSPD = (TObjArray *)entrySPD->GetObject();
if(!isCacheActive)entrySPD->SetObject(NULL);
if(!isCacheActive)entry2SDD->SetObject(NULL);
entry2SDD->SetOwner(kTRUE);
+ /*
TObjArray *calSSD = (TObjArray *)entrySSD->GetObject();
if(!isCacheActive)entrySSD->SetObject(NULL);
entrySSD->SetOwner(kTRUE);
+ */
+
+ TObjArray *noiseSSD = (TObjArray *)entryNoiseSSD->GetObject();
+ if(!isCacheActive)entryNoiseSSD->SetObject(NULL);
+ entryNoiseSSD->SetOwner(kTRUE);
+
+ TObjArray *gainSSD = (TObjArray *)entryGainSSD->GetObject();
+ if(!isCacheActive)entryGainSSD->SetObject(NULL);
+ entryGainSSD->SetOwner(kTRUE);
+
+ TObjArray *badchannelsSSD = (TObjArray *)entryBadChannelsSSD->GetObject();
+ if(!isCacheActive)entryBadChannelsSSD->SetObject(NULL);
+ entryBadChannelsSSD->SetOwner(kTRUE);
AliITSresponseSSD *pSSD = (AliITSresponseSSD*)entry2SSD->GetObject();
if(!isCacheActive)entry2SSD->SetObject(NULL);
if(!isCacheActive){
delete entrySPD;
delete entrySDD;
- delete entrySSD;
+ delete entryNoiseSSD;
+ delete entryGainSSD;
+ delete entryBadChannelsSSD;
delete entry2SPD;
delete entry2SDD;
delete entry2SSD;
AliCDBManager::Instance()->SetCacheFlag(origCacheStatus);
- if ((!pSPD)||(!pSDD)||(!pSSD)) {
- AliWarning("Can not get calibration from calibration database !");
- return kFALSE;
- }
- if ((! calSPD)||(! calSDD)||(! calSSD)) {
+ if ((!pSPD)||(!pSDD)||(!pSSD) || (!calSPD) || (!calSDD)
+ || (!noiseSSD)|| (!gainSSD)|| (!badchannelsSSD)) {
AliWarning("Can not get calibration from calibration database !");
return kFALSE;
}
+
fNMod[0] = calSPD->GetEntries();
fNMod[1] = calSDD->GetEntries();
- fNMod[2] = calSSD->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);
}
for (Int_t i=0; i<fNMod[2]; i++) {
- cal = (AliITSCalibration*) calSSD->At(i);
- cal->SetResponse(pSSD);
+ AliITSCalibrationSSD *calibSSD = new AliITSCalibrationSSD();
+ calibSSD->SetResponse((AliITSresponse*)pSSD);
+
+ AliITSNoiseSSD *noise = (AliITSNoiseSSD*) (noiseSSD->At(i));
+ calibSSD->SetNoise(noise);
+ AliITSGainSSD *gain = (AliITSGainSSD*) (gainSSD->At(i));
+ calibSSD->SetGain(gain);
+ AliITSBadChannelsSSD *bad = (AliITSBadChannelsSSD*) (badchannelsSSD->At(i));
+ calibSSD->SetBadChannels(bad);
+
Int_t iMod = i + fNMod[0] + fNMod[1];
- SetCalibrationModel(iMod, cal);
+ SetCalibrationModel(iMod, calibSSD);
+
}
return kTRUE;
}
--- /dev/null
+/**************************************************************************
+ * 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. *
+ * *
+ * 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. *
+ **************************************************************************/
+
+
+#include "AliITSGainSSD.h"
+
+//////////////////////////////////////////////////////
+// Author: Enrico Fragiacomo
+// Date: 23/08/2007
+// //
+//////////////////////////////////////////////////////
+
+ClassImp(AliITSGainSSD)
+
+//______________________________________________________________________
+AliITSGainSSD::AliITSGainSSD():
+fMod(0),
+fGainP(0),
+fGainN(0) {
+ // Default Constructor
+}
+
+//______________________________________________________________________
+AliITSGainSSD::~AliITSGainSSD(){
+ // destructor
+
+}
+
--- /dev/null
+#ifndef ALIITSGAINSSD_H
+#define ALIITSGAINSSD_H
+
+#include "TObjArray.h"
+#include "TArrayF.h"
+
+//////////////////////////////////////////////
+// Author: Enrico Fragiacomo
+// Date: 23/08/2007
+// //
+//////////////////////////////////////////////
+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
+};
+#endif
--- /dev/null
+/**************************************************************************
+ * 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. *
+ * *
+ * 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. *
+ **************************************************************************/
+
+
+#include "AliITSNoiseSSD.h"
+
+//////////////////////////////////////////////////////
+// Author: Enrico Fragiacomo
+// Date: 23/08/2007
+// //
+//////////////////////////////////////////////////////
+
+ClassImp(AliITSNoiseSSD)
+
+//______________________________________________________________________
+AliITSNoiseSSD::AliITSNoiseSSD():
+fMod(0),
+fNoisP(0),
+fNoisN(0) {
+ // Default Constructor
+}
+
+//______________________________________________________________________
+AliITSNoiseSSD::~AliITSNoiseSSD(){
+ // destructor
+
+}
+
--- /dev/null
+#ifndef ALIITSNOISESSD_H
+#define ALIITSNOISESSD_H
+
+#include "TObjArray.h"
+#include "TArrayF.h"
+
+//////////////////////////////////////////////
+// Author: Enrico Fragiacomo
+// Date: 23/08/2007
+// //
+//////////////////////////////////////////////
+class AliITSNoiseSSD : public TObject {
+
+ public:
+
+ AliITSNoiseSSD();
+ virtual ~AliITSNoiseSSD();
+ 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:
+
+ ClassDef(AliITSNoiseSSD,1) // Noise class for SSD
+};
+#endif
#pragma link C++ class AliITSCalibrationSPD+;
#pragma link C++ class AliITSCalibrationSDD+;
#pragma link C++ class AliITSCalibrationSSD+;
+#pragma link C++ class AliITSBadChannelsSSD+;
+#pragma link C++ class AliITSGainSSD+;
+#pragma link C++ class AliITSNoiseSSD+;
#pragma link C++ class AliITSpList+;
#pragma link C++ class AliITSpListItem+;
AliITSCalibrationSPD.cxx \
AliITSCalibrationSDD.cxx \
AliITSCalibrationSSD.cxx \
+ AliITSBadChannelsSSD.cxx \
+ AliITSGainSSD.cxx \
+ AliITSNoiseSSD.cxx \
AliITSDDLRawData.cxx \
AliITSRawStream.cxx \
AliITSRawStreamSDDv2.cxx \