fPedestal(),
fGain(0),
fBadChannels(0),
-fIsBad(kFALSE){
+ fIsBad(kFALSE),
+fSSDADCpereV(0.),
+ fKeVperADC(0)
+{
// Default Constructor
for(Int_t i=0;i<fgkChipsPerModule;i++){
fIsChipBad[i]=kFALSE;
}
+ SetSSDADCpereV();
+ SetKeVperADC();
}
//______________________________________________________________________
AliITSCalibrationSSD::AliITSCalibrationSSD(const char *dataType):
fPedestal(0),
fGain(0),
fBadChannels(0),
-fIsBad(kFALSE){
+fIsBad(kFALSE) ,
+fSSDADCpereV(0.),
+fKeVperADC(0){
// constructor
SetDataType(dataType);
for(Int_t i=0;i<fgkChipsPerModule;i++){
fIsChipBad[i]=kFALSE;
}
+ SetSSDADCpereV();
+ SetKeVperADC();
}
//______________________________________________________________________
AliITSCalibrationSSD::~AliITSCalibrationSSD(){
#include "AliITSPedestalSSDv2.h"
#include "AliITSGainSSDv2.h"
#include "AliITSBadChannelsSSDv2.h"
-#include "AliITSresponseSSD.h"
#include "TArrayF.h"
#include "TArrayI.h"
/* $Id$ */
//////////////////////////////////////////////
-// Response class for SSD //
+// Calibration class for SSD //
// //
//////////////////////////////////////////////
class AliITSCalibrationSSD : public AliITSCalibration {
virtual void Thresholds(Double_t & /* a */, Double_t & /* b */) const
{NotImplemented("Thresholds");}
- 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);}
+ void SetModule(Int_t mod){fModule = mod;}
- 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);}
+ void SetKeVperADC(Double_t a=86.4/120.){fKeVperADC = a;}
+ Double_t ADCToKeV(Double_t adc) const {return adc*fKeVperADC;}
- virtual Int_t GetZSThreshold() const {return ((AliITSresponseSSD*)fResponse)->GetZSThreshold();}
- virtual void SetZSThreshold(Int_t zsth)
- { ((AliITSresponseSSD*)fResponse)->SetZSThreshold(zsth);}
+ void SetSSDADCpereV(Double_t a=120./24888.9){fSSDADCpereV = a;}
+ Double_t GetSSDDEvToADC(Double_t eV) const {return eV*fSSDADCpereV;}
+ Int_t GetSSDIEvToADC(Double_t eV) const {
+ return ((Int_t) GetSSDDEvToADC(eV)); }
- void SetModule(Int_t mod){fModule = mod;}
-protected:
+ protected:
static const Int_t fgkChipsPerModule = 12; // Number of chips/module
static const Int_t fgkChannelsPerChip = 128; // Number of channels/chip
Bool_t fIsBad; // module is dead or alive ?
Bool_t fIsChipBad[fgkChipsPerModule]; // chip is dead or alive ?
+ Double_t fSSDADCpereV; // Constant to convert eV to ADC for SSD.
+ Double_t fKeVperADC; // Constant to convert ADC to keV
+
private:
AliITSCalibrationSSD(const AliITSCalibrationSSD &source); // copy constructor
AliITSCalibrationSSD& operator=(const AliITSCalibrationSSD &source); // ass. op.
- ClassDef(AliITSCalibrationSSD,4) //Response class for SSD
+ ClassDef(AliITSCalibrationSSD,5) //Response class for SSD
};
#endif
class AliITSsegmentation;
class AliITSsegmentationSSD;
class AliITSresponse;
-class AliITSresponseSSD;
class AliITSCalibration;
class AliITSCalibrationSSD;
#include "AliITSdigitSSD.h"
#include "AliITSReconstructor.h"
#include "AliITSCalibrationSSD.h"
+#include "AliITSsegmentationSSD.h"
Short_t *AliITSClusterFinderV2SSD::fgPairs = 0x0;
Int_t AliITSClusterFinderV2SSD::fgPairsSize = 0;
AliITSClusterFinderV2SSD::AliITSClusterFinderV2SSD(AliITSDetTypeRec* dettyp):AliITSClusterFinderV2(dettyp),
-fLastSSD1(AliITSgeomTGeo::GetModuleIndex(6,1,1)-1),
-fYpitchSSD(0.0095),
-fHwSSD(3.65),
-fHlSSD(2.00),
-fTanP(0.0275),
-fTanN(0.0075)
+fLastSSD1(AliITSgeomTGeo::GetModuleIndex(6,1,1)-1)
{
-
- //Default constructor
+//Default constructor
}
//______________________________________________________________________
-AliITSClusterFinderV2SSD::AliITSClusterFinderV2SSD(const AliITSClusterFinderV2SSD &cf) : AliITSClusterFinderV2(cf), fLastSSD1(cf.fLastSSD1),
-fYpitchSSD(cf.fYpitchSSD),
-fHwSSD(cf.fHwSSD),
-fHlSSD(cf.fHlSSD),
-fTanP(cf.fTanP),
-fTanN(cf.fTanN)
+AliITSClusterFinderV2SSD::AliITSClusterFinderV2SSD(const AliITSClusterFinderV2SSD &cf) : AliITSClusterFinderV2(cf), fLastSSD1(cf.fLastSSD1)
{
// Copy constructor
}
Float_t q=gain*d->GetSignal(); // calibration brings mip peaks around 120 (in ADC units)
q=cal->ADCToKeV(q); // converts the charge in KeV from ADC units
- //Float_t q=d->GetSignal()/4.29;// temp. fix (for PID purposed - normalis. to be checked)
d->SetSignal(Int_t(q));
if (d->GetSignal()<3) continue;
const TGeoHMatrix *mT2L=AliITSgeomTGeo::GetTracking2LocalMatrix(fModule);
TClonesArray &cl=*clusters;
- //
- // Float_t tanp=fTanP, tann=fTanN;
- const Float_t kStartXzero=3.64325;
- const Float_t kDeltaXzero5or6=0.02239;
- const Float_t kDeltaZ5to6=7.6/7.0;
- Int_t is6=-1;
-
- if (fModule>fLastSSD1) is6=1;
+ AliITSsegmentationSSD *seg = dynamic_cast<AliITSsegmentationSSD*>(fDetTypeRec->GetSegmentationModel(2));
+ if (fModule>fLastSSD1)
+ seg->SetLayer(6);
+ else
+ seg->SetLayer(5);
+
+ Float_t hwSSD = seg->Dx()*1e-4/2;
+ Float_t hlSSD = seg->Dz()*1e-4/2;
+
Int_t idet=fNdet[fModule];
Int_t ncl=0;
//
- Int_t negativepair[30000];
- Int_t cnegative[3000];
- Int_t cused1[3000];
- Int_t positivepair[30000];
- Int_t cpositive[3000];
- Int_t cused2[3000];
- for (Int_t i=0;i<3000;i++) {cnegative[i]=0; cused1[i]=0;}
- for (Int_t i=0;i<3000;i++) {cpositive[i]=0; cused2[i]=0;}
- for (Int_t i=0;i<30000;i++) {negativepair[i]=0; positivepair[i]=0;}
+ Int_t *cnegative = new Int_t[np];
+ Int_t *cused1 = new Int_t[np];
+ Int_t *negativepair = new Int_t[10*np];
+ Int_t *cpositive = new Int_t[nn];
+ Int_t *cused2 = new Int_t[nn];
+ Int_t *positivepair = new Int_t[10*nn];
+ for (Int_t i=0;i<np;i++) {cnegative[i]=0; cused1[i]=0;}
+ for (Int_t i=0;i<nn;i++) {cpositive[i]=0; cused2[i]=0;}
+ for (Int_t i=0;i<10*np;i++) {negativepair[i]=0;}
+ for (Int_t i=0;i<10*nn;i++) {positivepair[i]=0;}
if ((np*nn) > fgPairsSize) {
if ( (neg[j].GetQ()>0) && (neg[j].GetQ()<3) ) continue;
Float_t yn=neg[j].GetY();
- Float_t zt=1.9*(yp-yn)/7.0-is6*kDeltaZ5to6;
- Float_t yt=is6*(kStartXzero-(285*yp + 1045*yn)/140000.0) + kDeltaXzero5or6;
+ Float_t xt, zt;
+ seg->GetPadCxz(yn, yp, xt, zt);
- if (TMath::Abs(yt)<fHwSSD+0.01)
- if (TMath::Abs(zt)<fHlSSD+0.01*(neg[j].GetNd()+pos[i].GetNd())) {
+ if (TMath::Abs(xt)<hwSSD+0.01)
+ if (TMath::Abs(zt)<hlSSD+0.01*(neg[j].GetNd()+pos[i].GetNd())) {
negativepair[i*10+cnegative[i]] =j; //index
positivepair[j*10+cpositive[j]] =i;
cnegative[i]++; //counters
if ( (neg[j].GetQ()>0) && (neg[j].GetQ()<3) ) continue;
// if both 1Dclusters have an other cross continue
if (cpositive[j]&&cnegative[i]) continue;
- Float_t yn=neg[j].GetY();
+ Float_t yn=neg[j].GetY();
- Float_t zt=1.9*(yp-yn)/7.0-is6*kDeltaZ5to6;
- Float_t yt=is6*(kStartXzero-(285*yp + 1045*yn)/140000.0) + kDeltaXzero5or6;
+ Float_t xt, zt;
+ seg->GetPadCxz(yn, yp, xt, zt);
- if (TMath::Abs(yt)<fHwSSD+0.1)
- if (TMath::Abs(zt)<fHlSSD+0.15) {
+ if (TMath::Abs(xt)<hwSSD+0.1)
+ if (TMath::Abs(zt)<hlSSD+0.15) {
// tag 1Dcluster (eventually will produce low quality recpoint)
if (cnegative[i]==0) pos[i].SetNd(100); // not available pair
if (cpositive[j]==0) neg[j].SetNd(100); // not available pair
// sign gold tracks
//
for (Int_t ip=0;ip<np;ip++){
- Float_t ybest=1000,zbest=1000,qbest=0;
+ Float_t xbest=1000,zbest=1000,qbest=0;
//
// select gold clusters
if ( (cnegative[ip]==1) && cpositive[negativepair[10*ip]]==1){
if (TMath::Abs(ratio)>0.2) continue; // note: 0.2=3xsigma_ratio calculated in cosmics tests
//
- Float_t yn=neg[j].GetY();
-
- Float_t zt=1.9*(yp-yn)/7.0-is6*kDeltaZ5to6;
- Float_t yt=is6*(kStartXzero-(285*yp + 1045*yn)/140000.0) + kDeltaXzero5or6;
-
- ybest=yt; zbest=zt;
+ Float_t yn=neg[j].GetY();
+
+ Float_t xt, zt;
+ seg->GetPadCxz(yn, yp, xt, zt);
+
+ xbest=xt; zbest=zt;
qbest=0.5*(pos[ip].GetQ()+neg[j].GetQ());
if( (pos[ip].GetQ()==0)||(neg[ip].GetQ()==0)) qbest*=2; // in case of bad strips on one side keep all charge from the other one
{
- Double_t loc[3]={ybest,0.,zbest},trk[3]={0.,0.,0.};
+ Double_t loc[3]={xbest,0.,zbest},trk[3]={0.,0.,0.};
mT2L->MasterToLocal(loc,trk);
lp[0]=trk[1];
lp[1]=trk[2];
}
for (Int_t ip=0;ip<np;ip++){
- Float_t ybest=1000,zbest=1000,qbest=0;
+ Float_t xbest=1000,zbest=1000,qbest=0;
//
//
// select "silber" cluster
if ( (fgPairs[ip*nn+in]==100)&&(pos[ip].GetQ() ) ) { //
Float_t yp=pos[ip].GetY();
- Float_t yn=neg[in].GetY();
-
- Float_t zt=1.9*(yp-yn)/7.0-is6*kDeltaZ5to6;
- Float_t yt=is6*(kStartXzero-(285*yp + 1045*yn)/140000.0) + kDeltaXzero5or6;
- ybest =yt; zbest=zt;
-
+ Float_t yn=neg[in].GetY();
+
+ Float_t xt, zt;
+ seg->GetPadCxz(yn, yp, xt, zt);
+
+ xbest=xt; zbest=zt;
qbest =pos[ip].GetQ();
- Double_t loc[3]={ybest,0.,zbest},trk[3]={0.,0.,0.};
+ Double_t loc[3]={xbest,0.,zbest},trk[3]={0.,0.,0.};
mT2L->MasterToLocal(loc,trk);
lp[0]=trk[1];
lp[1]=trk[2];
if ( (fgPairs[ip2*nn+in]==100) && (pos[ip2].GetQ()) ) {
Float_t yp=pos[ip2].GetY();
- Float_t yn=neg[in].GetY();
-
- Float_t zt=1.9*(yp-yn)/7.0-is6*kDeltaZ5to6;
- Float_t yt=is6*(kStartXzero-(285*yp + 1045*yn)/140000.0) + kDeltaXzero5or6;
- ybest =yt; zbest=zt;
+ Float_t yn=neg[in].GetY();
+
+ Float_t xt, zt;
+ seg->GetPadCxz(yn, yp, xt, zt);
+
+ xbest=xt; zbest=zt;
qbest =pos[ip2].GetQ();
- Double_t loc[3]={ybest,0.,zbest},trk[3]={0.,0.,0.};
+ Double_t loc[3]={xbest,0.,zbest},trk[3]={0.,0.,0.};
mT2L->MasterToLocal(loc,trk);
lp[0]=trk[1];
lp[1]=trk[2];
//
for (Int_t jn=0;jn<nn;jn++){
if (cused2[jn]) continue;
- Float_t ybest=1000,zbest=1000,qbest=0;
+ Float_t xbest=1000,zbest=1000,qbest=0;
// select "silber" cluster
if ( cpositive[jn]==1 && cnegative[positivepair[10*jn]]==2){
Int_t ip = positivepair[10*jn];
if ( (fgPairs[ip*nn+jn]==100) && (neg[jn].GetQ()) ) { //
Float_t yn=neg[jn].GetY();
- Float_t yp=pos[ip].GetY();
-
- Float_t zt=1.9*(yp-yn)/7.0-is6*kDeltaZ5to6;
- Float_t yt=is6*(kStartXzero-(285*yp + 1045*yn)/140000.0) + kDeltaXzero5or6;
-
- ybest =yt; zbest=zt;
+ Float_t yp=pos[ip].GetY();
+ Float_t xt, zt;
+ seg->GetPadCxz(yn, yp, xt, zt);
+
+ xbest=xt; zbest=zt;
qbest =neg[jn].GetQ();
{
- Double_t loc[3]={ybest,0.,zbest},trk[3]={0.,0.,0.};
+ Double_t loc[3]={xbest,0.,zbest},trk[3]={0.,0.,0.};
mT2L->MasterToLocal(loc,trk);
lp[0]=trk[1];
lp[1]=trk[2];
Float_t yn=neg[jn2].GetY();
Double_t yp=pos[ip].GetY();
- Double_t zt=1.9*(yp-yn)/7.0-is6*kDeltaZ5to6;
- Double_t yt=is6*(kStartXzero-(285*yp + 1045*yn)/140000.0) + kDeltaXzero5or6;
-
- ybest =yt; zbest=zt;
+ Float_t xt, zt;
+ seg->GetPadCxz(yn, yp, xt, zt);
+
+ xbest=xt; zbest=zt;
qbest =neg[jn2].GetQ();
{
- Double_t loc[3]={ybest,0.,zbest},trk[3]={0.,0.,0.};
+ Double_t loc[3]={xbest,0.,zbest},trk[3]={0.,0.,0.};
mT2L->MasterToLocal(loc,trk);
lp[0]=trk[1];
lp[1]=trk[2];
for (Int_t ip=0;ip<np;ip++){
- Float_t ybest=1000,zbest=1000,qbest=0;
+ Float_t xbest=1000,zbest=1000,qbest=0;
//
// 2x2 clusters
//
Float_t yp=pos[ip].GetY();
Float_t yn=neg[j].GetY();
- Float_t zt=1.9*(yp-yn)/7.0-is6*kDeltaZ5to6;
- Float_t yt=is6*(kStartXzero-(285*yp + 1045*yn)/140000.0) + kDeltaXzero5or6;
-
- ybest=yt; zbest=zt;
+
+ Float_t xt, zt;
+ seg->GetPadCxz(yn, yp, xt, zt);
+
+ xbest=xt; zbest=zt;
+
qbest=0.5*(pos[ip].GetQ()+neg[j].GetQ());
{
- Double_t loc[3]={ybest,0.,zbest},trk[3]={0.,0.,0.};
+ Double_t loc[3]={xbest,0.,zbest},trk[3]={0.,0.,0.};
mT2L->MasterToLocal(loc,trk);
lp[0]=trk[1];
lp[1]=trk[2];
// recover all the other crosses
//
for (Int_t i=0; i<np; i++) {
- Float_t ybest=1000,zbest=1000,qbest=0;
+ Float_t xbest=1000,zbest=1000,qbest=0;
Float_t yp=pos[i].GetY();
if ((pos[i].GetQ()>0)&&(pos[i].GetQ()<3)) continue;
for (Int_t j=0; j<nn; j++) {
ratio = (pos[i].GetQ()-neg[j].GetQ())/(pos[i].GetQ()+neg[j].GetQ());
Float_t yn=neg[j].GetY();
- Float_t zt=1.9*(yp-yn)/7.0-is6*kDeltaZ5to6;
- Float_t yt=is6*(kStartXzero-(285*yp + 1045*yn)/140000.0) + kDeltaXzero5or6;
+ Float_t xt, zt;
+ seg->GetPadCxz(yn, yp, xt, zt);
- if (TMath::Abs(yt)<fHwSSD+0.01)
- if (TMath::Abs(zt)<fHlSSD+0.01*(neg[j].GetNd()+pos[i].GetNd())) {
- ybest=yt; zbest=zt;
+ if (TMath::Abs(xt)<hwSSD+0.01)
+ if (TMath::Abs(zt)<hlSSD+0.01*(neg[j].GetNd()+pos[i].GetNd())) {
+ xbest=xt; zbest=zt;
+
qbest=0.5*(pos[i].GetQ()+neg[j].GetQ());
{
- Double_t loc[3]={ybest,0.,zbest},trk[3]={0.,0.,0.};
+ Double_t loc[3]={xbest,0.,zbest},trk[3]={0.,0.,0.};
mT2L->MasterToLocal(loc,trk);
lp[0]=trk[1];
lp[1]=trk[2];
}
}
}
+ delete [] cnegative;
+ delete [] cused1;
+ delete [] negativepair;
+ delete [] cpositive;
+ delete [] cused2;
+ delete [] positivepair;
}
return (AliITSCalibrationSSD*) fDetTypeRec->GetCalibrationModel(mod);}
Int_t fLastSSD1; //index of the last SSD1 detector
- Float_t fYpitchSSD; //strip pitch (cm)
- Float_t fHwSSD; //half-width of an SSD detector (cm)
- Float_t fHlSSD; //half-length of an SSD detector (cm)
- Float_t fTanP; //tangent of the stereo angle on the P side
- Float_t fTanN; //tangent of the stereo angle on the N side
-
static Short_t* fgPairs; //array used to build positive-negative pairs
static Int_t fgPairsSize; //actual size of pairs array
- ClassDef(AliITSClusterFinderV2SSD,1) // ITS cluster finder V2 for SDD
+ ClassDef(AliITSClusterFinderV2SSD,2) // ITS cluster finder V2 for SDD
};
#endif
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");
AliCDBEntry *drSpSDD = AliCDBManager::Instance()->Get("ITS/Calib/DriftSpeedSDD");
AliCDBEntry *ddlMapSDD = AliCDBManager::Instance()->Get("ITS/Calib/DDLMapSDD");
// AliCDBEntry *mapASDD = AliCDBManager::Instance()->Get("ITS/Calib/MapsAnodeSDD");
if(!entrySPD || !deadSPD || !entrySDD || !entryNoiseSSD || !entryGainSSD ||
!entryBadChannelsSSD ||
- !entry2SPD || !entry2SDD || !entry2SSD || !drSpSDD || !ddlMapSDD || !mapTSDD ){
+ !entry2SPD || !entry2SDD || !drSpSDD || !ddlMapSDD || !mapTSDD ){
AliFatal("Calibration object retrieval failed! ");
return kFALSE;
}
if(!cacheStatus)entryBadChannelsSSD->SetObject(NULL);
entryBadChannelsSSD->SetOwner(kTRUE);
- AliITSresponseSSD *pSSD = (AliITSresponseSSD*)entry2SSD->GetObject();
- if(!cacheStatus)entry2SSD->SetObject(NULL);
- entry2SSD->SetOwner(kTRUE);
-
// DB entries are deleted. In this way metadeta objects are deleted as well
if(!cacheStatus){
delete entrySPD;
delete entryBadChannelsSSD;
delete entry2SPD;
delete entry2SDD;
- delete entry2SSD;
//delete mapASDD;
delete mapTSDD;
delete drSpSDD;
delete ddlMapSDD;
}
- if ((!pSPD)||(!pSDD)||(!pSSD) || (!calSPD) || (!caldeadSPD) ||(!calSDD) || (!drSp) || (!ddlsdd)
+ if ((!pSPD)||(!pSDD)|| (!calSPD) || (!caldeadSPD) ||(!calSDD) || (!drSp) || (!ddlsdd)
|| (!mapT) || (!noiseSSD)|| (!gainSSD)|| (!badChannelsSSD)) {
AliWarning("Can not get calibration from calibration database !");
return kFALSE;
}
}
- fSSDCalibration->SetResponse((AliITSresponse*)pSSD);
fSSDCalibration->SetNoise(noiseSSD);
fSSDCalibration->SetGain(gainSSD);
fSSDCalibration->SetBadChannels(badChannelsSSD);
AliCDBEntry *entryBadChannelsSSD = AliCDBManager::Instance()->Get("ITS/Calib/BadChannelsSSD");
AliCDBEntry *entry2SPD = AliCDBManager::Instance()->Get("ITS/Calib/RespSPD", run);
- AliCDBEntry *entry2SSD = AliCDBManager::Instance()->Get("ITS/Calib/RespSSD", run);
if(!entrySPD || !entrySDD || !entryNoiseSSD || !entryGainSSD || !entryBadChannelsSSD ||
- !entry2SPD || !entry2SSD || !drSpSDD || !ddlMapSDD || !mapTSDD){
+ !entry2SPD || !drSpSDD || !ddlMapSDD || !mapTSDD){
AliFatal("Calibration object retrieval failed! ");
return kFALSE;
}
if(!isCacheActive)entryBadChannelsSSD->SetObject(NULL);
entryBadChannelsSSD->SetOwner(kTRUE);*/
- AliITSresponseSSD *pSSD = (AliITSresponseSSD*)entry2SSD->GetObject();
- if(!isCacheActive)entry2SSD->SetObject(NULL);
- entry2SSD->SetOwner(kTRUE);
-
// DB entries are deleted. In this way metadeta objects are deleted as well
if(!isCacheActive){
delete entrySPD;
delete entryGainSSD;
delete entryBadChannelsSSD;
delete entry2SPD;
- delete entry2SSD;
// delete mapASDD;
delete mapTSDD;
delete drSpSDD;
AliCDBManager::Instance()->SetCacheFlag(origCacheStatus);
- if ((!pSPD)||(!pSSD) || (!calSPD) || (!calSDD) || (!drSp) || (!ddlsdd)
+ if ((!pSPD)|| (!calSPD) || (!calSDD) || (!drSp) || (!ddlsdd)
|| (!mapT) || (!noiseSSD)|| (!gainSSD)|| (!badChannelsSSD)) {
AliWarning("Can not get calibration from calibration database !");
return kFALSE;
}
}
- fSSDCalibration->SetResponse((AliITSresponse*)pSSD);
fSSDCalibration->SetNoise(noiseSSD);
fSSDCalibration->SetGain(gainSSD);
fSSDCalibration->SetBadChannels(badChannelsSSD);
fSDDDynamicRange(fgkSDDDynamicRangeDefault),
fSDDMaxAdc(0.),
fSDDChargeLoss(fgkSDDChargeLossDefault),
-fSSDADCpereV(0.),
fSSDCouplingPR(0),
fSSDCouplingPL(0),
fSSDCouplingNR(0),
SetSDDElectronics();
SetSDDDiffCoeff(fgkSDDDiffCoeffDefault,fgkSDDDiffCoeff1Default);
SetSDDMaxAdc((Double_t)fgkSDDMaxAdcDefault);
- SetSSDADCpereV();
SetSSDCouplings(fgkSSDCouplingPRDefault,fgkSSDCouplingPLDefault,fgkSSDCouplingNRDefault,fgkSSDCouplingNLDefault);
}
//______________________________________________________________________
fSDDDynamicRange(simpar.fSDDDynamicRange),
fSDDMaxAdc(simpar.fSDDMaxAdc),
fSDDChargeLoss(simpar.fSDDChargeLoss),
-fSSDADCpereV(simpar.fSSDADCpereV),
fSSDCouplingPR(simpar.fSSDCouplingPR),
fSSDCouplingPL(simpar.fSSDCouplingPL),
fSSDCouplingNR(simpar.fSSDCouplingNR),
printf("Charge Loss = %f\n",fSDDChargeLoss);
printf("\n");
printf("===== SSD parameters =====\n");
- printf("ADC per eV = %f\n",fSSDADCpereV);
printf("Coupling PR = %f\n",fSSDCouplingPR);
printf("Coupling PL = %f\n",fSSDCouplingPL);
printf("Coupling NR = %f\n",fSSDCouplingNR);
void SetSDDChargeLoss(Double_t p1) {fSDDChargeLoss=p1;}
Float_t GetSDDChargeLoss() const {return fSDDChargeLoss;}
-
- void SetSSDADCpereV(Double_t a=120./24888.9){fSSDADCpereV = a;}
- Double_t GetSSDDEvToADC(Double_t eV) const {return eV*fSSDADCpereV;}
- Int_t GetSSDIEvToADC(Double_t eV) const {
- return ((Int_t) GetSSDDEvToADC(eV)); }
-
+ Int_t GetSSDZSThreshold() const { // ZS threshold
+ return fSSDZSThreshold; }
+ virtual void SetSSDZSThreshold(Int_t zsth) { fSSDZSThreshold = zsth; }
+
void SetSSDCouplings(Double_t pr, Double_t pl, Double_t nr, Double_t nl) {
fSSDCouplingPR=pr; fSSDCouplingPL=pl; fSSDCouplingNR=nr; fSSDCouplingNL=nl; }
Double_t GetSSDCouplingPR() const {return fSSDCouplingPR;}
Float_t fSDDMaxAdc; // SDD ADC saturation value
Float_t fSDDChargeLoss; // Set Linear Coefficient for Charge Loss
- Double_t fSSDADCpereV; // Constant to convert eV to ADC for SSD.
Double_t fSSDCouplingPR; // SSD couplings
Double_t fSSDCouplingPL; // SSD couplings
Double_t fSSDCouplingNR; // SSD couplings
+++ /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 "AliITSresponseSSD.h"
-//////////////////////////////////////////////////
-// Base response class for ITS //
-// It is used to set static data members //
-// connected to parameters equal for all //
-// the SSD modules //
-//////////////////////////////////////////////////
-
-
-const Float_t AliITSresponseSSD::fgkDiffCoeffDefault = 0.;
-const Double_t AliITSresponseSSD::fgkfCouplingPR = 0.01;
-const Double_t AliITSresponseSSD::fgkfCouplingPL = 0.01;
-const Double_t AliITSresponseSSD::fgkfCouplingNR = 0.01;
-const Double_t AliITSresponseSSD::fgkfCouplingNL = 0.01;
-const Int_t AliITSresponseSSD::fgkZSThreshold = 3;
-
-
-ClassImp(AliITSresponseSSD)
-
-//______________________________________________________________________
-AliITSresponseSSD::AliITSresponseSSD():AliITSresponse(),
-fADCpereV(0),
-fKeVperADC(0),
-fCouplingPR(0),
-fCouplingPL(0),
-fCouplingNR(0),
-fCouplingNL(9),
-fZSThreshold(0){
- // Default Constructor
-
- SetDiffCoeff(fgkDiffCoeffDefault,0.);
- SetADCpereV();
- SetKeVperADC();
- SetCouplings(fgkfCouplingPR,fgkfCouplingPL,fgkfCouplingNR,fgkfCouplingNL);
- SetZSThreshold(fgkZSThreshold);
-}
-
-//______________________________________________________________________
-AliITSresponseSSD::AliITSresponseSSD(const AliITSresponseSSD &ob) : AliITSresponse(ob),
-fADCpereV(ob.fADCpereV),
-fKeVperADC(ob.fKeVperADC),
-fCouplingPR(ob.fCouplingPR),
-fCouplingPL(ob.fCouplingPL),
-fCouplingNR(ob.fCouplingNR),
-fCouplingNL(ob.fCouplingNL),
-fZSThreshold(ob.fZSThreshold){
- // Copy constructor
-
-}
-
-//______________________________________________________________________
-AliITSresponseSSD& AliITSresponseSSD::operator=(const AliITSresponseSSD& ob){
- // Assignment operator
- this->~AliITSresponseSSD();
- new(this) AliITSresponseSSD(ob);
- return *this;
-}
-
+++ /dev/null
-#ifndef ALIITSRESPONSESSD_H
-#define ALIITSRESPONSESSD_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice */
-
-#include "AliITSresponse.h"
-#include <Riostream.h>
-
-///////////////////////////////////////////////////
-// Response class for SSD //
-// //
-///////////////////////////////////////////////////
-
-class AliITSresponseSSD : public AliITSresponse {
-
- public:
- AliITSresponseSSD();
- virtual ~AliITSresponseSSD() {;}
-
- void SetADCpereV(Double_t a=120./24888.9){fADCpereV = a;}
- Double_t DEvToADC(Double_t eV) const {return eV*fADCpereV;}
- Int_t IEvToADC(Double_t eV) const { // Converts electron-hole pairs to
- return ((Int_t) DEvToADC(eV)); }
-
- void SetKeVperADC(Double_t a=86.4/120.){fKeVperADC = a;}
- Double_t ADCToKeV(Double_t adc) const {return adc*fKeVperADC;}
-
- Double_t GetCouplingPR() const {// couplings
- return fCouplingPR;}
- Double_t GetCouplingPL() const {// couplings
- return fCouplingPL;}
- Double_t GetCouplingNR() const {// couplings
- return fCouplingNR;}
- Double_t GetCouplingNL() const {// couplings
- return fCouplingNL;}
- virtual void SetCouplings(Double_t pr, Double_t pl, Double_t nr, Double_t nl) {
- fCouplingPR=pr; fCouplingPL=pl; fCouplingNR=nr; fCouplingNL=nl; }
-
- Int_t GetZSThreshold() const { // ZS threshold
- return fZSThreshold; }
- virtual void SetZSThreshold(Int_t zsth) { fZSThreshold = zsth; }
-
-protected:
- static const Float_t fgkDiffCoeffDefault; //default for fDiffCoeff
-
- static const Double_t fgkfCouplingPR; // default value for couplings
- static const Double_t fgkfCouplingPL; // default value for couplings
- static const Double_t fgkfCouplingNR; // default value for couplings
- static const Double_t fgkfCouplingNL; // default value for couplings
-
- Double_t fADCpereV; // Constant to convert eV to ADC.
- Double_t fKeVperADC; // Constant to convert ADC to keV
-
- Double_t fCouplingPR; // couplings
- Double_t fCouplingPL; // couplings
- Double_t fCouplingNR; // couplings
- Double_t fCouplingNL; // couplings
-
- static const Int_t fgkZSThreshold; // threshold for the zero suppresion
- Int_t fZSThreshold;
-
-
- private:
- AliITSresponseSSD(const AliITSresponseSSD &source); // copy constructor
- AliITSresponseSSD& operator=(const AliITSresponseSSD &source); // ass. op.
-
- ClassDef(AliITSresponseSSD,5) //Response class for SSD
-};
-#endif
Dead region: |000/
|00/
|0/
- // expects x, z in microns
+ // expects x, z in cm
*/
/*
Float_t P=0;
Float_t N=0;
if(fLayer==5) {
- P = 105.26*x - 0.79*z + 381.89;
- N = P + 3.68*z - 4;
+ P = 105.26*x - 0.7895*z + 382.000; //- 0.79*z + 381.89;
+ N = P + 3.684*z - 4;
}
else if(fLayer==6) {
- P = -105.26*x - 0.79*z + 384.66;
- N = P + 3.68*z + 4;
+ P = -105.26*x - 0.7895*z + 385.000; //- 0.79*z + 384.66;
+ N = P + 3.684*z + 4;
}
else AliError("Layer can be 5 or 6");
//----------------------------------------------------------------------
void AliITSsegmentationSSD::GetPadIxz(Float_t x,Float_t z,Int_t &iP,Int_t &iN) const {
// returns P and N sided strip numbers for a given location.
- /* _- Z
- + angle / ^
- fNstrips v | N-Side ...0
- \-------/------------|-----------\--------\
- |\\\\\\/////////////.|\\\\\\\\\\\\\\\\\\\\|
- |0\\\\/////////////..|.\\\\\\\\\\\\\\\\\\\|
- |00\\/////////////...|..\\\\\\\\\\\\\\\\\\|
- X <--|000/////////////... |...\\\\\\\\\\\\\\\\\|
- |00/////////////... | ...\\\\\\\\\\\\\\\\|
- |0/////////////... | ...\\\\\\\\\\\\\\\|
- |//////////////... | ...\\\\\\\\\\\\\\\|
- /-----\--------------|--------------------/
- fNstrips-1 P-Side ...0
- |0\
- |00\
- Dead region: |000/
- |00/
- |0/
-
- // expects x, z in microns
- */
-
- Float_t stereoP, stereoN;
- Angles(stereoP,stereoN);
- Float_t tanP=TMath::Tan(stereoP);
- Float_t tanN=TMath::Tan(stereoN);
- Float_t x1=x,z1=z;
- x1 += fDx/2;
- z1 += fDz/2;
- Float_t ldX = x1 - z1*tanP; // distance from left-down edge
- iP = (Int_t)(ldX/fPitch);
- iP = (iP<0)? -1: iP;
- iP = (iP>fNstrips)? -1: iP;
-
- ldX = x1 - tanN*(fDz - z1);
- iN = (Int_t)(ldX/fPitch);
- iN = (iN<0)? -1: iN;
- iN = (iN>fNstrips)? -1: iN;
+ // expects x, z in cm
+ GetPadTxz(x,z);
+ iP = Int_t(x+0.5);
+ iN = Int_t(z+0.5);
}
//-------------------------------------------------------
-void AliITSsegmentationSSD::GetPadCxz(Int_t iP,Int_t iN,Float_t &x,Float_t &z) const {
+void AliITSsegmentationSSD::GetPadCxz(Float_t iP,Float_t iN,Float_t &x,Float_t &z) const {
// actually this is the GetCrossing(Float_t &,Float_t &)
- // returns local x, z in microns !
+ // returns local x, z in cm
+ const Float_t kStartXzero=3.64325;
+ const Float_t kDeltaXzero5or6=0.02239;
+ const Float_t kDeltaZ5to6=7.6/7.0;
- Float_t lDx = fDx; // detector size in x direction, microns
- Float_t lDz = fDz; // detector size in z direction, microns
- Float_t xP; // x coordinate in the P side from the first P strip
- Float_t xN; // x coordinate in the N side from the first N strip
- Float_t stereoP, stereoN;
- Angles(stereoP,stereoN);
- Float_t kP=TMath::Tan(stereoP);
- Float_t kN=TMath::Tan(stereoN);
-
- xP=iP*fPitch;
- xN=iN*fPitch;
- x = xP + kP*(lDz*kN-xP+xN)/(kP+kN);
- z = (lDz*kN-xP+xN)/(kP+kN);
- x -= lDx/2;
- z -= lDz/2;
- //if(TMath::Abs(z) > Dz/2) cout<<"Warning, wrong z local ="<<z<<endl;
- // Check that zL is inside the detector for the
- // correspondent xP and xN coordinates
+ z = 1.9*(iN-iP)/7.0;
+ x = kStartXzero-(285*iN + 1045*iP)/140000.0;
- return;
+ if (fLayer==5){
+ z += kDeltaZ5to6;
+ x = -x + kDeltaXzero5or6;
+ }
+ else if (fLayer==6) {
+ z -= kDeltaZ5to6;
+ x += kDeltaXzero5or6;
+ }
+ else {
+ AliWarning("Layer shoudl be 5 or 6");
+ x = -99999;
+ z = -99999;
+ }
}
//______________________________________________________________________
Bool_t AliITSsegmentationSSD::LocalToDet(Float_t x,Float_t z,
// x = a + b + z*tan(fStereoP); a = Dpx(iP)*(iP+0.5)-dx; b = dz*th;
// for strips n-side
// x = a + b + z*tan(fStereoP); a = Dpx(iN)*(iN+0.5)-dx; b = -dz*th;
+ AliWarning("This function has not been verified. Should probably use GetPadCxz");
const Double_t kconst = 1.0E-04; // convert microns to cm.
Float_t flag=kconst*Dx(); // error value
Double_t th=0.0,dx,dz,i,a,b=0.0,xb[4],zb[4];
z *= 0.5;
return;
}
-//----------------------------------------------------------------------
-Bool_t AliITSsegmentationSSD::GetCrossing(Int_t iP,Int_t iN,
- Float_t &x,Float_t &z,
- Float_t c[2][2]){
- // Given one P side strip and one N side strip, Returns kTRUE if they
- // cross each other and the location of the two crossing strips and
- // their correxlation matrix c[2][2].
- /* _- Z
- + angle / ^
- fNstrips v | N-Side ...0
- \-------/------------|-----------\--------\
- |\\\\\\/////////////.|\\\\\\\\\\\\\\\\\\\\|
- |0\\\\/////////////..|.\\\\\\\\\\\\\\\\\\\|
- |00\\/////////////...|..\\\\\\\\\\\\\\\\\\|
- X <--|000/////////////... |...\\\\\\\\\\\\\\\\\|
- |00/////////////... | ...\\\\\\\\\\\\\\\\|
- |0/////////////... | ...\\\\\\\\\\\\\\\|
- |//////////////... | ...\\\\\\\\\\\\\\\|
- /-----\--------------|--------------------/
- fNstrips-1 P-Side ...0
- |0\
- |00\
- Dead region: |000/
- |00/
- |0/
- c[2][2] is defined as follows
- /c[0][0] c[0][1]\ /delta iP\ = /delta x\
- \c[1][0] c[1][1]/ \delta iN/ = \delta z/
- */
- const Double_t kconst = 1.0E-04; // convert microns to cm.
- Double_t thp,thn,th,dx,dz,p,ip,in;
- Float_t stereoP, stereoN;
- Angles(stereoP,stereoN);
-
- thp = TMath::Tan(stereoP);
- thn = TMath::Tan(-stereoN);
- th = thp-thn;
- if(th==0.0) { // parall strips then never cross.
- x = 0.0;
- z = 0.0;
- c[0][0] = c[1][0] = c[0][1] = c[1][1] = 0.0;
- return kFALSE;
- } // end if
- // The strips must cross some place in space.
- ip = (Double_t) iP; // convert to double now for speed
- in = (Double_t) iN; // convert to double now for speed
- dx = 0.5*kconst*Dx(); // half distance in x in cm
- dz = 0.5*kconst*Dz(); // half distance in z in cm
- p = kconst*Dpx(iP); // Get strip spacing/pitch now
- x = 0.5*p+dx + (p*(in*thp-ip*thn)-2.0*dz*thp*thn)/th;
- z =(p*(in-ip)-dz*(thp+thn))/th;
- // compute correlations.
- c[0][0] = -thn*p/th; // dx/diP
- c[1][1] = p/th; // dz/diN
- c[0][1] = p*thp/th; // dx/diN
- c[1][0] = -p/th; // dz/diP
- if(x<-dx || x>dx || z<-dz || z>dz) return kFALSE; // crossing is outside
- // of the detector so
- // these strips don't
- // cross.
- return kTRUE;
-}
-
//----------------------------------------------------------------------
Int_t AliITSsegmentationSSD::GetChipFromChannel(Int_t ix, Int_t iz) const {
// returns chip number (in range 0-11) starting from channel number
// Transform from real coordinates to strips
virtual void GetPadIxz(Float_t x ,Float_t z ,Int_t &iP,Int_t &iN) const;
// Transform from strips to real coordinates
- virtual void GetPadCxz(Int_t iP, Int_t iN, Float_t &x , Float_t &z) const;
+ void GetPadCxz(Float_t iP, Float_t iN, Float_t &x , Float_t &z) const;
+ virtual void GetPadCxz(Int_t iP, Int_t iN, Float_t &x , Float_t &z) const { GetPadCxz((Float_t) iP, (Float_t) iN, x, z); }
virtual void GetPadTxz(Float_t &x , Float_t &z) const;
// Transformation from Geant cm detector center local coordinates
// to detector P and N side strip numbers..
// from 0. iPN=0 for P side and 1 for N side strip. Returned is z=0.0
// and the corresponding x value..
virtual void DetToLocal(Int_t ix,Int_t iPN,Float_t &x,Float_t &z) const;
- // Given one P side strip and one N side strip, Returns kTRUE if they
- // cross each other and the location of the two crossing strips and
- // their correxlation matrix c[2][2].
- virtual Bool_t GetCrossing(Int_t iP,Int_t iN,Float_t &x,Float_t &z,
- Float_t c[2][2]);
-
virtual Int_t GetNumberOfChips() const {
return fgkNchipsPerSide;
#include "AliITSgeom.h"
#include "AliITSsimulationSSD.h"
#include "AliITSTableSSD.h"
-//#include "AliITSresponseSSD.h"
ClassImp(AliITSsimulationSSD)
////////////////////////////////////////////////////////////////////////
Int_t ix;
Double_t signal,noise;
AliITSCalibrationSSD* res =(AliITSCalibrationSSD*)GetCalibrationModel(module);
-
+
// Pside
for(ix=0;ix<GetNStrips();ix++){ // loop over strips
// noise comes in ADC channels from the calibration database
// It needs to be converted back to electronVolts
- noise /= res->GetDEvToADC(1.);
+ noise /= res->GetSSDDEvToADC(1.);
// Finally, noise is added to the signal
signal = noise + fMapA2->GetSignal(0,ix);//get signal from map
for(ix=0;ix<GetNStrips();ix++){ // loop over strips
noise = (Double_t) gRandom->Gaus(0,res->GetNoiseN(ix));// give noise to signal
noise *= (Double_t) res->GetGainN(ix);
- noise /= res->GetDEvToADC(1.);
+ noise /= res->GetSSDDEvToADC(1.);
signal = noise + fMapA2->GetSignal(1,ix);//get signal from map
fMapA2->SetHit(1,ix,signal); // give back signal to map
if(signal>0.0) pList->AddNoise(1,ix,module,noise);
// Apply the effect of electronic coupling between channels
Int_t ix;
Double_t signal=0;
- AliITSCalibrationSSD* res =(AliITSCalibrationSSD*)GetCalibrationModel(module);
-
+ //AliITSCalibrationSSD* res =(AliITSCalibrationSSD*)GetCalibrationModel(module);
+ AliITSSimuParam* res = fDetType->GetSimuParam();
+
Double_t *contrLeft = new Double_t[GetNStrips()];
Double_t *contrRight = new Double_t[GetNStrips()];
// P side coupling
for(ix=0;ix<GetNStrips();ix++){
- if(ix>0) contrLeft[ix] = fMapA2->GetSignal(0,ix-1)*res->GetCouplingPL();
+ if(ix>0) contrLeft[ix] = fMapA2->GetSignal(0,ix-1)*res->GetSSDCouplingPL();
else contrLeft[ix] = 0.0;
- if(ix<(GetNStrips()-1)) contrRight[ix] = fMapA2->GetSignal(0,ix+1)*res->GetCouplingPR();
+ if(ix<(GetNStrips()-1)) contrRight[ix] = fMapA2->GetSignal(0,ix+1)*res->GetSSDCouplingPR();
else contrRight[ix] = 0.0;
} // loop over strips
for(ix=0;ix<GetNStrips();ix++){
- signal = contrLeft[ix] + contrRight[ix] - res->GetCouplingPL() * fMapA2->GetSignal(0,ix)
- - res->GetCouplingPR() * fMapA2->GetSignal(0,ix);
+ signal = contrLeft[ix] + contrRight[ix] - res->GetSSDCouplingPL() * fMapA2->GetSignal(0,ix)
+ - res->GetSSDCouplingPR() * fMapA2->GetSignal(0,ix);
fMapA2->AddSignal(0,ix,signal);
if(signal>0.0) pList->AddNoise(0,ix,module,signal);
} // loop over strips
// N side coupling
for(ix=0;ix<GetNStrips();ix++){
- if(ix>0) contrLeft[ix] = fMapA2->GetSignal(1,ix-1)*res->GetCouplingNL();
+ if(ix>0) contrLeft[ix] = fMapA2->GetSignal(1,ix-1)*res->GetSSDCouplingNL();
else contrLeft[ix] = 0.0;
- if(ix<(GetNStrips()-1)) contrRight[ix] = fMapA2->GetSignal(1,ix+1)*res->GetCouplingNR();
+ if(ix<(GetNStrips()-1)) contrRight[ix] = fMapA2->GetSignal(1,ix+1)*res->GetSSDCouplingNR();
else contrRight[ix] = 0.0;
} // loop over strips
for(ix=0;ix<GetNStrips();ix++){
- signal = contrLeft[ix] + contrRight[ix] - res->GetCouplingNL() * fMapA2->GetSignal(0,ix)
- - res->GetCouplingNR() * fMapA2->GetSignal(0,ix);
+ signal = contrLeft[ix] + contrRight[ix] - res->GetSSDCouplingNL() * fMapA2->GetSignal(0,ix)
+ - res->GetSSDCouplingNR() * fMapA2->GetSignal(0,ix);
fMapA2->AddSignal(1,ix,signal);
if(signal>0.0) pList->AddNoise(1,ix,module,signal);
} // loop over strips
Float_t charges[3] = {0.0,0.0,0.0};
Float_t signal;
AliITSCalibrationSSD* res =(AliITSCalibrationSSD*)GetCalibrationModel(module);
+ AliITSSimuParam* simpar = fDetType->GetSimuParam();
for(Int_t k=0;k<2;k++){ // both sides (0=Pside, 1=Nside)
for(Int_t ix=0;ix<GetNStrips();ix++){ // loop over strips
else signal /= res->GetGainN(ix);
// signal is converted in unit of ADC
- signal = res->GetDEvToADC(signal);
+ signal = res->GetSSDDEvToADC(signal);
if(signal>4096.) signal = 4096.;//if exceeding, accumulate last one
// threshold for zero suppression is set on the basis of the noise
if(k==0) threshold = res->GetNoiseP(ix);
else threshold = res->GetNoiseN(ix);
- threshold *= res->GetZSThreshold(); // threshold at 3 sigma noise
+ threshold *= simpar->GetSSDZSThreshold(); // threshold at 3 sigma noise
if(signal < threshold) continue;
//cout<<signal<<" "<<threshold<<endl;
#pragma link C++ class AliITSCalibration+;
#pragma link C++ class AliITSresponseSPD+;
#pragma link C++ class AliITSresponseSDD+;
-#pragma link C++ class AliITSresponseSSD+;
#pragma link C++ class AliITSCalibrationSPD-;
#pragma link C++ class AliITSCalibrationSDD+;
#pragma link C++ class AliITSCalibrationSSD+;
AliITSCalibration.cxx \
AliITSresponseSPD.cxx \
AliITSresponseSDD.cxx \
- AliITSresponseSSD.cxx \
AliITSCalibrationSPD.cxx \
AliITSCalibrationSDD.cxx \
AliITSCalibrationSSD.cxx \