New plots for trending injector efficiencies (Melinda)
[u/mrichter/AliRoot.git] / ITS / AliITSsegmentationSDD.h
index a701de3..dacd449 100644 (file)
 
 
 #include "AliITSsegmentation.h"
-#include "AliITSresponse.h"
-
-// segmentation for SDD
 
+//////////////////////////////////////////////////////
+// Segmentation class for SDD                       //
+//                                                  //
+//////////////////////////////////////////////////////
 class AliITSsegmentationSDD :
 public AliITSsegmentation {
  public:
 
 
-    AliITSsegmentationSDD();
-    AliITSsegmentationSDD(AliITSgeom *gm, AliITSresponse *resp);
-    AliITSsegmentationSDD(AliITSsegmentationSDD &source);
+    AliITSsegmentationSDD(Option_t *opt="");
+    AliITSsegmentationSDD(const AliITSsegmentationSDD &source);
+    AliITSsegmentationSDD& operator=(const AliITSsegmentationSDD &source);
     virtual ~AliITSsegmentationSDD(){}
-    AliITSsegmentationSDD& operator=(AliITSsegmentationSDD &source);
 
     // Set Detector Segmentation Parameters
     //
-    // Detector size : x,z,y
-  virtual  void   SetDetSize
-          (Float_t p1=35000., Float_t p2=75264., Float_t p3= 300.) 
-          {fDx=p1; fDz=p2; fDy=p3;}
-
+    // get the drift speed used for this segmentation
+    virtual Float_t GetDriftSpeed()const{return fDriftSpeed;}
+    // Set the drift speed needed for this segmentation
+    virtual void SetDriftSpeed(Float_t ds){
+      fDriftSpeed = ds;
+      fSetDriftSpeed=kTRUE;
+    }
     // Cell size dz*dx  
-    virtual void    SetPadSize(Float_t pitch=294., Float_t clock=40.) 
+    virtual void    SetPadSize(Float_t pitch, Float_t clock) 
                          {fPitch=pitch;fTimeStep=1000./clock;}
 
     // Maximum number of cells along the two coordinates z,x (anodes,samples) 
-    virtual void    SetNPads(Int_t p1=256, Int_t p2=256) 
+    virtual void    SetNPads(Int_t p1, Int_t p2) 
                          {fNanodes=2*p1;fNsamples=p2;}
+    // Returns the maximum number of cells (digits) posible
+    virtual Int_t   GetNPads() const {return fNanodes*fNsamples;}
 
     // Transform from real local to cell coordinates
-    virtual void    GetPadIxz(Float_t x ,Float_t z ,Int_t   &ix,Int_t   &iz);
+    virtual void    GetPadIxz(Float_t x ,Float_t z ,Int_t   &ix,Int_t   &iz) const;
     // Transform from cell to real local coordinates
-    virtual void    GetPadCxz(Int_t   ix,Int_t   iz,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   ix,Int_t   iz,Float_t &x ,Float_t &z ) const;    
+
     // Get anode and time bucket as floats - numbering from 0
-    virtual void    GetPadTxz(Float_t &x ,Float_t &z);
+    virtual void    GetPadTxz(Float_t &x ,Float_t &z) const;
+    // Transformation from Geant cm detector center local coordinates
+    // to detector segmentation/cell coordiantes starting from (0,0).
+    virtual Bool_t  LocalToDet(Float_t x,Float_t z,Int_t &ix,Int_t &iz) const;
+    // Transformation from detector segmentation/cell coordiantes starting
+    // from (0,0) to Geant cm detector center local coordinates.
+    virtual void    DetToLocal(Int_t ix,Int_t iz,Float_t &x,Float_t &z) const;
     //
+    virtual Float_t GetAnodeFromLocal(Float_t x,Float_t z) const;
+    virtual Int_t   GetSideFromLocalX(Float_t xloc) const {
+      if(xloc>0) return 0;   // left side (channel 0) positive xloc
+      else return 1;         // right side (channel 1) negative xloc
+    }
+    virtual Float_t GetLocalZFromAnode(Int_t nAnode) const;
+    virtual Float_t GetLocalZFromAnode(Float_t zAnode) const;
+    virtual Float_t GetDriftTimeFromTb(Int_t tb) const {
+      Float_t xtb=(Float_t)tb+0.5;
+      return GetDriftTimeFromTb(xtb);
+    }
+    virtual Float_t GetDriftTimeFromTb(Float_t xtb) const {
+      return xtb*fTimeStep;
+    }
+    virtual Int_t    GetNumberOfChips() const {
+      return fgkNchipsPerHybrid;
+    }
+    virtual Int_t    GetMaximumChipIndex() const{
+      return fgkNchipsPerHybrid*2-1;
+    }
+    virtual Int_t    GetChipFromLocal(Float_t xloc, Float_t zloc) const;
+    virtual Int_t    GetChipsInLocalWindow(Int_t* array, Float_t zmin, Float_t zmax, Float_t xmin, Float_t xmax) const;
+      
+
+    virtual Int_t    GetChipFromChannel(Int_t ix, Int_t iz) const; 
+
     // Initialisation
     virtual void Init();
+
     //
     // Get member data
     //
-    // Detector type geometry
-    virtual AliITSgeom* Geometry() {return fGeom;}
-    // Detector length
-    virtual Float_t Dx() {return fDx;}
-    // Detector width
-    virtual Float_t Dz()  {return fDz;}  
-    // Detector thickness
-    virtual Float_t Dy() {return fDy;}
     // Cell size in x
-    virtual Float_t Dpx(Int_t dummy) {return fTimeStep;}
+    virtual Float_t Dpx(Int_t) const {return fTimeStep;}
     // Cell size in z 
-    virtual Float_t Dpz(Int_t dummy) {return fPitch;} 
+    virtual Float_t Dpz(Int_t) const {return fPitch;} 
 
     // Maximum number of samples in x
-    virtual Int_t    Npx() {return fNsamples;}
+    virtual Int_t    Npx() const {return fNsamples;}
+    // Maximum number of anodes in z
+    virtual Int_t    Npz() const {return fNanodes;}
     // Maximum number of anodes in z
-    virtual Int_t    Npz() {return fNanodes;}
+    virtual Int_t    NpzHalf() const {return fNanodes/2;}
 
     //
     // Get next neighbours 
-    virtual void Neighbours
-      (Int_t iX, Int_t iZ, Int_t* Nlist, Int_t Xlist[10], Int_t Zlist[10]);
-
-    // Set cell position
-    virtual void     SetPad(Int_t, Int_t) {}
-    // Set hit position
-    virtual void     SetHit(Float_t, Float_t) {}
-    
-    //
-    // Iterate over cells 
-    // Initialiser
-    virtual void  FirstPad
-          (Float_t xhit, Float_t zhit, Float_t dx, Float_t dz) {}
-    // Stepper
-    virtual void  NextPad() {}
-    // Condition
-    virtual Int_t MorePads() {return 0;}
-    //
-    // Current cell cursor during disintegration
-    // x-coordinate
-    virtual Int_t  Ix() {return 0;}
-    // z-coordinate
-    virtual Int_t  Iz() {return 0;}
-    //
-    // Signal Generation Condition during Stepping
-    virtual Int_t SigGenCond(Float_t x, Float_t y, Float_t z) {return 0;}
-    // Initialise signal generation at coord (x,y,z)
-    virtual void  SigGenInit(Float_t x, Float_t y, Float_t z) {}
-    // Current integration limits 
-    virtual void  IntegrationLimits
-    (Float_t& x1, Float_t& x2, Float_t& z1, Float_t& z2) {}
-    // Test points for auto calibration
-    virtual void GiveTestPoints(Int_t &n, Float_t *x, Float_t *z) {}
-    // Function for systematic corrections
-    // Set the correction function
-    virtual void SetCorrFunc(Int_t, TF1*) {}
-    // Get the correction Function
-    virtual TF1* CorrFunc(Int_t) {return 0;}
-           
-  protected:
+    virtual void Neighbours(Int_t iX,Int_t iZ,Int_t* Nlist,Int_t Xlist[10],
+                           Int_t Zlist[10]) const;
 
-    Int_t      fNsamples;      // Number of time samples in x
-    Int_t      fNanodes;       // Summed # of anodes in the two det halves (z)
-    Float_t    fPitch;         // Anode pitch - microns
-    Float_t    fTimeStep;      // Sampling time - ns
-    Float_t    fDx   ;         // Full width of the detector (x axis) - microns
-    Float_t    fDz    ;        // Length of half-detector (z axis) - microns
-    Float_t    fDy;            // Full thickness of the detector (y axis)
+    // Current integration limits 
+    virtual void  IntegrationLimits(Float_t&,Float_t&,Float_t&,Float_t&) {}
+    // Print Parameters
+    virtual void    Print(Option_t *opt="") const;
+// Print default parameters (static const data members, if any)
+    virtual void PrintDefaultParameters() const;           
 
-    AliITSgeom *fGeom;         //! pointer to the geometry class
-    AliITSresponse *fResponse; // pointer to the response class
-   
-    TF1*       fCorr;          // correction function
+    static Int_t GetNAnodesPerHybrid()  { return fgkHalfNanodesDefault;}
+  protected:
 
-    ClassDef(AliITSsegmentationSDD,1) // SDD segmentation
+    virtual void Copy(TObject &obj) const;
+
+    Int_t      fNsamples; // Number of time samples in x
+    Int_t      fNanodes;  // Summed # of anodes in the two det halves (z)
+    Float_t    fPitch;    // Anode pitch - microns
+    Float_t    fTimeStep; // Sampling time - ns
+    Float_t    fDriftSpeed;  // Drift speed 
+    Bool_t     fSetDriftSpeed; // flag for usage of drift speed
+    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 Float_t fgkClockDefault; //Default value for the clock freq.
+    static const Int_t fgkHalfNanodesDefault; //Default value for fNanodes/2
+    static const Int_t fgkNsamplesDefault; //Default value for fNsamples
+    static const Int_t fgkNchipsPerHybrid;    //number of chips per hybrid
+    static const Int_t fgkNanodesPerChip;    //number of chips per hybrid
+    static const Float_t fgkCm2Micron;  // conversion from cm to micron
+    static const Float_t fgkMicron2Cm;  // conversion from micron to cm
+    ClassDef(AliITSsegmentationSDD,6) // SDD segmentation
 };
 
 #endif