MUON/AliMUONSt345SlatSegmentation.h

   1 #ifndef ALIMUONST345SLATSEGMENTATION_H
   2 #define ALIMUONST345SLATSEGMENTATION_H
   3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice                               */
   5
   6 /* $Id$ */
   7
   8 //*********************************************************
   9 //  Segmentation classes for slat modules
  10 //  This class works with local coordinates
  11 //  of the slats via the class AliMUONGeometrySegmentation
  12 //  This class contains the size of the slats and the
  13 //  and the differents PCB densities.
  14 //*********************************************************
  15
  16 #include  "AliMUONVGeometryDESegmentation.h"
  17
  18 class TArrayF;
  19 class TArrayI;
  20 class AliMUONSegmentManuIndex;
  21 class AliMUONSegmentationDetectionElement;
  22
  23 class AliMUONSt345SlatSegmentation : public AliMUONVGeometryDESegmentation
  24 {
  25  public:
  26     AliMUONSt345SlatSegmentation();
  27     AliMUONSt345SlatSegmentation(Bool_t bending);
  28     virtual ~AliMUONSt345SlatSegmentation();
  29
  30     virtual Float_t  Distance2AndOffset(Int_t iX, Int_t iY, Float_t X, Float_t Y, Int_t * dummy);  // Distance between 1 pad and a position
  31     virtual Float_t  Dpx() const {return fDpx;}  // Pad size in x
  32     virtual Float_t  Dpy() const {return fDpy;}  // Pad size in y
  33     virtual Float_t  Dpx(Int_t isec) const;       // Pad size in x by Sector
  34     virtual Float_t  Dpy(Int_t isec) const;       // Pad size in y by Sector
  35     virtual void     Draw(const char */*opt*/ = "") {}  // Not implemented
  36     virtual void     FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy);  // Initialisation for pad iteration
  37     virtual void     FirstPad(Float_t xhit, Float_t yhit, Float_t zhit, Float_t dx, Float_t dy);
  38
  39     virtual Bool_t   HasPad(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/) { return true; }
  40     virtual Bool_t   HasPad(Int_t ix, Int_t iy);
  41     virtual AliMUONGeometryDirection  GetDirection() { return kDirUndefined; }
  42
  43     virtual Float_t  GetAnod(Float_t xhit) const;  // Anod wire coordinate closest to xhit
  44     virtual void     GetPadI(Float_t x ,Float_t y ,Int_t   &ix,Int_t &iy);  // Transform from pad to real coordinates
  45     virtual void     GetPadI(Float_t x, Float_t y , Float_t z, Int_t &ix, Int_t &iy);
  46     virtual void     GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y);
  47     virtual void     GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y, Float_t &z) {z=0; GetPadC(ix, iy, x , y);}
  48
  49     virtual void     GetPadE(Int_t &ix, Int_t &iy,  AliMUONSegmentManuIndex* connect); // get pad for a given connection
  50     virtual AliMUONSegmentManuIndex*     GetMpConnection(Int_t ix, Int_t iy); // get electronics connection for given pad
  51
  52
  53     virtual void     IntegrationLimits(Float_t& x1, Float_t& x2, Float_t& y1, Float_t& y2); //Current integration limits
  54     virtual Int_t    ISector()  {return fSector;} // Current Pad during Integration (current sector)
  55     virtual Int_t    Ix() {return fIx;} // x-coordinate
  56     virtual Int_t    Iy() {return fIy;} // y-coordinate
  57
  58     virtual Int_t    MorePads();  // Condition
  59
  60     virtual void     Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]);  // Get next neighbours
  61     virtual void     NextPad(); // Stepper
  62     virtual Int_t    Npx() const {return fNpx;} // Maximum number of Pads in x
  63     virtual Int_t    Npy() const {return fNpy;} // Maximum number of Pads in y
  64
  65     virtual void     SetDAnod(Float_t D) {fWireD = D;};  // Anod pitch
  66     virtual Int_t    Sector(Int_t ix, Int_t iy);         // Calculate sector from pad coordinates
  67     virtual void     SetHit(Float_t xhit, Float_t yhit); // Set hit position
  68     virtual void     SetHit(Float_t xhit, Float_t yhit, Float_t zhit);
  69     virtual void     SetId(Int_t id) {fId=id;}  // Setting detection element
  70     virtual void     SetPad(Int_t ix, Int_t iy);         // Set pad position
  71     virtual void     SetPadDivision(Int_t ndiv[4]);      // Set Slat Segmentation Parameters
  72     virtual void     SetPadSize(Float_t p1, Float_t p2); // Pad size Dx*Dy
  73     virtual void     SetPcbBoards(Int_t n[4]);           // Set Segmentation Zones (PCB Boards)
  74
  75     // The following function could be obsolet for this class, but they are pure virtual in AliSegmentation
  76     virtual void     GetNParallelAndOffset(Int_t /*iX*/, Int_t /*iY*/, Int_t */*Nparallel*/, Int_t */*Offset*/) {};
  77     virtual Int_t    SigGenCond(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/){return 0;} ;  // Signal Generation Condition during Stepping
  78     virtual void     SigGenInit(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/){};  // Initialise signal gneration at coord (x,y,z)
  79     virtual void     GiveTestPoints(Int_t &/*n*/, Float_t * /*x*/, Float_t */*y*/) const{};   // Test points for auto calibration
  80     virtual void     SetCorrFunc(Int_t /*dum*/, TF1* /*func*/){}; // Function for systematic corrections, Set the correction function
  81     virtual TF1*     CorrFunc(Int_t) const {return 0x0;} // Get the correction Function
  82     virtual Int_t    Sector(Float_t /*x*/, Float_t /*y*/) {return 1;}
  83
  84     virtual void     Init(Int_t detectionElementId); // Initialisation
  85     // Current integration limits
  86
  87  protected:
  88
  89     AliMUONSt345SlatSegmentation(const AliMUONSt345SlatSegmentation& rhs);
  90     AliMUONSt345SlatSegmentation& operator=(const AliMUONSt345SlatSegmentation& rhs);
  91     void GetMpFileName(Char_t* name) const;
  92     void Swap(Int_t padX, Int_t &padY);
  93
  94  private:
  95     //  Internal geometry of the slat
  96     Bool_t      fBending;        // 0: Bending or 1:Non Bending segmentation
  97     Int_t       fId;             // Identifier of detection element
  98     Int_t       fNsec;           // Number of density sectors (should be 4, if not not warranty about the output
  99     TArrayI*    fNDiv;           // Densities (d1, d2, d3, d4). It should be (4, 4, 2, 1) which goes from beam to out-beam
 100     TArrayF*    fDpxD;           // x pad width per density sector
 101     TArrayF*    fDpyD;           // x pad width per density sector
 102     Float_t     fDpx;            // x pad base width
 103     Float_t     fDpy;            // y pad base width
 104     Int_t       fNpx;            // Number of pads in x
 105     Int_t       fNpy;            // Number of pads in y
 106     Float_t     fWireD;          // wire pitch
 107     Int_t       fRtype;          // type of the slat: rounded R=1,2,3, rounded short R=-1,-2,-3, short R=4, normal R=0
 108     //
 109     Int_t       fSector;         // Current density sector
 110     Float_t     fDxPCB;          // x-size of PCB board
 111     Float_t     fDyPCB;          // y-size of PCB board
 112     Int_t       fPcbBoards[4];   // number of PCB boards per density sector n1,n2,n3,n4
 113     // n1 PcbBoard with density d1, n2 PcbBoards with density d2, etc ....
 114
 115     // Segmentation map
 116     Int_t       fNpxS[10];       // Number of pads per sector in x
 117     Int_t       fNpyS[10];       // Number of pads per sector in y
 118     Float_t     fCx[10];         // pad-sector contour x vs y
 119     Float_t     fCy;             // y offset
 120
 121     // Current pad and wire during tracking (cursor at hit centre)
 122     Float_t     fXhit;  // ! x-position of hit
 123     Float_t     fYhit;  // ! y-position of hit
 124
 125     // Current pad and wire during tracking (cursor at hit centre)
 126     Int_t       fIx;   // ! pad coord.  x
 127     Int_t       fIy;   // ! pad coord.  y
 128     Float_t     fX;    // ! real coord. x
 129     Float_t     fY;    // ! real ccord. y
 130
 131     // Chamber region consideres during disintegration
 132     Int_t       fIxmin; // ! lower left  x
 133     Int_t       fIxmax; // ! lower left  y
 134     Int_t       fIymin; // ! upper right x
 135     Int_t       fIymax; // ! upper right y
 136
 137     // Chamber region consideres during disintegration  (lower left and upper right corner)
 138     Float_t     fXmin;           // lower left  x
 139     Float_t     fXmax;           // lower left  y
 140     Float_t     fYmin;           // upper right x
 141     Float_t     fYmax;           // upper right y
 142
 143     Bool_t      fInitDone;       // flag for initialization
 144
 145     // electronics mapping
 146     AliMUONSegmentationDetectionElement* fSegmentationDetectionElement; //! pointer to the electronics mapping
 147
 148     ClassDef(AliMUONSt345SlatSegmentation,3)
 149 };
 150 #endif
 151
 152
 153
 154
 155
 156