[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(),fPadRow(0),fPadCol(0)
{
  //
  // 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
  //
  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
  //
  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	//_____________________________________________________________________________
a0cd5002	69	AliTRDpadPlane::AliTRDpadPlane(Int_t p, Int_t c):TObject(),fPadRow(0),fPadCol(0)
e0d47c25	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	//
e0d47c25	248	fPadRow = new Double_t[fNrows];
	249	Double_t row = fGeo->GetChamberLength(p,0)
	250	+ fGeo->GetChamberLength(p,1)
	251	+ fGeo->GetChamberLength(p,2) / 2.
a5cadd36	252	- fGeo->RpadW()
e0d47c25	253	- fLengthRim;
	254	for (Int_t ic = 0; ic < c; ic++) {
	255	row -= fGeo->GetChamberLength(p,ic);
	256	}
	257	for (Int_t ir = 0; ir < fNrows; ir++) {
	258	fPadRow[ir] = row;
	259	row -= fRowSpacing;
a5cadd36	260	if (ir == 0) {
e0d47c25	261	row -= fLengthOPad;
	262	}
	263	else {
	264	row -= fLengthIPad;
	265	}
	266	}
	267	//
	268	// Column direction
	269	//
e0d47c25	270	fPadCol = new Double_t[fNcols];
e0d47c25	271	Double_t col = fGeo->GetChamberWidth(p) / 2.
287c5d50	272	+ fGeo->CroWid()
e0d47c25	273	- fWidthRim;
	274	for (Int_t ic = 0; ic < fNcols; ic++) {
	275	fPadCol[ic] = col;
	276	col -= fColSpacing;
a5cadd36	277	if (ic == 0) {
e0d47c25	278	col -= fWidthOPad;
	279	}
	280	else {
	281	col -= fWidthIPad;
	282	}
	283	}
	284
	285	}
	286
	287	//_____________________________________________________________________________
	288	AliTRDpadPlane::AliTRDpadPlane(const AliTRDpadPlane &p):TObject(p)
	289	{
	290	//
	291	// AliTRDpadPlane copy constructor
	292	//
	293
	294	((AliTRDpadPlane &) p).Copy(*this);
	295
	296	}
	297
	298	//_____________________________________________________________________________
	299	AliTRDpadPlane::~AliTRDpadPlane()
	300	{
	301	//
	302	// AliTRDpadPlane destructor
	303	//
	304
	305	if (fGeo) {
	306	delete fGeo;
	307	fGeo = 0;
	308	}
	309
	310	if (fPadRow) {
	311	delete [] fPadRow;
	312	fPadRow = 0;
	313	}
	314
	315	if (fPadCol) {
	316	delete [] fPadCol;
	317	fPadCol = 0;
	318	}
	319
	320	}
	321
3c537e64	322	//_____________________________________________________________________________
	323	AliTRDpadPlane &AliTRDpadPlane::operator=(const AliTRDpadPlane &p)
	324	{
	325	//
	326	// Assignment operator
	327	//
	328
	329	if (this != &p) ((AliTRDpadPlane &) p).Copy(*this);
	330	return *this;
	331
	332	}
	333
e0d47c25	334	//_____________________________________________________________________________
	335	void AliTRDpadPlane::Copy(TObject &p) const
	336	{
	337	//
	338	// Copy function
	339	//
	340
	341	Int_t iBin = 0;
	342
	343	((AliTRDpadPlane &) p).fGeo = 0;
	344
	345	((AliTRDpadPlane &) p).fPla = fPla;
	346	((AliTRDpadPlane &) p).fCha = fCha;
	347
	348	((AliTRDpadPlane &) p).fLength = fLength;
	349	((AliTRDpadPlane &) p).fWidth = fWidth;
	350	((AliTRDpadPlane &) p).fLengthRim = fLengthRim;
	351	((AliTRDpadPlane &) p).fWidthRim = fWidthRim;
	352	((AliTRDpadPlane &) p).fLengthOPad = fLengthOPad;
	353	((AliTRDpadPlane &) p).fWidthOPad = fWidthOPad;
	354	((AliTRDpadPlane &) p).fLengthIPad = fLengthIPad;
	355	((AliTRDpadPlane &) p).fWidthIPad = fWidthIPad;
	356
	357	((AliTRDpadPlane &) p).fRowSpacing = fRowSpacing;
	358	((AliTRDpadPlane &) p).fColSpacing = fColSpacing;
	359
	360	((AliTRDpadPlane &) p).fNrows = fNrows;
	361	((AliTRDpadPlane &) p).fNcols = fNcols;
	362
	363	((AliTRDpadPlane &) p).fTiltingAngle = fTiltingAngle;
	364
	365	if (((AliTRDpadPlane &) p).fPadRow) delete [] ((AliTRDpadPlane &) p).fPadRow;
	366	((AliTRDpadPlane &) p).fPadRow = new Double_t[fNrows];
	367	for (iBin = 0; iBin < fNrows; iBin++) {
	368	((AliTRDpadPlane &) p).fPadRow[iBin] = fPadRow[iBin];
	369	}
	370
	371	if (((AliTRDpadPlane &) p).fPadCol) delete [] ((AliTRDpadPlane &) p).fPadCol;
	372	((AliTRDpadPlane &) p).fPadCol = new Double_t[fNrows];
	373	for (iBin = 0; iBin < fNrows; iBin++) {
	374	((AliTRDpadPlane &) p).fPadCol[iBin] = fPadCol[iBin];
	375	}
	376
	377	TObject::Copy(p);
	378
	379	}
	380
	381	//_____________________________________________________________________________
a5cadd36	382	Int_t AliTRDpadPlane::GetPadRowNumber(const Double_t z) const
e0d47c25	383	{
	384	//
	385	// Finds the pad row number for a given global z-position
	386	//
	387
	388	Int_t row = 0;
	389	Int_t nabove = 0;
	390	Int_t nbelow = 0;
	391	Int_t middle = 0;
	392
a5cadd36	393	if ((z > GetRow0()) \|\| (z < GetRowEnd())) {
a5cadd36	394
e0d47c25	395	row = -1;
a5cadd36	396
e0d47c25	397	}
e0d47c25	398	else {
a5cadd36	399
e0d47c25	400	nabove = fNrows+1;
	401	nbelow = 0;
	402	while (nabove - nbelow > 1) {
	403	middle = (nabove + nbelow) / 2;
	404	if (z == fPadRow[middle-1]) row = middle;
	405	if (z > fPadRow[middle-1]) nabove = middle;
	406	else nbelow = middle;
	407	}
	408	row = nbelow - 1;
a5cadd36	409
e0d47c25	410	}
	411
	412	return row;
	413
	414	}
	415
	416	//_____________________________________________________________________________
a5cadd36	417	Int_t AliTRDpadPlane::GetPadColNumber(const Double_t rphi
a5cadd36	418	, const Double_t rowOffset) const
e0d47c25	419	{
	420	//
	421	// Finds the pad column number for a given global rphi-position
	422	//
	423
a5cadd36	424	Int_t col = 0;
	425	Int_t nabove = 0;
	426	Int_t nbelow = 0;
	427	Int_t middle = 0;
	428	Double_t rphiShift = 0;
	429
	430	if ((rphi > GetCol0()) \|\| (rphi < GetColEnd())) {
e0d47c25	431
e0d47c25	432	col = -1;
a5cadd36	433
e0d47c25	434	}
e0d47c25	435	else {
a5cadd36	436
	437	//
	438	// Take the tilting angle into account by shifting the hit position
	439	// into the opposite direction
	440	//
	441
	442	rphiShift = rphi + fTiltingAngle * rowOffset;
	443
e0d47c25	444	nabove = fNcols+1;
	445	nbelow = 0;
	446	while (nabove - nbelow > 1) {
	447	middle = (nabove + nbelow) / 2;
	448	if (rphi == fPadCol[middle-1]) col = middle;
	449	if (rphi > fPadCol[middle-1]) nabove = middle;
	450	else nbelow = middle;
	451	}
	452	col = nbelow - 1;
e0d47c25	453
a5cadd36	454	//printf("rphi=%f, rphiShift=%f, col=%d, colH=%f\n"
a5cadd36	455	// ,rphi,rphiShift,col,fPadCol[col]);
e0d47c25	456
e0d47c25	457	}
e0d47c25	458
a5cadd36	459	return col;
e0d47c25	460
e0d47c25	461	}