Changes in SSD segmentation and simulation classes in order to take into account...
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 26 Jun 2008 17:38:36 +0000 (17:38 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 26 Jun 2008 17:38:36 +0000 (17:38 +0000)
ITS/AliITSInitGeometry.cxx
ITS/AliITSsegmentationSSD.cxx
ITS/AliITSsegmentationSSD.h
ITS/AliITSsimulationSSD.cxx
ITS/AliITSvBeamTestITS04.cxx

index 45492a7..34bebcd 100644 (file)
@@ -1096,8 +1096,6 @@ Bool_t AliITSInitGeometry::InitSegmentationPPRasymmFMD(AliITSDetector idet,
        segSSD->SetPadSize(95.,0.); // strip x pitch in microns
        segSSD->SetNPads(768,2); // number of strips on each side, sides.
        segSSD->SetAngles(0.0075,0.0275); // strip angels rad P and N side.
-       segSSD->SetAnglesLay5(0.0075,0.0275);//strip angels rad P and N
-       segSSD->SetAnglesLay6(0.0275,0.0075);//strip angels rad P and N
        geom->ReSetShape(idet,segSSD);
     }break;
     default:{// Others, Note no kSDDp or kSSDp in this geometry.
index 8852313..8ee73e2 100644 (file)
@@ -42,10 +42,6 @@ fNstrips(0),
 fStereoP(0),
 fStereoN(0),
 fPitch(0),
-fStereoPl5(0),
-fStereoNl5(0),
-fStereoPl6(0),
-fStereoNl6(0),
 fLayer(0){
     // default constructor
   SetDetSize(fgkDxDefault,fgkDzDefault,fgkDyDefault);
@@ -77,10 +73,6 @@ void AliITSsegmentationSSD::Copy(TObject &obj) const {
   ((AliITSsegmentationSSD& ) obj).fNstrips = fNstrips;
   ((AliITSsegmentationSSD& ) obj).fStereoP = fStereoP;
   ((AliITSsegmentationSSD& ) obj).fStereoN = fStereoN;
-  ((AliITSsegmentationSSD& ) obj).fStereoPl5 = fStereoPl5;
-  ((AliITSsegmentationSSD& ) obj).fStereoNl5 = fStereoNl5;
-  ((AliITSsegmentationSSD& ) obj).fStereoPl6 = fStereoPl6;
-  ((AliITSsegmentationSSD& ) obj).fStereoNl6 = fStereoNl6;
   ((AliITSsegmentationSSD& ) obj).fLayer   = fLayer;
   ((AliITSsegmentationSSD& ) obj).fPitch   = fPitch;
   ((AliITSsegmentationSSD& ) obj).fLayer   = fLayer;
@@ -103,10 +95,6 @@ fNstrips(0),
 fStereoP(0),
 fStereoN(0),
 fPitch(0),
-fStereoPl5(0),
-fStereoNl5(0),
-fStereoPl6(0),
-fStereoNl6(0),
 fLayer(0){
     // copy constructor
   source.Copy(*this);
@@ -122,26 +110,15 @@ void AliITSsegmentationSSD::Init(){
 //----------------------------------------------------------------------
 void AliITSsegmentationSSD::Angles(Float_t &aP,Float_t &aN) const{
   // P and N side stereo angles
-    if (fLayer == 5){
-       aP = fStereoPl5;
-       aN = fStereoNl5;
-    } // end if
-    else if (fLayer == 6){
-       aP = fStereoPl6;
-       aN = fStereoNl6;
-    } // end if
-    else {
-      AliWarning("SSD layer not set in segmentation. Setting angles for layer 5");
-      aP = fStereoPl5;
-      aN = fStereoNl5;
-    }
+  aP = fStereoP;
+  aN = fStereoN;
 }
 //----------------------------------------------------------------------
 void AliITSsegmentationSSD::SetLayer(Int_t l){
   //set fLayer data member (only 5 or 6 are allowed)
     if (l==5) fLayer =5;
-    if (l==6) fLayer =6;
-    if((l!=5) && (l!=6))AliError(Form("Layer can be 5 or 6, not %d",l));
+    else if (l==6) fLayer =6;
+    else AliError(Form("Layer can be 5 or 6, not %d",l));
 }
 //----------------------------------------------------------------------
 void AliITSsegmentationSSD::GetPadTxz(Float_t &x,Float_t &z) const{
@@ -168,6 +145,8 @@ void AliITSsegmentationSSD::GetPadTxz(Float_t &x,Float_t &z) const{
                      |0/
     // expects x, z in microns
     */
+
+  /*
     Float_t stereoP, stereoN;
     Angles(stereoP,stereoN);
     Float_t tanP = TMath::Tan(stereoP);
@@ -178,6 +157,23 @@ void AliITSsegmentationSSD::GetPadTxz(Float_t &x,Float_t &z) const{
     z1 += fDz/2;
     x   = (x1 - z1*tanP)/fPitch;
     z   = (x1 - tanN*(z1 - fDz))/fPitch;
+  */
+
+  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; 
+  }
+  else if(fLayer==6) {
+    P = -105.26*x - 0.79*z + 384.66;
+    N = P + 3.68*z + 4;
+  }
+  else AliError("Layer can be 5 or 6");
+
+  x=P;
+  z=N;
+
 }
 //----------------------------------------------------------------------
 void AliITSsegmentationSSD::GetPadIxz(Float_t x,Float_t z,Int_t &iP,Int_t &iN) const {
@@ -287,8 +283,8 @@ Bool_t AliITSsegmentationSSD::LocalToDet(Float_t x,Float_t z,
     return kFALSE; // outside of defined volume.
   }
   
-  x /= kconst;  // convert to microns
-  z /= kconst;  // convert to microns
+  //x /= kconst;  // convert to microns
+  //z /= kconst;  // convert to microns
   this->GetPadTxz(x,z);
   
   // first for P side
index 91d043e..52ff9a2 100644 (file)
@@ -29,14 +29,7 @@ public AliITSsegmentation {
 
     // Set stereo angles Pside-Nside 
     virtual void    SetAngles(Float_t pa=0.0075, Float_t na=0.0275) 
-                         {fStereoPl5=pa; fStereoNl5=na;
-                        fStereoPl6=na; fStereoNl6=pa;}
-
-    virtual void    SetAnglesLay5(Float_t pa=0.0075, Float_t na=0.0275) 
-                         {fStereoPl5=pa; fStereoNl5=na;}
-
-    virtual void    SetAnglesLay6(Float_t pa=0.0275, Float_t na=0.0075) 
-                         {fStereoPl6=pa; fStereoNl6=na;}
+                         {fStereoP=pa; fStereoN=na;}
 
     // Set stereo angles Pside-Nside 
     // Transform from real coordinates to strips
@@ -92,10 +85,6 @@ public AliITSsegmentation {
   Float_t    fStereoN;       // Stereo angle for Nside (rad)
   Float_t    fPitch;         // Pitch of the strips
   
-  Float_t    fStereoPl5;       // Stereo angle for Pside
-  Float_t    fStereoNl5;       // Stereo angle for Nside
-  Float_t    fStereoPl6;       // Stereo angle for Pside
-  Float_t    fStereoNl6;       // Stereo angle for Nside
   Int_t      fLayer;           //! layer number (5 or 6)
   static const Float_t fgkDxDefault;  // Default value for fDx
   static const Float_t fgkDzDefault;  // Default value for fDz
@@ -105,7 +94,7 @@ public AliITSsegmentation {
   static const Int_t fgkNchipsPerSide;    //number of chips per side
   static const Int_t fgkNstripsPerChip;    //number of strips per chip
 
-  ClassDef(AliITSsegmentationSSD,3) //Segmentation class for SSD 
+  ClassDef(AliITSsegmentationSSD,4) //Segmentation class for SSD 
 };
 
 #endif
index 02f8d34..4c01c9b 100644 (file)
@@ -41,7 +41,7 @@ ClassImp(AliITSsimulationSSD)
 //                                                                    //
 // Author: Enrico Fragiacomo                                          //
 //         enrico.fragiacomo@ts.infn.it                               //
-// Last revised: march 2006                                           // 
+// Last revised: june 2008                                            // 
 //                                                                    //
 // AliITSsimulationSSD is the simulation of SSD.                     //
 ////////////////////////////////////////////////////////////////////////
@@ -222,33 +222,33 @@ void AliITSsimulationSSD::HitsToAnalogDigits(AliITSmodule *mod,
   
   AliITSsegmentationSSD* seg = (AliITSsegmentationSSD*)GetSegmentationModel(2);
   
-    TObjArray *hits = mod->GetHits();
-    Int_t nhits     = hits->GetEntriesFast();
-    if (nhits<=0) return;
-    AliITSTableSSD * tav = new AliITSTableSSD(GetNStrips());
-    module = mod->GetIndex();
-    if ( mod->GetLayer() == 6 ) seg->SetLayer(6);
-    if ( mod->GetLayer() == 5 ) seg->SetLayer(5);
-    for(Int_t i=0; i<nhits; i++) {    
-      // LineSegmentL returns 0 if the hit is entering
-      // If hits is exiting returns positions of entering and exiting hits
-      // Returns also energy loss
-      if(GetDebug(4)){
-       cout << i << " ";
-       cout << mod->GetHit(i)->GetXL() << " "<<mod->GetHit(i)->GetYL();
-       cout << " " << mod->GetHit(i)->GetZL();
-       cout << endl;
-      } // end if
-      if (mod->LineSegmentL(i, x0, x1, y0, y1, z0, z1, de, idtrack)) {
-       HitToDigit(module, x0, y0, z0, x1, y1, z1, de,tav);
-       if (lasttrack != idtrack || i==(nhits-1)) {
-         GetList(idtrack,i,module,pList,tav);
-       } // end if
-       lasttrack=idtrack;
+  TObjArray *hits = mod->GetHits();
+  Int_t nhits     = hits->GetEntriesFast();
+  if (nhits<=0) return;
+  AliITSTableSSD * tav = new AliITSTableSSD(GetNStrips());
+  module = mod->GetIndex();
+  if ( mod->GetLayer() == 6 ) seg->SetLayer(6);
+  if ( mod->GetLayer() == 5 ) seg->SetLayer(5);
+  for(Int_t i=0; i<nhits; i++) {    
+    // LineSegmentL returns 0 if the hit is entering
+    // If hits is exiting returns positions of entering and exiting hits
+    // Returns also energy loss
+    if(GetDebug(4)){
+      cout << i << " ";
+      cout << mod->GetHit(i)->GetXL() << " "<<mod->GetHit(i)->GetYL();
+      cout << " " << mod->GetHit(i)->GetZL();
+      cout << endl;
+    } // end if
+    if (mod->LineSegmentL(i, x0, x1, y0, y1, z0, z1, de, idtrack)) {
+      HitToDigit(module, x0, y0, z0, x1, y1, z1, de,tav);
+      if (lasttrack != idtrack || i==(nhits-1)) {
+       GetList(idtrack,i,module,pList,tav);
       } // end if
-    }  // end loop over hits
-    delete tav; tav=0;
-    return;
+      lasttrack=idtrack;
+    } // end if
+  }  // end loop over hits
+  delete tav; tav=0;
+  return;
 }
 //----------------------------------------------------------------------
 void AliITSsimulationSSD::HitToDigit(Int_t module, Double_t x0, Double_t y0, 
@@ -260,8 +260,8 @@ void AliITSsimulationSSD::HitToDigit(Int_t module, Double_t x0, Double_t y0,
   
   AliITSsegmentationSSD* seg = (AliITSsegmentationSSD*)GetSegmentationModel(2);
   // Turns hits in SSD module into one or more digits.
-  Float_t tang[2] = {0.0,0.0};
-  seg->Angles(tang[0], tang[1]);//stereo<<->tan(stereo)~=stereo
+  //Float_t tang[2] = {0.0,0.0};
+  //seg->Angles(tang[0], tang[1]);//stereo<<->tan(stereo)~=stereo
   Double_t x, y, z;
   Double_t dex=0.0, dey=0.0, dez=0.0; 
   Double_t pairs; // pair generation energy per step.
@@ -276,7 +276,12 @@ void AliITSsimulationSSD::HitToDigit(Int_t module, Double_t x0, Double_t y0,
   // Enery loss is equally distributed among steps
   de    = de/numOfSteps;
   pairs = de/GetIonizeE(); // e-h pairs generated
+
+  //-----------------------------------------------------
+  // stepping
+  //-----------------------------------------------------
   for(Int_t j=0; j<numOfSteps; j++) {     // stepping
+
     x = x0 + (j+0.5)*dex;
     y = y0 + (j+0.5)*dey;
     if ( y > (seg->Dy()/2+10)*1.0E-4 ) {
@@ -287,48 +292,102 @@ void AliITSsimulationSSD::HitToDigit(Int_t module, Double_t x0, Double_t y0,
       return;
     } // end if
     z = z0 + (j+0.5)*dez;
+
     if(GetDebug(4)) cout <<"HitToDigit "<<x<<" "<<y<<" "<<z<< " "
                         <<dex<<" "<<dey<<" "<<dez<<endl;
+
+    if(seg->GetLayer()==6) {
+      y=-y; // Lay6 module has sensor up-side-down!!!
+    }
+    
+    // w is the coord. perpendicular to the strips
+    //    Float_t xp=x*1.e+4,zp=z*1.e+4; // microns    
+    Float_t xp=x,zp=z; 
+    seg->GetPadTxz(xp,zp);
+
+    Int_t k;
+    //---------------------------------------------------------
+    // Pside
+    //------------------------------------------------------------
+    k=0;
+    
     // calculate drift time
     // y is the minimum path
     tdrift[0] = (y+(seg->Dy()*1.0E-4)/2)/GetDriftVelocity(0);
+    
+    w = xp; // P side strip number
+    
+    if((w<(-0.5)) || (w>(GetNStrips()-0.5))) {
+      // this check rejects hits in regions not covered by strips
+      // 0.5 takes into account boundaries 
+      if(GetDebug(4)) cout << "Dead SSD region, x,z="<<x<<","<<z<<endl;
+      return; // There are dead region on the SSD sensitive volume!!!
+    } // end if
+    
+      // sigma is the standard deviation of the diffusion gaussian
+    if(tdrift[k]<0) return;
+    
+    sigma[k] = TMath::Sqrt(2*GetDiffConst(k)*tdrift[k]);
+    sigma[k] /= (GetStripPitch()*1.0E-4);  //units of Pitch
+    
+    if(sigma[k]==0.0) {        
+      Error("HitToDigit"," sigma[%d]=0",k);
+      exit(0);
+    } // end if
+    
+    par0[k] = pairs;
+    // we integrate the diffusion gaussian from -3sigma to 3sigma 
+    inf[k] = w - 3*sigma[k]; // 3 sigma from the gaussian average  
+    sup[k] = w + 3*sigma[k]; // 3 sigma from the gaussian average
+    // IntegrateGaussian does the actual
+    // integration of diffusion gaussian
+    IntegrateGaussian(k, par0[k], w, sigma[k], inf[k], sup[k],tav);
+    
+    //------------------------------------------------------
+    // end Pside
+    //-------------------------------------------------------
+    
+    //------------------------------------------------------
+    // Nside
+    //-------------------------------------------------------
+    k=1;
     tdrift[1] = ((seg->Dy()*1.0E-4)/2-y)/GetDriftVelocity(1);
     
-    for(Int_t k=0; k<2; k++) {   // both sides    remember: 0=Pside 1=Nside
-      
-      tang[k]=TMath::Tan(tang[k]);
-      
-      // w is the coord. perpendicular to the strips
-      Float_t xp=x*1.e+4,zp=z*1.e+4; // microns
-      seg->GetPadTxz(xp,zp);
-      if(k==0) w = xp; // P side strip number
-      else w = zp; // N side strip number
-      
-      if((w<(-0.5)) || (w>(GetNStrips()-0.5))) {
-       // this check rejects hits in regions not covered by strips
-       // 0.5 takes into account boundaries 
-       if(GetDebug(4)) cout << "x,z="<<x<<","<<z<<" w="<<w
-                            <<" Nstrips="<<GetNStrips()<<endl;
-       return; // There are dead region on the SSD sensitive volume.
-      } // end if
-      
+    //tang[k]=TMath::Tan(tang[k]);
+    
+    w = zp; // N side strip number
+    
+    if((w<(-0.5)) || (w>(GetNStrips()-0.5))) {
+      // this check rejects hits in regions not covered by strips
+      // 0.5 takes into account boundaries 
+      if(GetDebug(4)) cout << "Dead SSD region, x,z="<<x<<","<<z<<endl;
+      return; // There are dead region on the SSD sensitive volume.
+    } // end if
+    
       // sigma is the standard deviation of the diffusion gaussian
-      if(tdrift[k]<0) return;
-      sigma[k] = TMath::Sqrt(2*GetDiffConst(k)*tdrift[k]);
-      sigma[k] /= (GetStripPitch()*1.0E-4);  //units of Pitch
-      if(sigma[k]==0.0) {      
-       Error("HitToDigit"," sigma[%d]=0",k);
-       exit(0);
-      } // end if
-      
-      par0[k] = pairs;
-      // we integrate the diffusion gaussian from -3sigma to 3sigma 
-      inf[k] = w - 3*sigma[k]; // 3 sigma from the gaussian average  
-      sup[k] = w + 3*sigma[k]; // 3 sigma from the gaussian average
-      // IntegrateGaussian does the actual
-      // integration of diffusion gaussian
-      IntegrateGaussian(k, par0[k], w, sigma[k], inf[k], sup[k],tav);
-    }  // end for loop over side (0=Pside, 1=Nside)      
+    if(tdrift[k]<0) return;
+    
+    sigma[k] = TMath::Sqrt(2*GetDiffConst(k)*tdrift[k]);
+    sigma[k] /= (GetStripPitch()*1.0E-4);  //units of Pitch
+    
+    if(sigma[k]==0.0) {        
+      Error("HitToDigit"," sigma[%d]=0",k);
+      exit(0);
+    } // end if
+    
+    par0[k] = pairs;
+    // we integrate the diffusion gaussian from -3sigma to 3sigma 
+    inf[k] = w - 3*sigma[k]; // 3 sigma from the gaussian average  
+    sup[k] = w + 3*sigma[k]; // 3 sigma from the gaussian average
+    // IntegrateGaussian does the actual
+    // integration of diffusion gaussian
+    IntegrateGaussian(k, par0[k], w, sigma[k], inf[k], sup[k],tav);
+    
+    //-------------------------------------------------
+    // end Nside
+    //-------------------------------------------------
+    
+    
   } // end stepping
 }
 
index 829de0b..e2245cf 100644 (file)
@@ -431,8 +431,6 @@ void AliITSvBeamTestITS04::SetDefaults()
       seg2->SetPadSize(95.,0.); // strip x pitch in microns
       seg2->SetNPads(768,0); // number of strips on each side.
       seg2->SetAngles(0.0075,0.0275); // strip angels rad P and N side.
-      seg2->SetAnglesLay5(0.0075,0.0275); // strip angels rad P and N side.
-      seg2->SetAnglesLay6(0.0275,0.0075); // strip angels rad P and N side.
       SetSegmentationModel(kSSD,seg2); 
     }