[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 "AliTRDgeometry.h"

ClassImp(AliTRDpadPlane)

//_____________________________________________________________________________
AliTRDpadPlane::AliTRDpadPlane()
  :TObject()
  ,fGeo(0)
  ,fPla(0)
  ,fCha(0)
  ,fLength(0)
  ,fWidth(0)
  ,fLengthRim(0)
  ,fWidthRim(0)
  ,fLengthOPad(0)
  ,fWidthOPad(0)
  ,fLengthIPad(0)
  ,fWidthIPad(0)
  ,fRowSpacing(0)
  ,fColSpacing(0)
  ,fNrows(0)
  ,fNcols(0)
  ,fTiltingAngle(0)
  ,fTiltingTan(0)
  ,fPadRow(0)
  ,fPadCol(0)
{
  //
  // Default constructor
  //

}

//_____________________________________________________________________________
AliTRDpadPlane::AliTRDpadPlane(Int_t p, Int_t c)
  :TObject()
  ,fGeo(0)
  ,fPla(0)
  ,fCha(0)
  ,fLength(0)
  ,fWidth(0)
  ,fLengthRim(0)
  ,fWidthRim(0)
  ,fLengthOPad(0)
  ,fWidthOPad(0)
  ,fLengthIPad(0)
  ,fWidthIPad(0)
  ,fRowSpacing(0)
  ,fColSpacing(0)
  ,fNrows(0)
  ,fNcols(0)
  ,fTiltingAngle(0)
  ,fTiltingTan(0)
  ,fPadRow(0)
  ,fPadCol(0)
{
  //
  // Constructor that initializes a given pad plane type
  //

  fGeo = new AliTRDgeometry();

  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
  //
  fTiltingTan = 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)
  ,fGeo(0)
  ,fPla(p.fPla)
  ,fCha(p.fCha)
  ,fLength(p.fLength)
  ,fWidth(p.fWidth)
  ,fLengthRim(p.fLengthRim)
  ,fWidthRim(p.fLengthRim)
  ,fLengthOPad(p.fLengthOPad)
  ,fWidthOPad(p.fWidthOPad)
  ,fLengthIPad(p.fLengthIPad)
  ,fWidthIPad(p.fWidthIPad)
  ,fRowSpacing(p.fRowSpacing)
  ,fColSpacing(p.fColSpacing)
  ,fNrows(p.fNrows)
  ,fNcols(p.fNcols)
  ,fTiltingAngle(p.fTiltingAngle)
  ,fTiltingTan(p.fTiltingTan)
  ,fPadRow(0)
  ,fPadCol(0)
{
  //
  // AliTRDpadPlane copy constructor
  //

  Int_t iBin = 0;

  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];
  }                                                                             

}

//_____________________________________________________________________________
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;
  ((AliTRDpadPlane &) p).fTiltingTan   = fTiltingTan;

  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(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(Double_t rphi
				     , 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;

  // MI change don't apply tilting angle here - better to do it directly on hit level
  // Take the tilting angle into account by shifting the hit position
  // into the opposite direction
  // 

  rphiShift = rphi ;

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

    col = -1;

  }
  else {

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

  }

  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"
bd0f8685	30	#include "AliTRDgeometry.h"
e0d47c25	31
	32	ClassImp(AliTRDpadPlane)
	33
	34	//_____________________________________________________________________________
2745a409	35	AliTRDpadPlane::AliTRDpadPlane()
	36	:TObject()
	37	,fGeo(0)
	38	,fPla(0)
	39	,fCha(0)
	40	,fLength(0)
	41	,fWidth(0)
	42	,fLengthRim(0)
	43	,fWidthRim(0)
	44	,fLengthOPad(0)
	45	,fWidthOPad(0)
	46	,fLengthIPad(0)
	47	,fWidthIPad(0)
	48	,fRowSpacing(0)
	49	,fColSpacing(0)
	50	,fNrows(0)
	51	,fNcols(0)
	52	,fTiltingAngle(0)
	53	,fTiltingTan(0)
	54	,fPadRow(0)
	55	,fPadCol(0)
e0d47c25	56	{
	57	//
	58	// Default constructor
	59	//
	60
e0d47c25	61	}
	62
	63	//_____________________________________________________________________________
2745a409	64	AliTRDpadPlane::AliTRDpadPlane(Int_t p, Int_t c)
	65	:TObject()
	66	,fGeo(0)
	67	,fPla(0)
	68	,fCha(0)
	69	,fLength(0)
	70	,fWidth(0)
	71	,fLengthRim(0)
	72	,fWidthRim(0)
	73	,fLengthOPad(0)
	74	,fWidthOPad(0)
	75	,fLengthIPad(0)
	76	,fWidthIPad(0)
	77	,fRowSpacing(0)
	78	,fColSpacing(0)
	79	,fNrows(0)
	80	,fNcols(0)
	81	,fTiltingAngle(0)
	82	,fTiltingTan(0)
	83	,fPadRow(0)
	84	,fPadCol(0)
e0d47c25	85	{
	86	//
	87	// Constructor that initializes a given pad plane type
	88	//
	89
bd0f8685	90	fGeo = new AliTRDgeometry();
e0d47c25	91
	92	fPla = p;
	93	fCha = c;
	94
e0d47c25	95	fRowSpacing = 0.0;
	96	fColSpacing = 0.0;
	97
	98	fLengthRim = 1.0;
	99	fWidthRim = 0.5;
	100
	101	fNcols = 144;
	102
	103	//
	104	// The pad plane parameter
	105	//
	106	switch (p) {
	107	case 0:
	108	if (c == 2) {
	109	// L0C0 type
	110	fNrows = 12;
	111	fLength = 108.0;
287c5d50	112	fWidth = 92.2;
e0d47c25	113	fLengthOPad = 8.0;
	114	fWidthOPad = 0.515;
	115	fLengthIPad = 9.0;
	116	fWidthIPad = 0.635;
	117	fTiltingAngle = -2.0;
	118	}
	119	else {
	120	// L0C1 type
	121	fNrows = 16;
	122	fLength = 122.0;
287c5d50	123	fWidth = 92.2;
e0d47c25	124	fLengthOPad = 7.5;
	125	fWidthOPad = 0.515;
	126	fLengthIPad = 7.5;
	127	fWidthIPad = 0.635;
	128	fTiltingAngle = -2.0;
	129	}
	130	break;
	131	case 1:
	132	if (c == 2) {
	133	// L1C0 type
	134	fNrows = 12;
	135	fLength = 108.0;
	136	fWidth = 96.6;
	137	fLengthOPad = 8.0;
	138	fWidthOPad = 0.585;
	139	fLengthIPad = 9.0;
	140	fWidthIPad = 0.665;
	141	fTiltingAngle = 2.0;
	142	}
	143	else {
	144	// L1C1 type
	145	fNrows = 16;
	146	fLength = 122.0;
	147	fWidth = 96.6;
	148	fLengthOPad = 7.5;
	149	fWidthOPad = 0.585;
	150	fLengthIPad = 7.5;
	151	fWidthIPad = 0.665;
	152	fTiltingAngle = 2.0;
	153	}
	154	break;
	155	case 2:
	156	if (c == 2) {
	157	// L2C0 type
	158	fNrows = 12;
	159	fLength = 108.0;
	160	fWidth = 101.1;
	161	fLengthOPad = 8.0;
	162	fWidthOPad = 0.705;
	163	fLengthIPad = 9.0;
	164	fWidthIPad = 0.695;
	165	fTiltingAngle = -2.0;
	166	}
	167	else {
	168	// L2C1 type
	169	fNrows = 16;
	170	fLength = 129.0;
	171	fWidth = 101.1;
	172	fLengthOPad = 7.5;
	173	fWidthOPad = 0.705;
	174	fLengthIPad = 8.0;
	175	fWidthIPad = 0.695;
	176	fTiltingAngle = -2.0;
	177	}
	178	break;
	179	case 3:
	180	if (c == 2) {
	181	// L3C0 type
	182	fNrows = 12;
	183	fLength = 108.0;
	184	fWidth = 105.5;
	185	fLengthOPad = 8.0;
	186	fWidthOPad = 0.775;
	187	fLengthIPad = 9.0;
188	fWidthIPad = 0.725;
189	fTiltingAngle = 2.0;
190	}
191	else {
192	// L3C1 type
193	fNrows = 16;
194	fLength = 136.0;
195	fWidth = 105.5;
196	fLengthOPad = 7.5;
197	fWidthOPad = 0.775;
198	fLengthIPad = 8.5;
199	fWidthIPad = 0.725;
200	fTiltingAngle = 2.0;
201	}
202	break;
203	case 4:
204	if (c == 2) {
205	// L4C0 type
206	fNrows = 12;
207	fLength = 108.0;
208	fWidth = 109.9;
209	fLengthOPad = 8.0;
210	fWidthOPad = 0.845;
211	fLengthIPad = 9.0;
212	fWidthIPad = 0.755;
213	fTiltingAngle = -2.0;
214	}
215	else {
216	// L4C1 type
217	fNrows = 16;
218	fLength = 143.0;
219	fWidth = 109.9;
220	fLengthOPad = 7.5;
221	fWidthOPad = 0.845;
222	fLengthIPad = 9.0;
223	fWidthIPad = 0.755;
224	fTiltingAngle = -2.0;
225	}
226	break;
227	case 5:
228	if (c == 2) {
229	// L5C0 type
230	fNrows = 12;
231	fLength = 108.0;
232	fWidth = 114.4;
233	fLengthOPad = 8.0;
234	fWidthOPad = 0.965;
235	fLengthIPad = 9.0;
236	fWidthIPad = 0.785;
237	fTiltingAngle = 2.0;
238	}
239	else {
240	// L5C1 type
241	fNrows = 16;
242	fLength = 145.0;
243	fWidth = 114.4;
244	fLengthOPad = 8.5;
245	fWidthOPad = 0.965;
246	fLengthIPad = 9.0;
247	fWidthIPad = 0.785;
248	fTiltingAngle = 2.0;
249	}
250	break;
251	};
252
a5cadd36	253	//
2f4fac20	254	// Store tilting angle as tangens
a5cadd36	255	//
2f4fac20	256	fTiltingTan = TMath::Tan(TMath::Pi()/180.0 * fTiltingAngle);
a5cadd36	257
e0d47c25	258	//
	259	// The positions of the borders of the pads
	260	//
	261	// Row direction
	262	//
e0d47c25	263	fPadRow = new Double_t[fNrows];
	264	Double_t row = fGeo->GetChamberLength(p,0)
	265	+ fGeo->GetChamberLength(p,1)
	266	+ fGeo->GetChamberLength(p,2) / 2.
a5cadd36	267	- fGeo->RpadW()
e0d47c25	268	- fLengthRim;
	269	for (Int_t ic = 0; ic < c; ic++) {
	270	row -= fGeo->GetChamberLength(p,ic);
	271	}
	272	for (Int_t ir = 0; ir < fNrows; ir++) {
	273	fPadRow[ir] = row;
	274	row -= fRowSpacing;
a5cadd36	275	if (ir == 0) {
e0d47c25	276	row -= fLengthOPad;
	277	}
	278	else {
	279	row -= fLengthIPad;
	280	}
	281	}
	282	//
	283	// Column direction
	284	//
e0d47c25	285	fPadCol = new Double_t[fNcols];
e0d47c25	286	Double_t col = fGeo->GetChamberWidth(p) / 2.
287c5d50	287	+ fGeo->CroWid()
e0d47c25	288	- fWidthRim;
	289	for (Int_t ic = 0; ic < fNcols; ic++) {
	290	fPadCol[ic] = col;
	291	col -= fColSpacing;
a5cadd36	292	if (ic == 0) {
e0d47c25	293	col -= fWidthOPad;
	294	}
	295	else {
	296	col -= fWidthIPad;
	297	}
	298	}
	299
	300	}
	301
	302	//_____________________________________________________________________________
2745a409	303	AliTRDpadPlane::AliTRDpadPlane(const AliTRDpadPlane &p)
	304	:TObject(p)
	305	,fGeo(0)
	306	,fPla(p.fPla)
	307	,fCha(p.fCha)
	308	,fLength(p.fLength)
	309	,fWidth(p.fWidth)
	310	,fLengthRim(p.fLengthRim)
	311	,fWidthRim(p.fLengthRim)
	312	,fLengthOPad(p.fLengthOPad)
	313	,fWidthOPad(p.fWidthOPad)
	314	,fLengthIPad(p.fLengthIPad)
	315	,fWidthIPad(p.fWidthIPad)
	316	,fRowSpacing(p.fRowSpacing)
	317	,fColSpacing(p.fColSpacing)
	318	,fNrows(p.fNrows)
	319	,fNcols(p.fNcols)
	320	,fTiltingAngle(p.fTiltingAngle)
	321	,fTiltingTan(p.fTiltingTan)
	322	,fPadRow(0)
	323	,fPadCol(0)
e0d47c25	324	{
	325	//
	326	// AliTRDpadPlane copy constructor
	327	//
	328
2745a409	329	Int_t iBin = 0;
	330
	331	if (((AliTRDpadPlane &) p).fPadRow) delete [] ((AliTRDpadPlane &) p).fPadRow;
	332	((AliTRDpadPlane &) p).fPadRow = new Double_t[fNrows];
	333	for (iBin = 0; iBin < fNrows; iBin++) {
	334	((AliTRDpadPlane &) p).fPadRow[iBin] = fPadRow[iBin];
	335	}
	336
	337	if (((AliTRDpadPlane &) p).fPadCol) delete [] ((AliTRDpadPlane &) p).fPadCol;
	338	((AliTRDpadPlane &) p).fPadCol = new Double_t[fNrows];
	339	for (iBin = 0; iBin < fNrows; iBin++) {
	340	((AliTRDpadPlane &) p).fPadCol[iBin] = fPadCol[iBin];
	341	}
e0d47c25	342
	343	}
	344
	345	//_____________________________________________________________________________
	346	AliTRDpadPlane::~AliTRDpadPlane()
	347	{
	348	//
	349	// AliTRDpadPlane destructor
	350	//
	351
	352	if (fGeo) {
	353	delete fGeo;
	354	fGeo = 0;
	355	}
	356
	357	if (fPadRow) {
	358	delete [] fPadRow;
	359	fPadRow = 0;
	360	}
	361
	362	if (fPadCol) {
	363	delete [] fPadCol;
	364	fPadCol = 0;
	365	}
	366
	367	}
	368
3c537e64	369	//_____________________________________________________________________________
	370	AliTRDpadPlane &AliTRDpadPlane::operator=(const AliTRDpadPlane &p)
	371	{
	372	//
	373	// Assignment operator
	374	//
	375
	376	if (this != &p) ((AliTRDpadPlane &) p).Copy(*this);
	377	return *this;
	378
	379	}
	380
e0d47c25	381	//_____________________________________________________________________________
	382	void AliTRDpadPlane::Copy(TObject &p) const
	383	{
	384	//
	385	// Copy function
	386	//
	387
	388	Int_t iBin = 0;
	389
	390	((AliTRDpadPlane &) p).fGeo = 0;
	391
	392	((AliTRDpadPlane &) p).fPla = fPla;
	393	((AliTRDpadPlane &) p).fCha = fCha;
	394
	395	((AliTRDpadPlane &) p).fLength = fLength;
	396	((AliTRDpadPlane &) p).fWidth = fWidth;
	397	((AliTRDpadPlane &) p).fLengthRim = fLengthRim;
	398	((AliTRDpadPlane &) p).fWidthRim = fWidthRim;
	399	((AliTRDpadPlane &) p).fLengthOPad = fLengthOPad;
	400	((AliTRDpadPlane &) p).fWidthOPad = fWidthOPad;
	401	((AliTRDpadPlane &) p).fLengthIPad = fLengthIPad;
	402	((AliTRDpadPlane &) p).fWidthIPad = fWidthIPad;
	403
	404	((AliTRDpadPlane &) p).fRowSpacing = fRowSpacing;
	405	((AliTRDpadPlane &) p).fColSpacing = fColSpacing;
	406
	407	((AliTRDpadPlane &) p).fNrows = fNrows;
	408	((AliTRDpadPlane &) p).fNcols = fNcols;
	409
	410	((AliTRDpadPlane &) p).fTiltingAngle = fTiltingAngle;
4ffb371b	411	((AliTRDpadPlane &) p).fTiltingTan = fTiltingTan;
e0d47c25	412
	413	if (((AliTRDpadPlane &) p).fPadRow) delete [] ((AliTRDpadPlane &) p).fPadRow;
	414	((AliTRDpadPlane &) p).fPadRow = new Double_t[fNrows];
	415	for (iBin = 0; iBin < fNrows; iBin++) {
	416	((AliTRDpadPlane &) p).fPadRow[iBin] = fPadRow[iBin];
	417	}
	418
	419	if (((AliTRDpadPlane &) p).fPadCol) delete [] ((AliTRDpadPlane &) p).fPadCol;
	420	((AliTRDpadPlane &) p).fPadCol = new Double_t[fNrows];
	421	for (iBin = 0; iBin < fNrows; iBin++) {
	422	((AliTRDpadPlane &) p).fPadCol[iBin] = fPadCol[iBin];
	423	}
	424
	425	TObject::Copy(p);
	426
	427	}
	428
	429	//_____________________________________________________________________________
98ce8151	430	Int_t AliTRDpadPlane::GetPadRowNumber(Double_t z) const
e0d47c25	431	{
	432	//
	433	// Finds the pad row number for a given global z-position
	434	//
	435
	436	Int_t row = 0;
	437	Int_t nabove = 0;
	438	Int_t nbelow = 0;
	439	Int_t middle = 0;
	440
a5cadd36	441	if ((z > GetRow0()) \|\| (z < GetRowEnd())) {
a5cadd36	442
e0d47c25	443	row = -1;
a5cadd36	444
e0d47c25	445	}
e0d47c25	446	else {
a5cadd36	447
e0d47c25	448	nabove = fNrows+1;
	449	nbelow = 0;
	450	while (nabove - nbelow > 1) {
	451	middle = (nabove + nbelow) / 2;
	452	if (z == fPadRow[middle-1]) row = middle;
	453	if (z > fPadRow[middle-1]) nabove = middle;
	454	else nbelow = middle;
	455	}
	456	row = nbelow - 1;
a5cadd36	457
e0d47c25	458	}
	459
	460	return row;
	461
	462	}
	463
	464	//_____________________________________________________________________________
98ce8151	465	Int_t AliTRDpadPlane::GetPadColNumber(Double_t rphi
2745a409	466	, Double_t /rowOffset/) const
e0d47c25	467	{
	468	//
	469	// Finds the pad column number for a given global rphi-position
	470	//
	471
a5cadd36	472	Int_t col = 0;
	473	Int_t nabove = 0;
	474	Int_t nbelow = 0;
	475	Int_t middle = 0;
	476	Double_t rphiShift = 0;
	477
21d9fcf1	478	// MI change don't apply tilting angle here - better to do it directly on hit level
2f4fac20	479	// Take the tilting angle into account by shifting the hit position
2f4fac20	480	// into the opposite direction
21d9fcf1	481	//
21d9fcf1	482
21d9fcf1	483	rphiShift = rphi ;
2f4fac20	484
2f4fac20	485	if ((rphiShift > GetCol0()) \|\| (rphiShift < GetColEnd())) {
e0d47c25	486
e0d47c25	487	col = -1;
a5cadd36	488
e0d47c25	489	}
e0d47c25	490	else {
a5cadd36	491
e0d47c25	492	nabove = fNcols+1;
	493	nbelow = 0;
	494	while (nabove - nbelow > 1) {
	495	middle = (nabove + nbelow) / 2;
2f4fac20	496	if (rphiShift == fPadCol[middle-1]) col = middle;
	497	if (rphiShift > fPadCol[middle-1]) nabove = middle;
	498	else nbelow = middle;
e0d47c25	499	}
e0d47c25	500	col = nbelow - 1;
e0d47c25	501
e0d47c25	502	}
e0d47c25	503
a5cadd36	504	return col;
e0d47c25	505
e0d47c25	506	}