Possibility of switching on Lorentz drift in SPD (G. Bruno)

[u/mrichter/AliRoot.git] / ITS / AliITSsegmentationSSD.h

diff --git a/ITS/AliITSsegmentationSSD.h b/ITS/AliITSsegmentationSSD.h
index 912682b7723e13980aeb9bea8cdb47702aa0b5f9..74332009f5c4459c156712c0190a7f3ed045c8a5 100644 (file)
--- a/ITS/AliITSsegmentationSSD.h
+++ b/ITS/AliITSsegmentationSSD.h
@@ -11,25 +11,19 @@ public AliITSsegmentation {
 
     AliITSsegmentationSSD();
     AliITSsegmentationSSD(AliITSgeom *gm);
-    AliITSsegmentationSSD(AliITSsegmentationSSD &source);
+    AliITSsegmentationSSD(const AliITSsegmentationSSD &source);
     virtual ~AliITSsegmentationSSD(){}
-    AliITSsegmentationSSD& operator=(AliITSsegmentationSSD &source);
+    AliITSsegmentationSSD& operator=(const AliITSsegmentationSSD &source);
 
 
-    // Detector size: x,z,y 
-    virtual void    SetDetSize(Float_t p1=72960.,Float_t p2=40000.,
-                              Float_t p3= 300.) 
-                        {fDx=p1; fDz=p2; fDy=p3;}
-
     // Strip size  
-    virtual void    SetPadSize(Float_t pitch=95., Float_t dummy=1.) 
-                         {fPitch=pitch;}
+    virtual void    SetPadSize(Float_t pitch,Float_t /* d */)
+       {fPitch=pitch;}
 
     // Maximum number of strips along the two coordinates  
-    virtual void    SetNPads(Int_t p1=768, Int_t dummy=1) 
-                         {fNstrips=p1;}
+    virtual void    SetNPads(Int_t p1,Int_t /* d */){fNstrips=p1;}
     // Returns the maximum number of cells (digits) posible
-    virtual Int_t   GetNPads(){return 2*fNstrips;}
+    virtual Int_t   GetNPads() const {return 2*fNstrips;}
 
 
     // Set stereo angles Pside-Nside 
@@ -45,22 +39,17 @@ public AliITSsegmentation {
 
     // Set stereo angles Pside-Nside 
     // Transform from real coordinates to strips
-    virtual void    GetPadIxz(Float_t x ,Float_t z ,Int_t   &iP,Int_t  &iN);
+    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);
-    virtual void    GetPadTxz(Float_t &x , Float_t &z);
-
-    // Transform from real global to local coordinates
-    virtual void    GetLocal(Int_t module,Float_t *g ,Float_t *l) {}
-    // Transform from real local to global coordinates
-    virtual void    GetGlobal(Int_t module,Float_t *l ,Float_t *g) {}
+    virtual void    GetPadCxz(Int_t iP, Int_t iN, Float_t &x , Float_t &z) const;
+    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..
-    virtual void    LocalToDet(Float_t x,Float_t z,Int_t &iP,Int_t &iN);
+    virtual Bool_t  LocalToDet(Float_t x,Float_t z,Int_t &iP,Int_t &iN) const;
     // Transformation from detector segmentation/cell coordiantes starting
     // 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);
+    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].
@@ -69,48 +58,43 @@ public AliITSsegmentation {
 
     virtual void Init();
 
-    // Detector type geometry
-    virtual AliITSgeom* Geometry() {return 0;}
-    // Detector length
-    virtual Float_t Dx() {return fDx;}
-    // Detector width
-    virtual Float_t Dz() {return fDz;}
-    // Detector thickness
-    virtual Float_t Dy() {return fDy;}
     // Strip size in x
-    virtual Float_t Dpx(Int_t) {return fPitch;}
+    virtual Float_t Dpx(Int_t) const {return fPitch;}
     // Strip size in z 
-    virtual Float_t Dpz(Int_t) {return fDz;}
+    virtual Float_t Dpz(Int_t) const {return fDz;}
     // Maximum number of Strips in x
-    virtual Int_t    Npx() {return fNstrips;}
+    virtual Int_t    Npx() const {return fNstrips;}
     // Maximum number of Strips in z
-    virtual Int_t    Npz(){return 1;}
+    virtual Int_t    Npz()const {return 1;}
 
     // Angles : Pside stereo angle-Nside stereo angle
-     virtual void Angles(Float_t &aP,Float_t &aN);
+     virtual void Angles(Float_t &aP,Float_t &aN) const;
      virtual void SetLayer(Int_t l);
      virtual Int_t GetLayer() const {return fLayer;}
+    // Print Default parameters
+     virtual void PrintDefaultParameters() const;
 
   protected:
 
+  virtual void Copy(TObject &obj) const; 
+
   Int_t      fNstrips;       // Number of strips in x 
   Float_t    fStereoP;       // Stereo angle for Pside (rad)
   Float_t    fStereoN;       // Stereo angle for Nside (rad)
   Float_t    fPitch;         // Pitch of the strips
-  Float_t    fDz;            // Full width of the detector (z axis)- microns
-  Float_t    fDx;            // Full length of the detector (x axis)- microns
-  Float_t    fDy;            // Full thickness of the detector (y axis) -um 
   
   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;
-
-  AliITSgeom *fGeom;         //! pointer to the geometry class
-  TF1*       fCorr;          // correction function
-  
-  ClassDef(AliITSsegmentationSSD,1) //Segmentation class for SSD 
+  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
+  static const Float_t fgkDyDefault;  // Default value for fDy
+  static const Float_t fgkPitchDefault; //Default value for fPitch
+  static const Int_t fgkNstripsDefault; //Default value for fNstrips
+
+  ClassDef(AliITSsegmentationSSD,2) //Segmentation class for SSD 
 };
 
 #endif