MUON/AliMUONSt12QuadrantSegmentation.h

   1 #ifndef ALI_MUON_ST12_QUADRANT_SEGMENTATION_H
   2 #define ALI_MUON_ST12_QUADRANT_SEGMENTATION_H
   3
   4 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  * See cxx source for full Copyright notice                               */
   6
   7 /* $Id$ */
   8 // Revision of includes 07/05/2004
   9
  10 /// \ingroup base
  11 /// \class AliMUONSt12QuadrantSegmentation
  12 /// \brief Segmentation for MUON quadrants of stations 1 and 2 using
  13 /// the mapping package
  14 ///
  15 /// \author Ivana Hrivnacova, IPN Orsay
  16
  17 #include "AliMpStationType.h"
  18 #include "AliMpPlaneType.h"
  19
  20 #include "AliMUONVGeometryDESegmentation.h"
  21
  22 class TObjArray;
  23
  24 class AliMpSector;
  25 class AliMpSectorSegmentation;
  26 class AliMpVPadIterator;
  27 class AliMpPad;
  28
  29 class AliMUONChamber;
  30
  31 class AliMUONSt12QuadrantSegmentation : public AliMUONVGeometryDESegmentation
  32 {
  33   public:
  34     AliMUONSt12QuadrantSegmentation(AliMpVSegmentation* segmentation,
  35                                     AliMpStationType stationType,
  36                                     AliMpPlaneType planeType);
  37     AliMUONSt12QuadrantSegmentation();
  38
  39     virtual ~AliMUONSt12QuadrantSegmentation();
  40
  41     //
  42     // methods derived from base class
  43     //
  44
  45     // Set Chamber Segmentation Parameters
  46     //
  47     virtual void SetPadSize(Float_t p1, Float_t p2);
  48                        // Pad size Dx*Dy
  49     virtual void SetDAnod(Float_t D);
  50                        // Anode Pitch
  51
  52     // Check if pad exists
  53     //
  54     virtual Bool_t  HasPad(Float_t x, Float_t y, Float_t z);
  55                        // Returns true if a pad exists in the given position
  56     virtual Bool_t  HasPad(Int_t ix, Int_t iy);
  57                        // Returns true if a pad with given indices exists
  58
  59     // Quadrant type
  60     //
  61     virtual AliMUONGeometryDirection  GetDirection();
  62                        // Returns the direction with a constant pad size
  63     // Access to mapping
  64     virtual const AliMpVSegmentation* GetMpSegmentation() const;
  65
  66     // Transform from pad (wire) to real coordinates and vice versa
  67     //
  68     virtual Float_t GetAnod(Float_t xhit) const;
  69                        // Anode wire coordinate closest to xhit
  70     virtual void  GetPadI(Float_t x, Float_t y, Float_t  z, Int_t& ix, Int_t& iy);
  71     virtual void  GetPadI(Float_t x, Float_t y , Int_t &ix, Int_t &iy) ;
  72                        // Transform from pad to real coordinates
  73     virtual void  GetPadC(Int_t ix, Int_t iy, Float_t& x, Float_t& y, Float_t& z);
  74     virtual void  GetPadC(Int_t ix, Int_t iy, Float_t& x, Float_t& y);
  75                        // Transform from real to pad coordinates
  76
  77     // Initialisation
  78     //
  79     virtual void Init(Int_t chamber);
  80
  81     // Get member data
  82     //
  83     virtual Float_t Dpx() const;
  84     virtual Float_t Dpy() const;
  85                       // Pad size in x, y
  86     virtual Float_t Dpx(Int_t isector) const;
  87     virtual Float_t Dpy(Int_t isector) const;
  88                       // Pad size in x, y by Sector
  89     virtual Int_t   Npx() const;
  90     virtual Int_t   Npy() const;
  91                       // Maximum number of Pads in y
  92
  93     virtual void  SetPad(Int_t ix, Int_t iy);
  94                       // Set pad position
  95     virtual void  SetHit(Float_t xhit, Float_t yhit, Float_t zhit);
  96                       // Set hit position
  97
  98     // Iterate over pads
  99     //
 100     virtual void  FirstPad(Float_t xhit, Float_t yhit, Float_t zhit,
 101                            Float_t dx, Float_t dy);
 102     virtual void  NextPad();
 103     virtual Int_t MorePads();
 104
 105     virtual Float_t Distance2AndOffset(Int_t iX, Int_t iY,
 106                                        Float_t X, Float_t Y, Int_t* dummy) ;
 107                       // Distance between 1 pad and a position
 108     virtual void GetNParallelAndOffset(Int_t iX, Int_t iY,
 109                                        Int_t* Nparallel, Int_t* Offset);
 110                       // Number of pads read in parallel and offset to add to x
 111                       // (specific to LYON, but mandatory for display)
 112     virtual void Neighbours(Int_t iX, Int_t iY,
 113                             Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]);
 114                       // Get next neighbours
 115
 116     // Current values
 117     //
 118     virtual Int_t  Ix();
 119     virtual Int_t  Iy();
 120                      // Current pad cursor during disintegration
 121                      // x, y-coordinate
 122     virtual Int_t  ISector();
 123                     // current sector
 124
 125     virtual Int_t  Sector(Int_t ix, Int_t iy);
 126     virtual Int_t  Sector(Float_t x, Float_t y);
 127                     // calculate sector from pad coordinates
 128
 129     virtual void  IntegrationLimits(Float_t& x1, Float_t& x2,
 130                                     Float_t& y1, Float_t& y2);
 131                    // Current integration limits
 132
 133     // Signal Generation
 134     //
 135     virtual Int_t SigGenCond(Float_t x, Float_t y, Float_t z);
 136                     // Signal Generation Condition during Stepping
 137     virtual void  SigGenInit(Float_t x, Float_t y, Float_t z);
 138                     // Initialise signal generation at coord (x,y,z)
 139
 140
 141     virtual void GiveTestPoints(Int_t& n, Float_t* x, Float_t* y) const;
 142                    // Test points for auto calibration
 143     virtual void Draw(const char *opt = "");
 144                    // Draw the segmentation zones
 145
 146     // Function for systematic corrections
 147     //
 148     virtual void SetCorrFunc(Int_t isec,  TF1* func);
 149                    // Set the correction function
 150     virtual TF1* CorrFunc(Int_t isec)  const;
 151                    // Get the correction Function
 152
 153   protected:
 154     AliMUONSt12QuadrantSegmentation(const AliMUONSt12QuadrantSegmentation& rhs);
 155
 156     // operators
 157     AliMUONSt12QuadrantSegmentation& operator=(const AliMUONSt12QuadrantSegmentation & rhs);
 158
 159   private:
 160     // methods
 161     void UpdateCurrentPadValues(const AliMpPad& pad);
 162
 163     // data members
 164
 165     // From mapping
 166     //
 167     AliMpStationType         fStationType;       ///< Station type
 168     AliMpPlaneType           fPlaneType;         ///< Plane type
 169     const AliMpSector*       fSector;            ///< Sector (from mapping)
 170     AliMpSectorSegmentation* fSectorSegmentation;///< Sector segmentation (from mapping)
 171     AliMpVPadIterator*       fSectorIterator;    //!< Iterator over pads
 172
 173     // Wire pitch
 174     //
 175     Float_t         fWireD;  ///< \ brief Wire pitch
 176                              ///< (smaller distance between anode wires)
 177
 178     // Reference to mother chamber
 179     //
 180     AliMUONChamber* fChamber; //!< Reference to mother chamber
 181     Int_t           fId;      ///< Identifier
 182     Float_t         fRmin;    ///< Inner radius
 183     Float_t         fRmax;    ///< Outer radius
 184     Float_t         fZ;       ///< Z-position of chamber
 185
 186     // Current pad during integration (cursor for disintegration)
 187     //
 188     Int_t   fIx;     //!< Pad coord.  x
 189     Int_t   fIy;     //!< Pad coord.  y
 190     Float_t fX;      //!< Real coord. x
 191     Float_t fY;      //!< Real ccord. y
 192     Int_t   fZone;   //!< Current zone (sector in AliSegmentation naming)
 193
 194     // Current pad and wire during tracking (cursor at hit centre)
 195     //
 196     Float_t fXhit;  //!< X-position of hit
 197     Float_t fYhit;  //!< Y-position of hit
 198
 199     // Reference point to define signal generation condition
 200     //
 201     Int_t   fIxt;   //!< Pad coord. x
 202     Int_t   fIyt;   //!< Pad coord. y
 203     Int_t   fIwt;   //!< Wire number
 204     Float_t fXt;    //!< X
 205     Float_t fYt;    //!< Y
 206
 207     TObjArray* fCorrA; //!< Array of correction functions
 208
 209   ClassDef(AliMUONSt12QuadrantSegmentation,2) // Station1 segmentation
 210 };
 211
 212 #endif //ALI_MUON_ST12_QUADRANT_SEGMENTATION_H
 213
 214
 215
 216
 217
 218
 219
 220