[u/mrichter/AliRoot.git] / MUON / AliMUONSt12QuadrantSegmentation.h

#ifndef ALI_MUON_ST12_QUADRANT_SEGMENTATION_H
#define ALI_MUON_ST12_QUADRANT_SEGMENTATION_H

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */
// Revision of includes 07/05/2004

/// \ingroup base
/// \class AliMUONSt12QuadrantSegmentation
/// \brief Segmentation for MUON quadrants of stations 1 and 2 using 
/// the mapping package
///
/// \author Ivana Hrivnacova, IPN Orsay

#include "AliMpStationType.h"
#include "AliMpPlaneType.h"

#include "AliMUONVGeometryDESegmentation.h"

class TObjArray;

class AliMpSector;
class AliMpSectorSegmentation;
class AliMpVPadIterator;
class AliMpPad;

class AliMUONChamber;

class AliMUONSt12QuadrantSegmentation : public AliMUONVGeometryDESegmentation 
{
  public:
    AliMUONSt12QuadrantSegmentation(AliMpVSegmentation* segmentation,
                                    AliMpStationType stationType, 
                                    AliMpPlaneType planeType);
    AliMUONSt12QuadrantSegmentation();
    
    virtual ~AliMUONSt12QuadrantSegmentation();
    
    //    
    // methods derived from base class    
    // 

    // Set Chamber Segmentation Parameters
    //
    virtual void SetPadSize(Float_t p1, Float_t p2);
                       // Pad size Dx*Dy 
    virtual void SetDAnod(Float_t D);
                       // Anode Pitch

    // Check if pad exists
    //
    virtual Bool_t  HasPad(Float_t x, Float_t y, Float_t z); 
                       // Returns true if a pad exists in the given position
    virtual Bool_t  HasPad(Int_t ix, Int_t iy);
                       // Returns true if a pad with given indices exists

    // Quadrant type
    //
    virtual AliMUONGeometryDirection  GetDirection();
                       // Returns the direction with a constant pad size
    // Access to mapping
    virtual const AliMpVSegmentation* GetMpSegmentation() const; 		       

    // Transform from pad (wire) to real coordinates and vice versa
    //
    virtual Float_t GetAnod(Float_t xhit) const;
                       // Anode wire coordinate closest to xhit
    virtual void  GetPadI(Float_t x, Float_t y, Float_t  z, Int_t& ix, Int_t& iy);
    virtual void  GetPadI(Float_t x, Float_t y , Int_t &ix, Int_t &iy) ;
                       // Transform from pad to real coordinates
    virtual void  GetPadC(Int_t ix, Int_t iy, Float_t& x, Float_t& y, Float_t& z);
    virtual void  GetPadC(Int_t ix, Int_t iy, Float_t& x, Float_t& y);
                       // Transform from real to pad coordinates
  
    // Initialisation
    //
    virtual void Init(Int_t chamber);
 
    // Get member data
    //
    virtual Float_t Dpx() const;
    virtual Float_t Dpy() const;
                      // Pad size in x, y 
    virtual Float_t Dpx(Int_t isector) const;
    virtual Float_t Dpy(Int_t isector) const;
                      // Pad size in x, y by Sector 
    virtual Int_t   Npx() const;
    virtual Int_t   Npy() const;
                      // Maximum number of Pads in y

    virtual void  SetPad(Int_t ix, Int_t iy);
                      // Set pad position
    virtual void  SetHit(Float_t xhit, Float_t yhit, Float_t zhit);
                      // Set hit position
    
    // Iterate over pads
    //
    virtual void  FirstPad(Float_t xhit, Float_t yhit, Float_t zhit, 
                           Float_t dx, Float_t dy);
    virtual void  NextPad();
    virtual Int_t MorePads();

    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
    virtual void GetNParallelAndOffset(Int_t iX, Int_t iY,
				       Int_t* Nparallel, Int_t* Offset);
                      // Number of pads read in parallel and offset to add to x 
                      // (specific to LYON, but mandatory for display)
    virtual void Neighbours(Int_t iX, Int_t iY, 
                            Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]);
                      // Get next neighbours 

    // Current values
    //
    virtual Int_t  Ix();
    virtual Int_t  Iy();
                     // Current pad cursor during disintegration
                     // x, y-coordinate
    virtual Int_t  ISector();
                    // current sector

    virtual Int_t  Sector(Int_t ix, Int_t iy);
    virtual Int_t  Sector(Float_t x, Float_t y);
                    // calculate sector from pad coordinates

    virtual void  IntegrationLimits(Float_t& x1, Float_t& x2,
                                    Float_t& y1, Float_t& y2);
                   // Current integration limits 

    // Signal Generation
    //
    virtual Int_t SigGenCond(Float_t x, Float_t y, Float_t z);
                    // Signal Generation Condition during Stepping
    virtual void  SigGenInit(Float_t x, Float_t y, Float_t z);
                    // Initialise signal generation at coord (x,y,z)
		    
    
    virtual void GiveTestPoints(Int_t& n, Float_t* x, Float_t* y) const;
                   // Test points for auto calibration
    virtual void Draw(const char *opt = "");
                   // Draw the segmentation zones

    // Function for systematic corrections
    //
    virtual void SetCorrFunc(Int_t isec,  TF1* func);
                   // Set the correction function
    virtual TF1* CorrFunc(Int_t isec)  const;
                   // Get the correction Function
 
  protected:
    AliMUONSt12QuadrantSegmentation(const AliMUONSt12QuadrantSegmentation& rhs);
  
    // operators
    AliMUONSt12QuadrantSegmentation& operator=(const AliMUONSt12QuadrantSegmentation & rhs);

  private:
    // methods
    void UpdateCurrentPadValues(const AliMpPad& pad);
  
    // data members

    // From mapping
    //
    AliMpStationType         fStationType;       ///< Station type
    AliMpPlaneType           fPlaneType;         ///< Plane type
    const AliMpSector*       fSector;            ///< Sector (from mapping)
    AliMpSectorSegmentation* fSectorSegmentation;///< Sector segmentation (from mapping)
    AliMpVPadIterator*       fSectorIterator;    //!< Iterator over pads

    // Wire pitch
    //
    Float_t         fWireD;  ///< \ brief Wire pitch
                             ///< (smaller distance between anode wires)
    
    // Reference to mother chamber
    //
    AliMUONChamber* fChamber; //!< Reference to mother chamber
    Int_t           fId;      ///< Identifier
    Float_t         fRmin;    ///< Inner radius
    Float_t         fRmax;    ///< Outer radius
    Float_t         fZ;       ///< Z-position of chamber

    // Current pad during integration (cursor for disintegration)
    //
    Int_t   fIx;     //!< Pad coord.  x 
    Int_t   fIy;     //!< Pad coord.  y 
    Float_t fX;      //!< Real coord. x
    Float_t fY;      //!< Real ccord. y
    Int_t   fZone;   //!< Current zone (sector in AliSegmentation naming)
    
    // Current pad and wire during tracking (cursor at hit centre)
    //
    Float_t fXhit;  //!< X-position of hit
    Float_t fYhit;  //!< Y-position of hit

    // Reference point to define signal generation condition
    //
    Int_t   fIxt;   //!< Pad coord. x
    Int_t   fIyt;   //!< Pad coord. y
    Int_t   fIwt;   //!< Wire number
    Float_t fXt;    //!< X
    Float_t fYt;    //!< Y

    TObjArray* fCorrA; //!< Array of correction functions

  ClassDef(AliMUONSt12QuadrantSegmentation,2) // Station1 segmentation
};

#endif //ALI_MUON_ST12_QUADRANT_SEGMENTATION_H
Commit	Line	Data
e118b27e	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
692de412	10	/// \ingroup base
692de412	11	/// \class AliMUONSt12QuadrantSegmentation
5398f946	12	/// \brief Segmentation for MUON quadrants of stations 1 and 2 using
	13	/// the mapping package
	14	///
	15	/// \author Ivana Hrivnacova, IPN Orsay
e118b27e	16
	17	#include "AliMpStationType.h"
	18	#include "AliMpPlaneType.h"
	19
e0a49962	20	#include "AliMUONVGeometryDESegmentation.h"
e118b27e	21
	22	class TObjArray;
	23
	24	class AliMpSector;
	25	class AliMpSectorSegmentation;
	26	class AliMpVPadIterator;
	27	class AliMpPad;
	28
	29	class AliMUONChamber;
	30
e0a49962	31	class AliMUONSt12QuadrantSegmentation : public AliMUONVGeometryDESegmentation
e118b27e	32	{
e118b27e	33	public:
8fbf5237	34	AliMUONSt12QuadrantSegmentation(AliMpVSegmentation* segmentation,
8fbf5237	35	AliMpStationType stationType,
e0a49962	36	AliMpPlaneType planeType);
e118b27e	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
e0a49962	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
6b1e4b22	59	// Quadrant type
	60	//
	61	virtual AliMUONGeometryDirection GetDirection();
	62	// Returns the direction with a constant pad size
f5ed7890	63	// Access to mapping
b7ef3c96	64	virtual const AliMpVSegmentation* GetMpSegmentation() const;
6b1e4b22	65
e118b27e	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
9db6c8d7	76
e118b27e	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
e118b27e	163	// data members
	164
	165	// From mapping
	166	//
18b6b8c7	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
e118b27e	172
	173	// Wire pitch
	174	//
18b6b8c7	175	Float_t fWireD; ///< \ brief Wire pitch
18b6b8c7	176	///< (smaller distance between anode wires)
e118b27e	177
	178	// Reference to mother chamber
	179	//
18b6b8c7	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
e118b27e	185
	186	// Current pad during integration (cursor for disintegration)
	187	//
18b6b8c7	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)
e118b27e	193
	194	// Current pad and wire during tracking (cursor at hit centre)
	195	//
18b6b8c7	196	Float_t fXhit; //!< X-position of hit
18b6b8c7	197	Float_t fYhit; //!< Y-position of hit
e118b27e	198
	199	// Reference point to define signal generation condition
	200	//
18b6b8c7	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
e118b27e	206
18b6b8c7	207	TObjArray* fCorrA; //!< Array of correction functions
e118b27e	208
394d8216	209	ClassDef(AliMUONSt12QuadrantSegmentation,2) // Station1 segmentation
e118b27e	210	};
	211
	212	#endif //ALI_MUON_ST12_QUADRANT_SEGMENTATION_H
	213
	214
	215
	216
	217
	218
	219
	220