SSD: updated segmentation class and cleanup of ClusterFinder (M. Van Leeuwen). Elimin...
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 29 Aug 2008 15:03:11 +0000 (15:03 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 29 Aug 2008 15:03:11 +0000 (15:03 +0000)
16 files changed:
ITS/AliITSCalibrationSSD.cxx
ITS/AliITSCalibrationSSD.h
ITS/AliITSClusterFinderSSD.h
ITS/AliITSClusterFinderV2SSD.cxx
ITS/AliITSClusterFinderV2SSD.h
ITS/AliITSDetTypeRec.cxx
ITS/AliITSDetTypeSim.cxx
ITS/AliITSSimuParam.cxx
ITS/AliITSSimuParam.h
ITS/AliITSresponseSSD.cxx [deleted file]
ITS/AliITSresponseSSD.h [deleted file]
ITS/AliITSsegmentationSSD.cxx
ITS/AliITSsegmentationSSD.h
ITS/AliITSsimulationSSD.cxx
ITS/ITSbaseLinkDef.h
ITS/libITSbase.pkg

index 1e2a0d0..592c080 100644 (file)
@@ -36,12 +36,17 @@ fNoise(0),
 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):
@@ -52,7 +57,9 @@ fNoise(0),
 fPedestal(0),
 fGain(0),
 fBadChannels(0),
-fIsBad(kFALSE){
+fIsBad(kFALSE) ,
+fSSDADCpereV(0.),
+fKeVperADC(0){
     // constructor
 
     SetDataType(dataType);
@@ -69,6 +76,8 @@ fIsBad(kFALSE){
     for(Int_t i=0;i<fgkChipsPerModule;i++){
       fIsChipBad[i]=kFALSE;
     }
+    SetSSDADCpereV();
+    SetKeVperADC();
 }
 //______________________________________________________________________
 AliITSCalibrationSSD::~AliITSCalibrationSSD(){
index 403ec7f..704e3d9 100644 (file)
@@ -7,13 +7,12 @@
 #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 {
@@ -95,27 +94,18 @@ 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
@@ -135,10 +125,13 @@ protected:
     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
index f45b35e..6f39f58 100644 (file)
@@ -14,7 +14,6 @@ class AliITSpackageSSD;
 class AliITSsegmentation;
 class AliITSsegmentationSSD;
 class AliITSresponse;
-class AliITSresponseSSD;
 class AliITSCalibration;
 class AliITSCalibrationSSD;
 
index d0f3bd2..13f97a8 100644 (file)
@@ -37,6 +37,7 @@
 #include "AliITSdigitSSD.h"
 #include "AliITSReconstructor.h"
 #include "AliITSCalibrationSSD.h"
+#include "AliITSsegmentationSSD.h"
 
 Short_t *AliITSClusterFinderV2SSD::fgPairs = 0x0;
 Int_t    AliITSClusterFinderV2SSD::fgPairsSize = 0;
@@ -45,25 +46,14 @@ ClassImp(AliITSClusterFinderV2SSD)
 
 
 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
 }
@@ -117,7 +107,6 @@ void AliITSClusterFinderV2SSD::FindClustersSSD(TClonesArray *alldigits) {
 
     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;
@@ -614,28 +603,30 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
   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) {
 
@@ -655,11 +646,11 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
       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
@@ -679,13 +670,13 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
       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
@@ -720,7 +711,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
     // 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){ 
@@ -741,19 +732,19 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
        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];
@@ -820,7 +811,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
     }
     
     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
@@ -837,15 +828,15 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
          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];
@@ -900,15 +891,16 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
          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];
@@ -969,7 +961,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
       //  
     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];
@@ -987,18 +979,17 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
          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];
@@ -1052,16 +1043,16 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
 
          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];
@@ -1121,7 +1112,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
   
     
     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
       //
@@ -1171,14 +1162,16 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
        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];
@@ -1237,7 +1230,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
   // 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++) {
@@ -1252,16 +1245,17 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
       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];
@@ -1304,5 +1298,11 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
       }
     }
   }
+  delete [] cnegative;
+  delete [] cused1;
+  delete [] negativepair;
+  delete [] cpositive;
+  delete [] cused2;
+  delete [] positivepair;
 
 }
index 3a1d9d9..d3b4e4a 100644 (file)
@@ -37,16 +37,10 @@ public:
     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
index 2b7fc6e..0898ce5 100644 (file)
@@ -461,7 +461,6 @@ Bool_t AliITSDetTypeRec::GetCalibration() {
   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");
@@ -469,7 +468,7 @@ Bool_t AliITSDetTypeRec::GetCalibration() {
 
   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;
   }    
@@ -547,10 +546,6 @@ Bool_t AliITSDetTypeRec::GetCalibration() {
   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;
@@ -561,14 +556,13 @@ Bool_t AliITSDetTypeRec::GetCalibration() {
     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;
@@ -614,7 +608,6 @@ Bool_t AliITSDetTypeRec::GetCalibration() {
     }
   }
 
-  fSSDCalibration->SetResponse((AliITSresponse*)pSSD);
   fSSDCalibration->SetNoise(noiseSSD);
   fSSDCalibration->SetGain(gainSSD);
   fSSDCalibration->SetBadChannels(badChannelsSSD);
index e97b5b1..27813a2 100644 (file)
@@ -447,10 +447,9 @@ Bool_t AliITSDetTypeSim::GetCalibration() {
   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;
   }    
@@ -545,10 +544,6 @@ Bool_t AliITSDetTypeSim::GetCalibration() {
   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;
@@ -557,7 +552,6 @@ Bool_t AliITSDetTypeSim::GetCalibration() {
     delete entryGainSSD;
     delete entryBadChannelsSSD;
     delete entry2SPD;
-    delete entry2SSD;
 //    delete mapASDD;   
     delete mapTSDD;
     delete drSpSDD;
@@ -566,7 +560,7 @@ Bool_t AliITSDetTypeSim::GetCalibration() {
   
   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;
@@ -620,7 +614,6 @@ Bool_t AliITSDetTypeSim::GetCalibration() {
     }
   }
 
-  fSSDCalibration->SetResponse((AliITSresponse*)pSSD);
   fSSDCalibration->SetNoise(noiseSSD);
   fSSDCalibration->SetGain(gainSSD);
   fSSDCalibration->SetBadChannels(badChannelsSSD);
index 97964bf..ac63cdf 100644 (file)
@@ -69,7 +69,6 @@ fSDDJitterError(fgkSDDJitterErrorDefault),
 fSDDDynamicRange(fgkSDDDynamicRangeDefault),
 fSDDMaxAdc(0.),
 fSDDChargeLoss(fgkSDDChargeLossDefault),
-fSSDADCpereV(0.),
 fSSDCouplingPR(0),
 fSSDCouplingPL(0),
 fSSDCouplingNR(0),
@@ -92,7 +91,6 @@ fT(300.)
   SetSDDElectronics();
   SetSDDDiffCoeff(fgkSDDDiffCoeffDefault,fgkSDDDiffCoeff1Default);
   SetSDDMaxAdc((Double_t)fgkSDDMaxAdcDefault);
-  SetSSDADCpereV();
   SetSSDCouplings(fgkSSDCouplingPRDefault,fgkSSDCouplingPLDefault,fgkSSDCouplingNRDefault,fgkSSDCouplingNLDefault);
 }
 //______________________________________________________________________
@@ -114,7 +112,6 @@ fSDDJitterError(simpar.fSDDJitterError),
 fSDDDynamicRange(simpar.fSDDDynamicRange),
 fSDDMaxAdc(simpar.fSDDMaxAdc),
 fSDDChargeLoss(simpar.fSDDChargeLoss),
-fSSDADCpereV(simpar.fSSDADCpereV),
 fSSDCouplingPR(simpar.fSSDCouplingPR),
 fSSDCouplingPL(simpar.fSSDCouplingPL),
 fSSDCouplingNR(simpar.fSSDCouplingNR),
@@ -183,7 +180,6 @@ void AliITSSimuParam::PrintParameters() const{
   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);
index 159aa48..4d28d30 100644 (file)
@@ -87,12 +87,10 @@ class AliITSSimuParam : public TObject {
   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;}
@@ -217,7 +215,6 @@ class AliITSSimuParam : public TObject {
   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
diff --git a/ITS/AliITSresponseSSD.cxx b/ITS/AliITSresponseSSD.cxx
deleted file mode 100644 (file)
index 00431ff..0000000
+++ /dev/null
@@ -1,74 +0,0 @@
-/**************************************************************************
- * 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;
-}
-
diff --git a/ITS/AliITSresponseSSD.h b/ITS/AliITSresponseSSD.h
deleted file mode 100644 (file)
index 7a1d650..0000000
+++ /dev/null
@@ -1,69 +0,0 @@
-#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
index 8ee73e2..3183732 100644 (file)
@@ -143,7 +143,7 @@ void AliITSsegmentationSSD::GetPadTxz(Float_t &x,Float_t &z) const{
        Dead region: |000/
                      |00/
                      |0/
-    // expects x, z in microns
+    // expects x, z in cm
     */
 
   /*
@@ -162,12 +162,12 @@ void AliITSsegmentationSSD::GetPadTxz(Float_t &x,Float_t &z) const{
   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");
 
@@ -178,71 +178,36 @@ void AliITSsegmentationSSD::GetPadTxz(Float_t &x,Float_t &z) const{
 //----------------------------------------------------------------------
 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,
@@ -324,6 +289,7 @@ void AliITSsegmentationSSD::DetToLocal(Int_t ix,Int_t iPN,
     // 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];
@@ -367,69 +333,6 @@ void AliITSsegmentationSSD::DetToLocal(Int_t ix,Int_t iPN,
     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
 
index 52ff9a2..ac61556 100644 (file)
@@ -35,7 +35,8 @@ public AliITSsegmentation {
     // 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..
@@ -44,12 +45,6 @@ public AliITSsegmentation {
     // 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;
index 4a06149..48de1a2 100644 (file)
@@ -34,7 +34,6 @@
 #include "AliITSgeom.h"
 #include "AliITSsimulationSSD.h"
 #include "AliITSTableSSD.h"
-//#include "AliITSresponseSSD.h"
 
 ClassImp(AliITSsimulationSSD)
 ////////////////////////////////////////////////////////////////////////
@@ -397,7 +396,7 @@ void AliITSsimulationSSD::ApplyNoise(AliITSpList *pList,Int_t module){
   Int_t ix;
   Double_t signal,noise;
   AliITSCalibrationSSD* res =(AliITSCalibrationSSD*)GetCalibrationModel(module);
-  
+   
   // Pside
   for(ix=0;ix<GetNStrips();ix++){      // loop over strips
     
@@ -412,7 +411,7 @@ void AliITSsimulationSSD::ApplyNoise(AliITSpList *pList,Int_t module){
     
     // 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
@@ -424,7 +423,7 @@ void AliITSsimulationSSD::ApplyNoise(AliITSpList *pList,Int_t module){
   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);
@@ -436,37 +435,38 @@ void AliITSsimulationSSD::ApplyCoupling(AliITSpList *pList,Int_t module) {
   // 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 
@@ -640,6 +640,7 @@ void AliITSsimulationSSD::ChargeToSignal(Int_t module,AliITSpList *pList) {
     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
@@ -656,7 +657,7 @@ void AliITSsimulationSSD::ChargeToSignal(Int_t module,AliITSpList *pList) {
        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
@@ -664,7 +665,7 @@ void AliITSsimulationSSD::ChargeToSignal(Int_t module,AliITSpList *pList) {
        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;
index d4dcbb0..dbc227d 100644 (file)
@@ -49,7 +49,6 @@
 #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+;
index 729edd4..2be365e 100644 (file)
@@ -28,7 +28,6 @@ SRCS =        AliITSgeom.cxx \
                AliITSCalibration.cxx \
                AliITSresponseSPD.cxx \
                AliITSresponseSDD.cxx \
-               AliITSresponseSSD.cxx \
                AliITSCalibrationSPD.cxx \
                AliITSCalibrationSDD.cxx \
                AliITSCalibrationSSD.cxx \