[u/mrichter/AliRoot.git] / TRD / AliTRDpadPlane.h

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

/* $Id$ */

//////////////////////////////////////////////////
//                                              //
//  TRD pad plane class                         //
//                                              //
//  Contains the information on pad postions,   //
//  pad dimensions, tilting angle, etc.         //
//  It also provides methods to identify the    //
//  current pad number from global coordinates. //
//                                              //
//////////////////////////////////////////////////

#include <TObject.h>


//_____________________________________________________________________________
class AliTRDpadPlane : public TObject {

 public:

  AliTRDpadPlane();
  AliTRDpadPlane(Int_t plane, Int_t chamber);
  AliTRDpadPlane(const AliTRDpadPlane &p);
  virtual           ~AliTRDpadPlane();
  AliTRDpadPlane    &operator=(const AliTRDpadPlane &p);
  virtual void       Copy(TObject &p) const;

  void     SetPlane(Int_t p)                   { fPla            = p; };
  void     SetChamber(Int_t c)                 { fCha            = c; };
  void     SetRowSpacing(Double_t s)           { fRowSpacing     = s; };
  void     SetColSpacing(Double_t s)           { fColSpacing     = s; };
  void     SetLengthRim(Double_t l)            { fLengthRim      = l; };
  void     SetWidthRim(Double_t w)             { fWidthRim       = w; };
  void     SetNcols(Int_t n)                   { fNcols          = n;
                                                 if (fPadCol) delete[] fPadCol;
                                                 fPadCol         = new Double_t[fNcols]; };
  void     SetNrows(Int_t n)                   { fNrows          = n;
                                                 if (fPadRow) delete[] fPadRow;
                                                 fPadRow         = new Double_t[fNrows]; };
  void     SetPadCol(Int_t ic, Double_t c)     { if (ic < fNcols) fPadCol[ic] = c;       };
  void     SetPadRow(Int_t ir, Double_t r)     { if (ir < fNrows) fPadRow[ir] = r;       };
  void     SetLength(Double_t l)               { fLength         = l; };
  void     SetWidth(Double_t w)                { fWidth          = w; };
  void     SetLengthOPad(Double_t l)           { fLengthOPad     = l; };
  void     SetWidthOPad(Double_t w)            { fWidthOPad      = w; };
  void     SetLengthIPad(Double_t l)           { fLengthIPad     = l; };
  void     SetWidthIPad(Double_t w)            { fWidthIPad      = w; };
  void     SetPadRowSMOffset(Double_t o)       { fPadRowSMOffset = o; };
  void     SetTiltingAngle(Double_t t);

  Int_t    GetPadRowNumber(Double_t z) const;
  Int_t    GetPadRowNumberROC(Double_t z) const;
  Int_t    GetPadColNumber(Double_t rphi) const;

  Double_t GetTiltOffset(Double_t rowOffset) const 
                                             { return fTiltingTan * (rowOffset - 0.5*fLengthIPad); };

  Double_t GetPadRowOffset(Int_t row, Double_t z) const
                                             { if ((row < 0) || (row >= fNrows))
                                                 return -1.0;
                                               else 
                                                 return fPadRow[row] + fPadRowSMOffset - z;        };
  Double_t GetPadRowOffsetROC(Int_t row, Double_t z) const
                                             { if ((row < 0) || (row >= fNrows))
                                                 return -1.0;
                                               else 
                                                 return fPadRow[row] - z;    };

  Double_t GetPadColOffset(Int_t col, Double_t rphi) const
                                             { if ((col < 0) || (col >= fNcols))
                                                 return -1.0;
                                               else
                                                 return fPadCol[col] - rphi; };

  Double_t GetTiltingAngle() const           { return fTiltingAngle; };

  Int_t    GetNrows() const                  { return fNrows;        };
  Int_t    GetNcols() const                  { return fNcols;        };

  Double_t GetRow0() const                   { return fPadRow[0] + fPadRowSMOffset;    };
  Double_t GetRow0ROC() const                { return fPadRow[0];    };
  Double_t GetCol0() const                   { return fPadCol[0];    };

  Double_t GetRowEnd() const                 { return fPadRow[fNrows-1] - fLengthOPad + fPadRowSMOffset; };
  Double_t GetRowEndROC() const              { return fPadRow[fNrows-1] - fLengthOPad; };
  Double_t GetColEnd() const                 { return fPadCol[fNcols-1] - fWidthOPad;  };

  Double_t GetRowPos(Int_t row) const        { return fPadRow[row] + fPadRowSMOffset;  };
  Double_t GetRowPosROC(Int_t row) const     { return fPadRow[row];  };
  Double_t GetColPos(Int_t col) const        { return fPadCol[col];  };
  
  Double_t GetRowSize(Int_t row) const       { if ((row == 0) || (row == fNrows-1))
                                                 return fLengthOPad;
                                               else
                                                 return fLengthIPad; };
  Double_t GetColSize(Int_t col) const       { if ((col == 0) || (col == fNcols-1))
                                                 return fWidthOPad;
                                               else
                                                 return fWidthIPad;  };

  Double_t GetLengthRim() const              { return fLengthRim;    };
  Double_t GetWidthRim() const               { return fWidthRim;     };

  Double_t GetRowSpacing() const             { return fRowSpacing;   };
  Double_t GetColSpacing() const             { return fColSpacing;   };

  Double_t GetLengthOPad() const             { return fLengthOPad;   };
  Double_t GetLengthIPad() const             { return fLengthIPad;   };

  Double_t GetWidthOPad() const              { return fWidthOPad;    };
  Double_t GetWidthIPad() const              { return fWidthIPad;    };

 protected:

  Int_t     fPla;             //  Plane number
  Int_t     fCha;             //  Chamber number

  Double_t  fLength;          //  Length of pad plane in z-direction (row)
  Double_t  fWidth;           //  Width of pad plane in rphi-direction (col)

  Double_t  fLengthRim;       //  Length of the rim in z-direction (row)
  Double_t  fWidthRim;        //  Width of the rim in rphi-direction (col)

  Double_t  fLengthOPad;      //  Length of an outer pad in z-direction (row)
  Double_t  fWidthOPad;       //  Width of an outer pad in rphi-direction (col)

  Double_t  fLengthIPad;      //  Length of an inner pad in z-direction (row)
  Double_t  fWidthIPad;       //  Width of an inner pad in rphi-direction (col)

  Double_t  fRowSpacing;      //  Spacing between the pad rows
  Double_t  fColSpacing;      //  Spacing between the pad columns

  Int_t     fNrows;           //  Number of rows
  Int_t     fNcols;           //  Number of columns

  Double_t  fTiltingAngle;    //  Pad tilting angle  
  Double_t  fTiltingTan;      //  Tangens of pad tilting angle

  Double_t *fPadRow;          //  Pad border positions in row direction
  Double_t *fPadCol;          //  Pad border positions in column direction

  Double_t  fPadRowSMOffset;  //  To be added to translate local ROC system to local SM system

  ClassDef(AliTRDpadPlane,4)  //  TRD ROC pad plane

};

#endif
Commit	Line	Data
e0d47c25	1	#ifndef ALITRDPADPLANE_H
	2	#define ALITRDPADPLANE_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
f162af62	6	/* $Id$ */
e0d47c25	7
	8	//////////////////////////////////////////////////
	9	// //
	10	// TRD pad plane class //
	11	// //
	12	// Contains the information on pad postions, //
	13	// pad dimensions, tilting angle, etc. //
	14	// It also provides methods to identify the //
	15	// current pad number from global coordinates. //
	16	// //
	17	//////////////////////////////////////////////////
	18
	19	#include <TObject.h>
	20
f18d4f83	21
e0d47c25	22	//_____________________________________________________________________________
	23	class AliTRDpadPlane : public TObject {
	24
	25	public:
	26
	27	AliTRDpadPlane();
5dfd5caf	28	AliTRDpadPlane(Int_t plane, Int_t chamber);
e0d47c25	29	AliTRDpadPlane(const AliTRDpadPlane &p);
	30	virtual ~AliTRDpadPlane();
	31	AliTRDpadPlane &operator=(const AliTRDpadPlane &p);
	32	virtual void Copy(TObject &p) const;
	33
f162af62	34	void SetPlane(Int_t p) { fPla = p; };
	35	void SetChamber(Int_t c) { fCha = c; };
	36	void SetRowSpacing(Double_t s) { fRowSpacing = s; };
	37	void SetColSpacing(Double_t s) { fColSpacing = s; };
	38	void SetLengthRim(Double_t l) { fLengthRim = l; };
	39	void SetWidthRim(Double_t w) { fWidthRim = w; };
	40	void SetNcols(Int_t n) { fNcols = n;
	41	if (fPadCol) delete[] fPadCol;
	42	fPadCol = new Double_t[fNcols]; };
	43	void SetNrows(Int_t n) { fNrows = n;
	44	if (fPadRow) delete[] fPadRow;
	45	fPadRow = new Double_t[fNrows]; };
	46	void SetPadCol(Int_t ic, Double_t c) { if (ic < fNcols) fPadCol[ic] = c; };
	47	void SetPadRow(Int_t ir, Double_t r) { if (ir < fNrows) fPadRow[ir] = r; };
	48	void SetLength(Double_t l) { fLength = l; };
	49	void SetWidth(Double_t w) { fWidth = w; };
	50	void SetLengthOPad(Double_t l) { fLengthOPad = l; };
	51	void SetWidthOPad(Double_t w) { fWidthOPad = w; };
	52	void SetLengthIPad(Double_t l) { fLengthIPad = l; };
	53	void SetWidthIPad(Double_t w) { fWidthIPad = w; };
f162af62	54	void SetPadRowSMOffset(Double_t o) { fPadRowSMOffset = o; };
f18d4f83	55	void SetTiltingAngle(Double_t t);
f162af62	56
98ce8151	57	Int_t GetPadRowNumber(Double_t z) const;
4329977a	58	Int_t GetPadRowNumberROC(Double_t z) const;
	59	Int_t GetPadColNumber(Double_t rphi) const;
	60
6d17a2b7	61	Double_t GetTiltOffset(Double_t rowOffset) const
6d17a2b7	62	{ return fTiltingTan * (rowOffset - 0.5*fLengthIPad); };
4329977a	63
98ce8151	64	Double_t GetPadRowOffset(Int_t row, Double_t z) const
4329977a	65	{ if ((row < 0) \|\| (row >= fNrows))
	66	return -1.0;
	67	else
	68	return fPadRow[row] + fPadRowSMOffset - z; };
	69	Double_t GetPadRowOffsetROC(Int_t row, Double_t z) const
a5cadd36	70	{ if ((row < 0) \|\| (row >= fNrows))
	71	return -1.0;
	72	else
	73	return fPadRow[row] - z; };
	74
98ce8151	75	Double_t GetPadColOffset(Int_t col, Double_t rphi) const
a5cadd36	76	{ if ((col < 0) \|\| (col >= fNcols))
	77	return -1.0;
	78	else
	79	return fPadCol[col] - rphi; };
	80
	81	Double_t GetTiltingAngle() const { return fTiltingAngle; };
	82
	83	Int_t GetNrows() const { return fNrows; };
	84	Int_t GetNcols() const { return fNcols; };
	85
4329977a	86	Double_t GetRow0() const { return fPadRow[0] + fPadRowSMOffset; };
4329977a	87	Double_t GetRow0ROC() const { return fPadRow[0]; };
a5cadd36	88	Double_t GetCol0() const { return fPadCol[0]; };
a5cadd36	89
4329977a	90	Double_t GetRowEnd() const { return fPadRow[fNrows-1] - fLengthOPad + fPadRowSMOffset; };
4329977a	91	Double_t GetRowEndROC() const { return fPadRow[fNrows-1] - fLengthOPad; };
d3d2d3e8	92	Double_t GetColEnd() const { return fPadCol[fNcols-1] - fWidthOPad; };
a5cadd36	93
4329977a	94	Double_t GetRowPos(Int_t row) const { return fPadRow[row] + fPadRowSMOffset; };
4329977a	95	Double_t GetRowPosROC(Int_t row) const { return fPadRow[row]; };
3becff3c	96	Double_t GetColPos(Int_t col) const { return fPadCol[col]; };
e0d47c25	97
3becff3c	98	Double_t GetRowSize(Int_t row) const { if ((row == 0) \|\| (row == fNrows-1))
a5cadd36	99	return fLengthOPad;
	100	else
	101	return fLengthIPad; };
3becff3c	102	Double_t GetColSize(Int_t col) const { if ((col == 0) \|\| (col == fNcols-1))
a5cadd36	103	return fWidthOPad;
a5cadd36	104	else
af26ce80	105	return fWidthIPad; };
f162af62	106
3becff3c	107	Double_t GetLengthRim() const { return fLengthRim; };
f162af62	108	Double_t GetWidthRim() const { return fWidthRim; };
a5cadd36	109
f162af62	110	Double_t GetRowSpacing() const { return fRowSpacing; };
f162af62	111	Double_t GetColSpacing() const { return fColSpacing; };
e0d47c25	112
f162af62	113	Double_t GetLengthOPad() const { return fLengthOPad; };
	114	Double_t GetLengthIPad() const { return fLengthIPad; };
	115
	116	Double_t GetWidthOPad() const { return fWidthOPad; };
	117	Double_t GetWidthIPad() const { return fWidthIPad; };
	118
	119	protected:
e0d47c25	120
	121	Int_t fPla; // Plane number
	122	Int_t fCha; // Chamber number
	123
	124	Double_t fLength; // Length of pad plane in z-direction (row)
	125	Double_t fWidth; // Width of pad plane in rphi-direction (col)
	126
	127	Double_t fLengthRim; // Length of the rim in z-direction (row)
	128	Double_t fWidthRim; // Width of the rim in rphi-direction (col)
	129
	130	Double_t fLengthOPad; // Length of an outer pad in z-direction (row)
	131	Double_t fWidthOPad; // Width of an outer pad in rphi-direction (col)
	132
	133	Double_t fLengthIPad; // Length of an inner pad in z-direction (row)
	134	Double_t fWidthIPad; // Width of an inner pad in rphi-direction (col)
	135
	136	Double_t fRowSpacing; // Spacing between the pad rows
	137	Double_t fColSpacing; // Spacing between the pad columns
	138
	139	Int_t fNrows; // Number of rows
	140	Int_t fNcols; // Number of columns
	141
	142	Double_t fTiltingAngle; // Pad tilting angle
4ffb371b	143	Double_t fTiltingTan; // Tangens of pad tilting angle
e0d47c25	144
f162af62	145	Double_t *fPadRow; // Pad border positions in row direction
f162af62	146	Double_t *fPadCol; // Pad border positions in column direction
e0d47c25	147
4329977a	148	Double_t fPadRowSMOffset; // To be added to translate local ROC system to local SM system
4329977a	149
f162af62	150	ClassDef(AliTRDpadPlane,4) // TRD ROC pad plane
e0d47c25	151
	152	};
	153
	154	#endif