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

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  Describes a pad plane of a TRD ROC                                       //
//                                                                           //
//  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 "AliTRDpadPlane.h"
#include "AliTRDgeometryFull.h"

ClassImp(AliTRDpadPlane)

//_____________________________________________________________________________
AliTRDpadPlane::AliTRDpadPlane():TObject()
{
  //
  // Default constructor
  //

  fGeo          = 0;

  fPla          = 0;
  fCha          = 0;

  fLength       = 0.0;
  fWidth        = 0.0;
  fLengthRim    = 0.0;
  fWidthRim     = 0.0;
  fLengthOPad   = 0.0;
  fWidthOPad    = 0.0;
  fLengthIPad   = 0.0;
  fWidthIPad    = 0.0;

  fRowSpacing   = 0.0;
  fColSpacing   = 0.0;

  fNrows        = 0;
  fNcols        = 0;

  fPadRow       = 0;
  fPadCol       = 0;

  fTiltingAngle = 0.0;

}

//_____________________________________________________________________________
AliTRDpadPlane::AliTRDpadPlane(Int_t p, Int_t c):TObject()
{
  //
  // Constructor that initializes a given pad plane type
  //

  fGeo = new AliTRDgeometryFull();

  fPla = p;
  fCha = c;

  fRowSpacing = 0.0;
  fColSpacing = 0.0;

  fLengthRim  = 1.0;
  fWidthRim   = 0.5;

  fNcols      = 144;

  //
  // The pad plane parameter
  //
  switch (p) {
  case 0:
    if (c == 2) {
      // L0C0 type
      fNrows        =  12;
      fLength       = 108.0;
      fWidth        =  92.2;
      fLengthOPad   =   8.0;
      fWidthOPad    =   0.515;
      fLengthIPad   =   9.0;
      fWidthIPad    =   0.635;
      fTiltingAngle =  -2.0;
    }
    else {
      // L0C1 type
      fNrows        =  16;
      fLength       = 122.0;
      fWidth        =  92.2;
      fLengthOPad   =   7.5;
      fWidthOPad    =   0.515;
      fLengthIPad   =   7.5;
      fWidthIPad    =   0.635;
      fTiltingAngle =  -2.0;
    }
    break;
  case 1:
    if (c == 2) {
      // L1C0 type
      fNrows        =  12;
      fLength       = 108.0;
      fWidth        =  96.6;
      fLengthOPad   =   8.0;
      fWidthOPad    =   0.585;
      fLengthIPad   =   9.0;
      fWidthIPad    =   0.665;
      fTiltingAngle =   2.0;
    }
    else {
      // L1C1 type
      fNrows        =  16;
      fLength       = 122.0;
      fWidth        =  96.6;
      fLengthOPad   =   7.5;
      fWidthOPad    =   0.585;
      fLengthIPad   =   7.5;
      fWidthIPad    =   0.665;
      fTiltingAngle =   2.0;
    }
    break;
  case 2:
    if (c == 2) {
      // L2C0 type
      fNrows        =  12;
      fLength       = 108.0;
      fWidth        = 101.1;
      fLengthOPad   =   8.0;
      fWidthOPad    =   0.705;
      fLengthIPad   =   9.0;
      fWidthIPad    =   0.695;
      fTiltingAngle =  -2.0;
    }
    else {
      // L2C1 type
      fNrows        =  16;
      fLength       = 129.0;
      fWidth        = 101.1;
      fLengthOPad   =   7.5;
      fWidthOPad    =   0.705;
      fLengthIPad   =   8.0;
      fWidthIPad    =   0.695;
      fTiltingAngle =  -2.0;
    }
    break;
  case 3:
    if (c == 2) {
      // L3C0 type
      fNrows        =  12;
      fLength       = 108.0;
      fWidth        = 105.5;
      fLengthOPad   =   8.0;
      fWidthOPad    =   0.775;
      fLengthIPad   =   9.0;
      fWidthIPad    =   0.725;
      fTiltingAngle =   2.0;
    }
    else {
      // L3C1 type
      fNrows        =  16;
      fLength       = 136.0;
      fWidth        = 105.5;
      fLengthOPad   =   7.5;
      fWidthOPad    =   0.775;
      fLengthIPad   =   8.5;
      fWidthIPad    =   0.725;
      fTiltingAngle =   2.0;
    }
    break;
  case 4:
    if (c == 2) {
      // L4C0 type
      fNrows        =  12;
      fLength       = 108.0;
      fWidth        = 109.9;
      fLengthOPad   =   8.0;
      fWidthOPad    =   0.845;
      fLengthIPad   =   9.0;
      fWidthIPad    =   0.755;
      fTiltingAngle =  -2.0;
    }
    else {
      // L4C1 type
      fNrows        =  16;
      fLength       = 143.0;
      fWidth        = 109.9;
      fLengthOPad   =   7.5;
      fWidthOPad    =   0.845;
      fLengthIPad   =   9.0;
      fWidthIPad    =   0.755;
      fTiltingAngle =  -2.0;
    }
    break;
  case 5:
    if (c == 2) {
      // L5C0 type
      fNrows        =  12;
      fLength       = 108.0;
      fWidth        = 114.4;
      fLengthOPad   =   8.0;
      fWidthOPad    =   0.965;
      fLengthIPad   =   9.0;
      fWidthIPad    =   0.785;
      fTiltingAngle =   2.0;
    }
    else {
      // L5C1 type
      fNrows        =  16;
      fLength       = 145.0;
      fWidth        = 114.4;
      fLengthOPad   =   8.5;
      fWidthOPad    =   0.965;
      fLengthIPad   =   9.0;
      fWidthIPad    =   0.785;
      fTiltingAngle =   2.0;
    }
    break;
  };

  //
  // Store tilting angle as tangens (opposite direction!)
  //
  fTiltingAngle = TMath::Tan(TMath::Pi()/180.0 * -fTiltingAngle);

  //
  // The positions of the borders of the pads
  //
  // Row direction
  //
  if (fPadRow) delete [] fPadRow;
  fPadRow = new Double_t[fNrows];
  Double_t row = fGeo->GetChamberLength(p,0)
    	       + fGeo->GetChamberLength(p,1)
               + fGeo->GetChamberLength(p,2) / 2.
               - fGeo->RpadW()
               - fLengthRim;
  for (Int_t ic = 0; ic < c; ic++) {
    row -= fGeo->GetChamberLength(p,ic);
  }
  for (Int_t ir = 0; ir < fNrows; ir++) {
    fPadRow[ir] = row;
    row -= fRowSpacing;
    if (ir == 0) {
      row -= fLengthOPad;
    }
    else {
      row -= fLengthIPad;
    }
  }
  //
  // Column direction
  //
  if (fPadCol) delete [] fPadCol;
  fPadCol = new Double_t[fNcols];
  Double_t col = fGeo->GetChamberWidth(p) / 2. 
               + fGeo->CroWid()
               - fWidthRim;
  for (Int_t ic = 0; ic < fNcols; ic++) {
    fPadCol[ic] = col;
    col -= fColSpacing;
    if (ic == 0) {
      col -= fWidthOPad;
    }
    else {
      col -= fWidthIPad;
    }
  }

}

//_____________________________________________________________________________
AliTRDpadPlane::AliTRDpadPlane(const AliTRDpadPlane &p):TObject(p)
{
  //
  // AliTRDpadPlane copy constructor
  //

  ((AliTRDpadPlane &) p).Copy(*this);

}

//_____________________________________________________________________________
AliTRDpadPlane::~AliTRDpadPlane()
{
  //
  // AliTRDpadPlane destructor
  //

  if (fGeo) {
    delete fGeo;
    fGeo    = 0;
  }

  if (fPadRow) {
    delete [] fPadRow;
    fPadRow = 0;
  }

  if (fPadCol) {
    delete [] fPadCol;
    fPadCol = 0;
  }

}

//_____________________________________________________________________________
AliTRDpadPlane &AliTRDpadPlane::operator=(const AliTRDpadPlane &p)
{
  //
  // Assignment operator
  //

  if (this != &p) ((AliTRDpadPlane &) p).Copy(*this);
  return *this;

}

//_____________________________________________________________________________
void AliTRDpadPlane::Copy(TObject &p) const
{
  //
  // Copy function
  //

  Int_t iBin = 0;

  ((AliTRDpadPlane &) p).fGeo          = 0;

  ((AliTRDpadPlane &) p).fPla          = fPla;
  ((AliTRDpadPlane &) p).fCha          = fCha;

  ((AliTRDpadPlane &) p).fLength       = fLength;
  ((AliTRDpadPlane &) p).fWidth        = fWidth;
  ((AliTRDpadPlane &) p).fLengthRim    = fLengthRim;
  ((AliTRDpadPlane &) p).fWidthRim     = fWidthRim;
  ((AliTRDpadPlane &) p).fLengthOPad   = fLengthOPad;
  ((AliTRDpadPlane &) p).fWidthOPad    = fWidthOPad;
  ((AliTRDpadPlane &) p).fLengthIPad   = fLengthIPad;
  ((AliTRDpadPlane &) p).fWidthIPad    = fWidthIPad;

  ((AliTRDpadPlane &) p).fRowSpacing   = fRowSpacing;
  ((AliTRDpadPlane &) p).fColSpacing   = fColSpacing;

  ((AliTRDpadPlane &) p).fNrows        = fNrows;
  ((AliTRDpadPlane &) p).fNcols        = fNcols;

  ((AliTRDpadPlane &) p).fTiltingAngle = fTiltingAngle;

  if (((AliTRDpadPlane &) p).fPadRow) delete [] ((AliTRDpadPlane &) p).fPadRow;
  ((AliTRDpadPlane &) p).fPadRow = new Double_t[fNrows];
  for (iBin = 0; iBin < fNrows; iBin++) {
    ((AliTRDpadPlane &) p).fPadRow[iBin] = fPadRow[iBin];
  }                                                                             

  if (((AliTRDpadPlane &) p).fPadCol) delete [] ((AliTRDpadPlane &) p).fPadCol;
  ((AliTRDpadPlane &) p).fPadCol = new Double_t[fNrows];
  for (iBin = 0; iBin < fNrows; iBin++) {
    ((AliTRDpadPlane &) p).fPadCol[iBin] = fPadCol[iBin];
  }                                                                             

  TObject::Copy(p);

}

//_____________________________________________________________________________
Int_t AliTRDpadPlane::GetPadRowNumber(const Double_t z) const
{
  //
  // Finds the pad row number for a given global z-position
  //

  Int_t row    = 0;
  Int_t nabove = 0;
  Int_t nbelow = 0;
  Int_t middle = 0;

  if ((z > GetRow0()) || (z < GetRowEnd())) {

    row = -1;

  }
  else {

    nabove = fNrows+1;
    nbelow = 0;
    while (nabove - nbelow > 1) {
      middle = (nabove + nbelow) / 2;
      if (z == fPadRow[middle-1]) row    = middle;
      if (z  > fPadRow[middle-1]) nabove = middle;
      else                        nbelow = middle;
    }
    row = nbelow - 1;

  }

  return row;

}

//_____________________________________________________________________________
Int_t AliTRDpadPlane::GetPadColNumber(const Double_t rphi
                                    , const Double_t rowOffset) const
{
  //
  // Finds the pad column number for a given global rphi-position
  //

  Int_t    col       = 0;
  Int_t    nabove    = 0;
  Int_t    nbelow    = 0;
  Int_t    middle    = 0;
  Double_t rphiShift = 0;

  if ((rphi > GetCol0()) || (rphi < GetColEnd())) {

    col = -1;

  }
  else {

    //
    // Take the tilting angle into account by shifting the hit position
    // into the opposite direction
    //

    rphiShift = rphi + fTiltingAngle * rowOffset;

    nabove = fNcols+1;
    nbelow = 0;
    while (nabove - nbelow > 1) {
      middle = (nabove + nbelow) / 2;
      if (rphi == fPadCol[middle-1]) col    = middle;
      if (rphi  > fPadCol[middle-1]) nabove = middle;
      else                           nbelow = middle;
    }
    col = nbelow - 1;

    //printf("rphi=%f, rphiShift=%f, col=%d, colH=%f\n"
    //   ,rphi,rphiShift,col,fPadCol[col]);

  }

  return col;

}
Commit	Line	Data
e0d47c25	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id$ */
	17
	18	///////////////////////////////////////////////////////////////////////////////
	19	// //
	20	// Describes a pad plane of a TRD ROC //
	21	// //
	22	// Contains the information on pad postions, pad dimensions, //
	23	// tilting angle, etc. //
	24	// It also provides methods to identify the current pad number from //
	25	// global coordinates. //
	26	// //
	27	///////////////////////////////////////////////////////////////////////////////
	28
	29	#include "AliTRDpadPlane.h"
	30	#include "AliTRDgeometryFull.h"
	31
	32	ClassImp(AliTRDpadPlane)
	33
	34	//_____________________________________________________________________________
	35	AliTRDpadPlane::AliTRDpadPlane():TObject()
	36	{
	37	//
	38	// Default constructor
	39	//
	40
	41	fGeo = 0;
	42
	43	fPla = 0;
	44	fCha = 0;
	45
	46	fLength = 0.0;
	47	fWidth = 0.0;
	48	fLengthRim = 0.0;
	49	fWidthRim = 0.0;
	50	fLengthOPad = 0.0;
	51	fWidthOPad = 0.0;
	52	fLengthIPad = 0.0;
	53	fWidthIPad = 0.0;
	54
	55	fRowSpacing = 0.0;
	56	fColSpacing = 0.0;
	57
	58	fNrows = 0;
	59	fNcols = 0;
	60
	61	fPadRow = 0;
	62	fPadCol = 0;
	63
	64	fTiltingAngle = 0.0;
65
66	}
67
68	//_____________________________________________________________________________
69	AliTRDpadPlane::AliTRDpadPlane(Int_t p, Int_t c):TObject()
70	{
71	//
72	// Constructor that initializes a given pad plane type
73	//
74
75	fGeo = new AliTRDgeometryFull();
76
77	fPla = p;
78	fCha = c;
79
e0d47c25	80	fRowSpacing = 0.0;
	81	fColSpacing = 0.0;
	82
	83	fLengthRim = 1.0;
	84	fWidthRim = 0.5;
	85
	86	fNcols = 144;
	87
	88	//
	89	// The pad plane parameter
	90	//
	91	switch (p) {
	92	case 0:
	93	if (c == 2) {
	94	// L0C0 type
	95	fNrows = 12;
	96	fLength = 108.0;
287c5d50	97	fWidth = 92.2;
e0d47c25	98	fLengthOPad = 8.0;
	99	fWidthOPad = 0.515;
	100	fLengthIPad = 9.0;
	101	fWidthIPad = 0.635;
	102	fTiltingAngle = -2.0;
	103	}
	104	else {
	105	// L0C1 type
	106	fNrows = 16;
	107	fLength = 122.0;
287c5d50	108	fWidth = 92.2;
e0d47c25	109	fLengthOPad = 7.5;
	110	fWidthOPad = 0.515;
	111	fLengthIPad = 7.5;
	112	fWidthIPad = 0.635;
	113	fTiltingAngle = -2.0;
	114	}
	115	break;
	116	case 1:
	117	if (c == 2) {
	118	// L1C0 type
	119	fNrows = 12;
	120	fLength = 108.0;
	121	fWidth = 96.6;
	122	fLengthOPad = 8.0;
	123	fWidthOPad = 0.585;
	124	fLengthIPad = 9.0;
	125	fWidthIPad = 0.665;
	126	fTiltingAngle = 2.0;
	127	}
	128	else {
	129	// L1C1 type
	130	fNrows = 16;
	131	fLength = 122.0;
	132	fWidth = 96.6;
	133	fLengthOPad = 7.5;
	134	fWidthOPad = 0.585;
	135	fLengthIPad = 7.5;
	136	fWidthIPad = 0.665;
	137	fTiltingAngle = 2.0;
	138	}
	139	break;
	140	case 2:
	141	if (c == 2) {
	142	// L2C0 type
	143	fNrows = 12;
	144	fLength = 108.0;
	145	fWidth = 101.1;
	146	fLengthOPad = 8.0;
	147	fWidthOPad = 0.705;
	148	fLengthIPad = 9.0;
	149	fWidthIPad = 0.695;
	150	fTiltingAngle = -2.0;
	151	}
	152	else {
	153	// L2C1 type
	154	fNrows = 16;
	155	fLength = 129.0;
	156	fWidth = 101.1;
	157	fLengthOPad = 7.5;
	158	fWidthOPad = 0.705;
	159	fLengthIPad = 8.0;
	160	fWidthIPad = 0.695;
	161	fTiltingAngle = -2.0;
	162	}
	163	break;
	164	case 3:
	165	if (c == 2) {
	166	// L3C0 type
	167	fNrows = 12;
	168	fLength = 108.0;
	169	fWidth = 105.5;
	170	fLengthOPad = 8.0;
	171	fWidthOPad = 0.775;
	172	fLengthIPad = 9.0;
173	fWidthIPad = 0.725;
174	fTiltingAngle = 2.0;
175	}
176	else {
177	// L3C1 type
178	fNrows = 16;
179	fLength = 136.0;
180	fWidth = 105.5;
181	fLengthOPad = 7.5;
182	fWidthOPad = 0.775;
183	fLengthIPad = 8.5;
184	fWidthIPad = 0.725;
185	fTiltingAngle = 2.0;
186	}
187	break;
188	case 4:
189	if (c == 2) {
190	// L4C0 type
191	fNrows = 12;
192	fLength = 108.0;
193	fWidth = 109.9;
194	fLengthOPad = 8.0;
195	fWidthOPad = 0.845;
196	fLengthIPad = 9.0;
197	fWidthIPad = 0.755;
198	fTiltingAngle = -2.0;
199	}
200	else {
201	// L4C1 type
202	fNrows = 16;
203	fLength = 143.0;
204	fWidth = 109.9;
205	fLengthOPad = 7.5;
206	fWidthOPad = 0.845;
207	fLengthIPad = 9.0;
208	fWidthIPad = 0.755;
209	fTiltingAngle = -2.0;
210	}
211	break;
212	case 5:
213	if (c == 2) {
214	// L5C0 type
215	fNrows = 12;
216	fLength = 108.0;
217	fWidth = 114.4;
218	fLengthOPad = 8.0;
219	fWidthOPad = 0.965;
220	fLengthIPad = 9.0;
221	fWidthIPad = 0.785;
222	fTiltingAngle = 2.0;
223	}
224	else {
225	// L5C1 type
226	fNrows = 16;
227	fLength = 145.0;
228	fWidth = 114.4;
229	fLengthOPad = 8.5;
230	fWidthOPad = 0.965;
231	fLengthIPad = 9.0;
232	fWidthIPad = 0.785;
233	fTiltingAngle = 2.0;
234	}
235	break;
236	};
237
a5cadd36	238	//
	239	// Store tilting angle as tangens (opposite direction!)
	240	//
	241	fTiltingAngle = TMath::Tan(TMath::Pi()/180.0 * -fTiltingAngle);
	242
e0d47c25	243	//
	244	// The positions of the borders of the pads
	245	//
	246	// Row direction
	247	//
	248	if (fPadRow) delete [] fPadRow;
	249	fPadRow = new Double_t[fNrows];
	250	Double_t row = fGeo->GetChamberLength(p,0)
	251	+ fGeo->GetChamberLength(p,1)
	252	+ fGeo->GetChamberLength(p,2) / 2.
a5cadd36	253	- fGeo->RpadW()
e0d47c25	254	- fLengthRim;
	255	for (Int_t ic = 0; ic < c; ic++) {
	256	row -= fGeo->GetChamberLength(p,ic);
	257	}
	258	for (Int_t ir = 0; ir < fNrows; ir++) {
	259	fPadRow[ir] = row;
	260	row -= fRowSpacing;
a5cadd36	261	if (ir == 0) {
e0d47c25	262	row -= fLengthOPad;
	263	}
	264	else {
	265	row -= fLengthIPad;
	266	}
	267	}
	268	//
	269	// Column direction
	270	//
	271	if (fPadCol) delete [] fPadCol;
	272	fPadCol = new Double_t[fNcols];
	273	Double_t col = fGeo->GetChamberWidth(p) / 2.
287c5d50	274	+ fGeo->CroWid()
e0d47c25	275	- fWidthRim;
	276	for (Int_t ic = 0; ic < fNcols; ic++) {
	277	fPadCol[ic] = col;
	278	col -= fColSpacing;
a5cadd36	279	if (ic == 0) {
e0d47c25	280	col -= fWidthOPad;
	281	}
	282	else {
	283	col -= fWidthIPad;
	284	}
	285	}
	286
	287	}
	288
	289	//_____________________________________________________________________________
	290	AliTRDpadPlane::AliTRDpadPlane(const AliTRDpadPlane &p):TObject(p)
	291	{
	292	//
	293	// AliTRDpadPlane copy constructor
	294	//
	295
	296	((AliTRDpadPlane &) p).Copy(*this);
	297
	298	}
	299
	300	//_____________________________________________________________________________
	301	AliTRDpadPlane::~AliTRDpadPlane()
	302	{
	303	//
	304	// AliTRDpadPlane destructor
	305	//
	306
	307	if (fGeo) {
	308	delete fGeo;
	309	fGeo = 0;
	310	}
	311
	312	if (fPadRow) {
	313	delete [] fPadRow;
	314	fPadRow = 0;
	315	}
	316
	317	if (fPadCol) {
	318	delete [] fPadCol;
	319	fPadCol = 0;
	320	}
	321
	322	}
	323
3c537e64	324	//_____________________________________________________________________________
	325	AliTRDpadPlane &AliTRDpadPlane::operator=(const AliTRDpadPlane &p)
	326	{
	327	//
	328	// Assignment operator
	329	//
	330
	331	if (this != &p) ((AliTRDpadPlane &) p).Copy(*this);
	332	return *this;
	333
	334	}
	335
e0d47c25	336	//_____________________________________________________________________________
	337	void AliTRDpadPlane::Copy(TObject &p) const
	338	{
	339	//
	340	// Copy function
	341	//
	342
	343	Int_t iBin = 0;
	344
	345	((AliTRDpadPlane &) p).fGeo = 0;
	346
	347	((AliTRDpadPlane &) p).fPla = fPla;
	348	((AliTRDpadPlane &) p).fCha = fCha;
	349
	350	((AliTRDpadPlane &) p).fLength = fLength;
	351	((AliTRDpadPlane &) p).fWidth = fWidth;
	352	((AliTRDpadPlane &) p).fLengthRim = fLengthRim;
	353	((AliTRDpadPlane &) p).fWidthRim = fWidthRim;
	354	((AliTRDpadPlane &) p).fLengthOPad = fLengthOPad;
	355	((AliTRDpadPlane &) p).fWidthOPad = fWidthOPad;
	356	((AliTRDpadPlane &) p).fLengthIPad = fLengthIPad;
	357	((AliTRDpadPlane &) p).fWidthIPad = fWidthIPad;
	358
	359	((AliTRDpadPlane &) p).fRowSpacing = fRowSpacing;
	360	((AliTRDpadPlane &) p).fColSpacing = fColSpacing;
	361
	362	((AliTRDpadPlane &) p).fNrows = fNrows;
	363	((AliTRDpadPlane &) p).fNcols = fNcols;
	364
	365	((AliTRDpadPlane &) p).fTiltingAngle = fTiltingAngle;
	366
	367	if (((AliTRDpadPlane &) p).fPadRow) delete [] ((AliTRDpadPlane &) p).fPadRow;
	368	((AliTRDpadPlane &) p).fPadRow = new Double_t[fNrows];
	369	for (iBin = 0; iBin < fNrows; iBin++) {
	370	((AliTRDpadPlane &) p).fPadRow[iBin] = fPadRow[iBin];
	371	}
	372
	373	if (((AliTRDpadPlane &) p).fPadCol) delete [] ((AliTRDpadPlane &) p).fPadCol;
	374	((AliTRDpadPlane &) p).fPadCol = new Double_t[fNrows];
	375	for (iBin = 0; iBin < fNrows; iBin++) {
	376	((AliTRDpadPlane &) p).fPadCol[iBin] = fPadCol[iBin];
	377	}
	378
	379	TObject::Copy(p);
	380
	381	}
	382
	383	//_____________________________________________________________________________
a5cadd36	384	Int_t AliTRDpadPlane::GetPadRowNumber(const Double_t z) const
e0d47c25	385	{
	386	//
	387	// Finds the pad row number for a given global z-position
	388	//
	389
	390	Int_t row = 0;
	391	Int_t nabove = 0;
	392	Int_t nbelow = 0;
	393	Int_t middle = 0;
	394
a5cadd36	395	if ((z > GetRow0()) \|\| (z < GetRowEnd())) {
a5cadd36	396
e0d47c25	397	row = -1;
a5cadd36	398
e0d47c25	399	}
e0d47c25	400	else {
a5cadd36	401
e0d47c25	402	nabove = fNrows+1;
	403	nbelow = 0;
	404	while (nabove - nbelow > 1) {
	405	middle = (nabove + nbelow) / 2;
	406	if (z == fPadRow[middle-1]) row = middle;
	407	if (z > fPadRow[middle-1]) nabove = middle;
	408	else nbelow = middle;
	409	}
	410	row = nbelow - 1;
a5cadd36	411
e0d47c25	412	}
	413
	414	return row;
	415
	416	}
	417
	418	//_____________________________________________________________________________
a5cadd36	419	Int_t AliTRDpadPlane::GetPadColNumber(const Double_t rphi
a5cadd36	420	, const Double_t rowOffset) const
e0d47c25	421	{
	422	//
	423	// Finds the pad column number for a given global rphi-position
	424	//
	425
a5cadd36	426	Int_t col = 0;
	427	Int_t nabove = 0;
	428	Int_t nbelow = 0;
	429	Int_t middle = 0;
	430	Double_t rphiShift = 0;
	431
	432	if ((rphi > GetCol0()) \|\| (rphi < GetColEnd())) {
e0d47c25	433
e0d47c25	434	col = -1;
a5cadd36	435
e0d47c25	436	}
e0d47c25	437	else {
a5cadd36	438
	439	//
	440	// Take the tilting angle into account by shifting the hit position
	441	// into the opposite direction
	442	//
	443
	444	rphiShift = rphi + fTiltingAngle * rowOffset;
	445
e0d47c25	446	nabove = fNcols+1;
	447	nbelow = 0;
	448	while (nabove - nbelow > 1) {
	449	middle = (nabove + nbelow) / 2;
	450	if (rphi == fPadCol[middle-1]) col = middle;
	451	if (rphi > fPadCol[middle-1]) nabove = middle;
	452	else nbelow = middle;
	453	}
	454	col = nbelow - 1;
e0d47c25	455
a5cadd36	456	//printf("rphi=%f, rphiShift=%f, col=%d, colH=%f\n"
a5cadd36	457	// ,rphi,rphiShift,col,fPadCol[col]);
e0d47c25	458
e0d47c25	459	}
e0d47c25	460
a5cadd36	461	return col;
e0d47c25	462
e0d47c25	463	}