[u/mrichter/AliRoot.git] / TPC / AliTPCROC.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.                  *
 **************************************************************************/


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  Geometry        class for a single ROC                                   //
//                                                                           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////
#include "AliTPCROC.h"
#include "TMath.h"

ClassImp(AliTPCROC)


AliTPCROC* AliTPCROC::fgInstance = 0;


//_ singleton implementation __________________________________________________
AliTPCROC* AliTPCROC::Instance()
{
  //
  // Singleton implementation
  // Returns an instance of this class, it is created if neccessary
  //
  if (fgInstance == 0){
    fgInstance = new AliTPCROC();
    fgInstance->Init();    
  }
  return fgInstance;
}


void AliTPCROC::Init(){
  //
  // initialize static variables
  //
  if (AliTPCROC::fNSectorsAll>0) return;
  fNSectorsAll =72;
  fNSectors[0] =36;
  fNSectors[1] =36;
  //
  fNRows[0]= 63;
  fNRows[1]= 96;
  //
  // number of pads in padrow
  fNPads[0] = new UInt_t[fNRows[0]];
  fNPads[1] = new UInt_t[fNRows[1]];  
  //
  // padrow index in array
  //
  fRowPosIndex[0] = new UInt_t[fNRows[0]];
  fRowPosIndex[1] = new UInt_t[fNRows[1]];
  //
  // inner sectors
  //
  UInt_t index =0;
  for (UInt_t irow=0; irow<fNRows[0];irow++){
    UInt_t npads = (irow==0) ? 68 : 2 *Int_t(Double_t(irow)/3. +33.67);
    fNPads[0][irow] = npads;
    fRowPosIndex[0][irow] = index;
    index+=npads;
  }
  fNChannels[0] = index;
  //
  index =0;
  Double_t k1 = 10.*TMath::Tan(10*TMath::DegToRad())/6.;
  Double_t k2 = 15.*TMath::Tan(10*TMath::DegToRad())/6.;
  for (UInt_t irow=0; irow<fNRows[1];irow++){    
    UInt_t npads = (irow<64) ? 
      2*Int_t(k1*Double_t(irow)+37.75):
      2*Int_t(k2*Double_t(irow-64)+56.66);
    fNPads[1][irow] = npads;
    fRowPosIndex[1][irow] = index;
    index+=npads;
  }
  fNChannels[1] = index;
  SetGeometry();
}


void AliTPCROC::SetGeometry()
{
  //
  //set ROC geometry parameters
  //
  const  Float_t kInnerRadiusLow = 83.65;
  const  Float_t kInnerRadiusUp  = 133.3;
  const  Float_t kOuterRadiusLow = 133.5;
  const  Float_t kOuterRadiusUp  = 247.7;
  const  Float_t kInnerFrameSpace = 1.5;
  const  Float_t kOuterFrameSpace = 1.5;
  const  Float_t kInnerWireMount = 1.2;
  const  Float_t kOuterWireMount = 1.4;
  const  Float_t kZLength =250.;
  const  UInt_t   kNRowLow = 63;
  const  UInt_t   kNRowUp1 = 64;
  const  UInt_t   kNRowUp2 = 32;
  const  UInt_t   kNRowUp  = 96;
  const  Float_t kInnerAngle = 20; // 20 degrees
  const  Float_t kOuterAngle = 20; // 20 degrees
  //
  //  pad     parameters
  // 
  const Float_t  kInnerPadPitchLength = 0.75;
  const Float_t  kInnerPadPitchWidth = 0.40;
  const Float_t  kInnerPadLength = 0.75;
  const Float_t  kInnerPadWidth = 0.40;
  const Float_t  kOuter1PadPitchLength = 1.0;
  const Float_t  kOuterPadPitchWidth = 0.6;
  const Float_t  kOuter1PadLength = 1.0;
  const Float_t  kOuterPadWidth = 0.6;
  const Float_t  kOuter2PadPitchLength = 1.5;
  const Float_t  kOuter2PadLength = 1.5;  

  //
  //wires default parameters
  //
//   const UInt_t    kNInnerWiresPerPad = 3;
//   const UInt_t    kInnerDummyWire = 2;
//   const Float_t  kInnerWWPitch = 0.25;
//   const Float_t  kRInnerFirstWire = 84.475;
//   const Float_t  kRInnerLastWire = 132.475;
//   const Float_t  kInnerOffWire = 0.5;
//   const UInt_t    kNOuter1WiresPerPad = 4;
//   const UInt_t    kNOuter2WiresPerPad = 6;
//   const Float_t  kOuterWWPitch = 0.25;  
//   const Float_t  kROuterFirstWire = 134.225;
//   const Float_t  kROuterLastWire = 246.975;
//   const UInt_t    kOuterDummyWire = 2;
//   const Float_t  kOuterOffWire = 0.5;
  //
  //set sector parameters
  //
  fInnerRadiusLow = kInnerRadiusLow;
  fOuterRadiusLow = kOuterRadiusLow;
  fInnerRadiusUp  = kInnerRadiusUp;
  fOuterRadiusUp  = kOuterRadiusUp;  
  fInnerFrameSpace = kInnerFrameSpace;
  fOuterFrameSpace = kOuterFrameSpace;
  fInnerWireMount  = kInnerWireMount;
  fOuterWireMount  = kOuterWireMount;
  fZLength         = kZLength;
  fInnerAngle      =  TMath::DegToRad()*kInnerAngle;
  fOuterAngle      =  TMath::DegToRad()*kOuterAngle;

  fNRowLow       = kNRowLow;
  fNRowUp1      = kNRowUp1;
  fNRowUp2       = kNRowUp2;
  fNRowUp        = kNRowUp;
  //
  //set pad parameter
  //
  fInnerPadPitchLength = kInnerPadPitchLength;
  fInnerPadPitchWidth  = kInnerPadPitchWidth;
  fInnerPadLength      = kInnerPadLength;
  fInnerPadWidth       = kInnerPadWidth;
  fOuter1PadPitchLength = kOuter1PadPitchLength; 
  fOuter2PadPitchLength = kOuter2PadPitchLength;
  fOuterPadPitchWidth   = kOuterPadPitchWidth;
  fOuter1PadLength      = kOuter1PadLength;
  fOuter2PadLength      = kOuter2PadLength;
  fOuterPadWidth        = kOuterPadWidth; 

  //
  //set wire parameters
  //
  // SetInnerNWires(kNInnerWiresPerPad);
  //   SetInnerDummyWire(kInnerDummyWire);
  //   SetInnerOffWire(kInnerOffWire);
  //   SetOuter1NWires(kNOuter1WiresPerPad);
  //   SetOuter2NWire(kNOuter2WiresPerPad);
  //   SetOuterDummyWire(kOuterDummyWire);
  //   SetOuterOffWire(kOuterOffWire);
  //   SetInnerWWPitch(kInnerWWPitch);
  //   SetRInnerFirstWire(kRInnerFirstWire);
  //   SetRInnerLastWire(kRInnerLastWire);
  //   SetOuterWWPitch(kOuterWWPitch);
  //   SetROuterFirstWire(kROuterFirstWire);
  //   SetROuterLastWire(kROuterLastWire);  

  UInt_t i=0;
  Float_t firstrow = fInnerRadiusLow + 1.575;   
  for( i= 0;i<fNRowLow;i++)
    {
      Float_t x = firstrow + fInnerPadPitchLength*(Float_t)i;  
      fPadRowLow[i]=x;
      fYInner[i+1]  = x*TMath::Tan(fInnerAngle/2.)-fInnerWireMount;
      fNPadsLow[i] = GetNPads(0,i) ;     // ROC implement     
    }
  // cross talk rows
  fYInner[0]=(fPadRowLow[0]-fInnerPadPitchLength)*TMath::Tan(fInnerAngle/2.)-fInnerWireMount;
  fYInner[fNRowLow+1]=(fPadRowLow[fNRowLow-1]+fInnerPadPitchLength)*TMath::Tan(fInnerAngle/2.)-fInnerWireMount; 
  firstrow = fOuterRadiusLow + 1.6;
  for(i=0;i<fNRowUp;i++)
    {
      if(i<fNRowUp1){
	Float_t x = firstrow + fOuter1PadPitchLength*(Float_t)i; 
	fPadRowUp[i]=x;
	fYOuter[i+1]= x*TMath::Tan(fOuterAngle/2.)-fOuterWireMount;
	fNPadsUp[i] =  GetNPads(36,i) ;     // ROC implement      
	if(i==fNRowUp1-1) {
	  fLastWireUp1=fPadRowUp[i] +0.625;
	  firstrow = fPadRowUp[i] + 0.5*(fOuter1PadPitchLength+fOuter2PadPitchLength);
	}
      }
      else
	{
	  Float_t x = firstrow + fOuter2PadPitchLength*(Float_t)(i-64);
	  fPadRowUp[i]=x;
	  fNPadsUp[i] =  GetNPads(36,i) ;     // ROC implement
	}
      fYOuter[i+1]  = fPadRowUp[i]*TMath::Tan(fOuterAngle/2.)-fOuterWireMount;
    }
  

} 


//_____________________________________________________________________________
AliTPCROC::AliTPCROC()
          :TObject(), 
           fNSectorsAll(0),
	   fInnerRadiusLow(0.),
	   fInnerRadiusUp(0.),
	   fOuterRadiusUp(0.),
	   fOuterRadiusLow(0.),
	   fInnerFrameSpace(0.),
	   fOuterFrameSpace(0.),
	   fInnerWireMount(0.),
	   fOuterWireMount(0.),
	   fZLength(0.),
	   fInnerAngle(0.),
	   fOuterAngle(0.),
	   fNInnerWiresPerPad(0),
	   fInnerWWPitch(0.),
	   fInnerDummyWire(0),
	   fInnerOffWire(0.),
	   fRInnerFirstWire(0.),
	   fRInnerLastWire(0.),
	   fLastWireUp1(0.),
	   fNOuter1WiresPerPad(0),
	   fNOuter2WiresPerPad(0),
	   fOuterWWPitch(0.),
	   fOuterDummyWire(0),
	   fOuterOffWire(0),
	   fROuterFirstWire(0.),
	   fROuterLastWire(0),
	   fInnerPadPitchLength(0.),
	   fInnerPadPitchWidth(0.),
	   fInnerPadLength(0.),
	   fInnerPadWidth(0.),
	   fOuter1PadPitchLength(0.),
	   fOuter2PadPitchLength(0),
	   fOuterPadPitchWidth(0),
	   fOuter1PadLength(0.),
	   fOuter2PadLength(0),
	   fOuterPadWidth(0),
	   fNRowLow(0),
	   fNRowUp1(0),
	   fNRowUp2(0),
	   fNRowUp(0),
	   fNtRows(0)
{
  //
  // Default constructor
  for (UInt_t i=0;i<2;i++){
    fNSectors[i]  = 0;
    fNRows[i]     = 0;
    fNChannels[i] = 0;
    fNPads[i]     = 0;
    fRowPosIndex[i]= 0;
  }
}


//_____________________________________________________________________________
AliTPCROC::AliTPCROC(const AliTPCROC &roc)
          :TObject(roc),
           fNSectorsAll(0),
	   fInnerRadiusLow(0.),
	   fInnerRadiusUp(0.),
	   fOuterRadiusUp(0.),
	   fOuterRadiusLow(0.),
	   fInnerFrameSpace(0.),
	   fOuterFrameSpace(0.),
	   fInnerWireMount(0.),
	   fOuterWireMount(0.),
	   fZLength(0.),
	   fInnerAngle(0.),
	   fOuterAngle(0.),
	   fNInnerWiresPerPad(0),
	   fInnerWWPitch(0.),
	   fInnerDummyWire(0),
	   fInnerOffWire(0.),
	   fRInnerFirstWire(0.),
	   fRInnerLastWire(0.),
	   fLastWireUp1(0.),
	   fNOuter1WiresPerPad(0),
	   fNOuter2WiresPerPad(0),
	   fOuterWWPitch(0.),
	   fOuterDummyWire(0),
	   fOuterOffWire(0),
	   fROuterFirstWire(0.),
	   fROuterLastWire(0),
	   fInnerPadPitchLength(0.),
	   fInnerPadPitchWidth(0.),
	   fInnerPadLength(0.),
	   fInnerPadWidth(0.),
	   fOuter1PadPitchLength(0.),
	   fOuter2PadPitchLength(0),
	   fOuterPadPitchWidth(0),
	   fOuter1PadLength(0.),
	   fOuter2PadLength(0),
	   fOuterPadWidth(0),
	   fNRowLow(0),
	   fNRowUp1(0),
	   fNRowUp2(0),
	   fNRowUp(0),
	   fNtRows(0)

{
  //
  // AliTPCROC copy constructor
  //
  fNSectorsAll = roc.fNSectorsAll;
  fNSectors[0] = roc.fNSectors[0];
  fNSectors[1] = roc.fNSectors[1];
  fNRows[0]    = roc.fNRows[0];
  fNRows[1]    = roc.fNRows[1];
  fNChannels[0]= roc.fNChannels[0];
  fNChannels[1]= roc.fNChannels[1];
  //
  // number of pads in padrow
  fNPads[0] = new UInt_t[fNRows[0]];
  fNPads[1] = new UInt_t[fNRows[1]];  
  //
  // padrow index in array
  //
  fRowPosIndex[0] = new UInt_t[fNRows[0]];
  fRowPosIndex[1] = new UInt_t[fNRows[1]];
  //
  for (UInt_t irow =0; irow<fNRows[0];irow++){
    fNPads[0][irow]       = roc.fNPads[0][irow];
    fRowPosIndex[0][irow] = roc.fRowPosIndex[0][irow];
  }
  for (UInt_t irow =0; irow<fNRows[1];irow++){
    fNPads[1][irow]       = roc.fNPads[1][irow];
    fRowPosIndex[1][irow] = roc.fRowPosIndex[1][irow];
  }
}
//____________________________________________________________________________
AliTPCROC & AliTPCROC::operator =(const AliTPCROC & roc)
{
  //
  // assignment operator - dummy
  //
  fZLength = roc.fZLength;
  return (*this);
}
//_____________________________________________________________________________
AliTPCROC::~AliTPCROC()
{
  //
  // AliTPCROC destructor
  //
  delete [] fNPads[0];
  delete [] fNPads[1];
  delete [] fRowPosIndex[0];
  delete [] fRowPosIndex[1];
  fgInstance = 0x0;
  
}


void AliTPCROC::GetPositionLocal(UInt_t sector, UInt_t row, UInt_t pad, Float_t *pos){
  //
  // get position of center of pad - ideal frame used
  //
  pos[2]=fZLength;
  if (sector<36){
   pos[0] = fPadRowLow[row];
   pos[1] = fInnerPadPitchWidth*(Int_t(pad)-Int_t(fNPads[0][row])/2);
  }else{
    pos[0] = fPadRowUp[row];
    pos[1] = fOuterPadPitchWidth*(Int_t(pad)-Int_t(fNPads[1][row])/2);    
  }
  if ((sector%36)>=18){
    pos[2] *= -1.;
    pos[1] *= -1.;
  }
}


void AliTPCROC::GetPositionGlobal(UInt_t sector, UInt_t row, UInt_t pad, Float_t *pos){
  //
  // get position of center of pad - ideal frame used 
  //
  GetPositionLocal(sector,row,pad,pos);
  Double_t alpha = TMath::DegToRad()*(10.+20.*(sector%18));
  Float_t gx = pos[0]*TMath::Cos(alpha)-pos[1]*TMath::Sin(alpha);
  Float_t gy = pos[1]*TMath::Cos(alpha)+pos[0]*TMath::Sin(alpha);
  pos[0] = gx;
  pos[1] = gy;
}
Commit	Line	Data
	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
	17	///////////////////////////////////////////////////////////////////////////////
	18	// //
	19	// Geometry class for a single ROC //
	20	// //
	21	// //
	22	///////////////////////////////////////////////////////////////////////////////
	23	#include "AliTPCROC.h"
	24	#include "TMath.h"
	25
	26	ClassImp(AliTPCROC)
	27
	28
	29	AliTPCROC* AliTPCROC::fgInstance = 0;
	30
	31
	32
	33
	34	//_ singleton implementation __________________________________________________
	35	AliTPCROC* AliTPCROC::Instance()
	36	{
	37	//
	38	// Singleton implementation
	39	// Returns an instance of this class, it is created if neccessary
	40	//
	41	if (fgInstance == 0){
	42	fgInstance = new AliTPCROC();
	43	fgInstance->Init();
	44	}
	45	return fgInstance;
	46	}
	47
	48
	49
	50
	51	void AliTPCROC::Init(){
	52	//
	53	// initialize static variables
	54	//
	55	if (AliTPCROC::fNSectorsAll>0) return;
	56	fNSectorsAll =72;
	57	fNSectors[0] =36;
	58	fNSectors[1] =36;
	59	//
	60	fNRows[0]= 63;
	61	fNRows[1]= 96;
	62	//
	63	// number of pads in padrow
	64	fNPads[0] = new UInt_t[fNRows[0]];
	65	fNPads[1] = new UInt_t[fNRows[1]];
	66	//
	67	// padrow index in array
	68	//
	69	fRowPosIndex[0] = new UInt_t[fNRows[0]];
	70	fRowPosIndex[1] = new UInt_t[fNRows[1]];
	71	//
	72	// inner sectors
	73	//
	74	UInt_t index =0;
	75	for (UInt_t irow=0; irow<fNRows[0];irow++){
	76	UInt_t npads = (irow==0) ? 68 : 2 *Int_t(Double_t(irow)/3. +33.67);
	77	fNPads[0][irow] = npads;
	78	fRowPosIndex[0][irow] = index;
	79	index+=npads;
	80	}
	81	fNChannels[0] = index;
	82	//
	83	index =0;
	84	Double_t k1 = 10.TMath::Tan(10TMath::DegToRad())/6.;
	85	Double_t k2 = 15.TMath::Tan(10TMath::DegToRad())/6.;
	86	for (UInt_t irow=0; irow<fNRows[1];irow++){
	87	UInt_t npads = (irow<64) ?
	88	2Int_t(k1Double_t(irow)+37.75):
	89	2Int_t(k2Double_t(irow-64)+56.66);
	90	fNPads[1][irow] = npads;
	91	fRowPosIndex[1][irow] = index;
	92	index+=npads;
	93	}
	94	fNChannels[1] = index;
	95	SetGeometry();
	96	}
	97
	98
	99
	100
	101	void AliTPCROC::SetGeometry()
	102	{
	103	//
	104	//set ROC geometry parameters
	105	//
	106	const Float_t kInnerRadiusLow = 83.65;
	107	const Float_t kInnerRadiusUp = 133.3;
	108	const Float_t kOuterRadiusLow = 133.5;
	109	const Float_t kOuterRadiusUp = 247.7;
	110	const Float_t kInnerFrameSpace = 1.5;
	111	const Float_t kOuterFrameSpace = 1.5;
	112	const Float_t kInnerWireMount = 1.2;
	113	const Float_t kOuterWireMount = 1.4;
	114	const Float_t kZLength =250.;
	115	const UInt_t kNRowLow = 63;
	116	const UInt_t kNRowUp1 = 64;
	117	const UInt_t kNRowUp2 = 32;
	118	const UInt_t kNRowUp = 96;
	119	const Float_t kInnerAngle = 20; // 20 degrees
	120	const Float_t kOuterAngle = 20; // 20 degrees
	121	//
	122	// pad parameters
	123	//
	124	const Float_t kInnerPadPitchLength = 0.75;
	125	const Float_t kInnerPadPitchWidth = 0.40;
	126	const Float_t kInnerPadLength = 0.75;
	127	const Float_t kInnerPadWidth = 0.40;
	128	const Float_t kOuter1PadPitchLength = 1.0;
	129	const Float_t kOuterPadPitchWidth = 0.6;
	130	const Float_t kOuter1PadLength = 1.0;
	131	const Float_t kOuterPadWidth = 0.6;
	132	const Float_t kOuter2PadPitchLength = 1.5;
	133	const Float_t kOuter2PadLength = 1.5;
	134
	135	//
	136	//wires default parameters
	137	//
	138	// const UInt_t kNInnerWiresPerPad = 3;
	139	// const UInt_t kInnerDummyWire = 2;
	140	// const Float_t kInnerWWPitch = 0.25;
	141	// const Float_t kRInnerFirstWire = 84.475;
	142	// const Float_t kRInnerLastWire = 132.475;
	143	// const Float_t kInnerOffWire = 0.5;
	144	// const UInt_t kNOuter1WiresPerPad = 4;
	145	// const UInt_t kNOuter2WiresPerPad = 6;
	146	// const Float_t kOuterWWPitch = 0.25;
	147	// const Float_t kROuterFirstWire = 134.225;
	148	// const Float_t kROuterLastWire = 246.975;
	149	// const UInt_t kOuterDummyWire = 2;
	150	// const Float_t kOuterOffWire = 0.5;
	151	//
	152	//set sector parameters
	153	//
	154	fInnerRadiusLow = kInnerRadiusLow;
	155	fOuterRadiusLow = kOuterRadiusLow;
	156	fInnerRadiusUp = kInnerRadiusUp;
	157	fOuterRadiusUp = kOuterRadiusUp;
	158	fInnerFrameSpace = kInnerFrameSpace;
	159	fOuterFrameSpace = kOuterFrameSpace;
	160	fInnerWireMount = kInnerWireMount;
	161	fOuterWireMount = kOuterWireMount;
	162	fZLength = kZLength;
	163	fInnerAngle = TMath::DegToRad()*kInnerAngle;
	164	fOuterAngle = TMath::DegToRad()*kOuterAngle;
	165
	166	fNRowLow = kNRowLow;
	167	fNRowUp1 = kNRowUp1;
	168	fNRowUp2 = kNRowUp2;
	169	fNRowUp = kNRowUp;
	170	//
	171	//set pad parameter
	172	//
	173	fInnerPadPitchLength = kInnerPadPitchLength;
	174	fInnerPadPitchWidth = kInnerPadPitchWidth;
	175	fInnerPadLength = kInnerPadLength;
	176	fInnerPadWidth = kInnerPadWidth;
	177	fOuter1PadPitchLength = kOuter1PadPitchLength;
	178	fOuter2PadPitchLength = kOuter2PadPitchLength;
	179	fOuterPadPitchWidth = kOuterPadPitchWidth;
	180	fOuter1PadLength = kOuter1PadLength;
	181	fOuter2PadLength = kOuter2PadLength;
	182	fOuterPadWidth = kOuterPadWidth;
	183
	184	//
	185	//set wire parameters
	186	//
	187	// SetInnerNWires(kNInnerWiresPerPad);
	188	// SetInnerDummyWire(kInnerDummyWire);
	189	// SetInnerOffWire(kInnerOffWire);
	190	// SetOuter1NWires(kNOuter1WiresPerPad);
	191	// SetOuter2NWire(kNOuter2WiresPerPad);
	192	// SetOuterDummyWire(kOuterDummyWire);
	193	// SetOuterOffWire(kOuterOffWire);
	194	// SetInnerWWPitch(kInnerWWPitch);
	195	// SetRInnerFirstWire(kRInnerFirstWire);
	196	// SetRInnerLastWire(kRInnerLastWire);
	197	// SetOuterWWPitch(kOuterWWPitch);
	198	// SetROuterFirstWire(kROuterFirstWire);
	199	// SetROuterLastWire(kROuterLastWire);
	200
	201	UInt_t i=0;
	202	Float_t firstrow = fInnerRadiusLow + 1.575;
	203	for( i= 0;i<fNRowLow;i++)
	204	{
	205	Float_t x = firstrow + fInnerPadPitchLength*(Float_t)i;
	206	fPadRowLow[i]=x;
	207	fYInner[i+1] = x*TMath::Tan(fInnerAngle/2.)-fInnerWireMount;
	208	fNPadsLow[i] = GetNPads(0,i) ; // ROC implement
	209	}
	210	// cross talk rows
	211	fYInner[0]=(fPadRowLow[0]-fInnerPadPitchLength)*TMath::Tan(fInnerAngle/2.)-fInnerWireMount;
	212	fYInner[fNRowLow+1]=(fPadRowLow[fNRowLow-1]+fInnerPadPitchLength)*TMath::Tan(fInnerAngle/2.)-fInnerWireMount;
	213	firstrow = fOuterRadiusLow + 1.6;
	214	for(i=0;i<fNRowUp;i++)
	215	{
	216	if(i<fNRowUp1){
	217	Float_t x = firstrow + fOuter1PadPitchLength*(Float_t)i;
	218	fPadRowUp[i]=x;
	219	fYOuter[i+1]= x*TMath::Tan(fOuterAngle/2.)-fOuterWireMount;
	220	fNPadsUp[i] = GetNPads(36,i) ; // ROC implement
	221	if(i==fNRowUp1-1) {
	222	fLastWireUp1=fPadRowUp[i] +0.625;
	223	firstrow = fPadRowUp[i] + 0.5*(fOuter1PadPitchLength+fOuter2PadPitchLength);
	224	}
	225	}
	226	else
	227	{
	228	Float_t x = firstrow + fOuter2PadPitchLength*(Float_t)(i-64);
	229	fPadRowUp[i]=x;
	230	fNPadsUp[i] = GetNPads(36,i) ; // ROC implement
	231	}
	232	fYOuter[i+1] = fPadRowUp[i]*TMath::Tan(fOuterAngle/2.)-fOuterWireMount;
	233	}
	234
	235
	236
	237	}
	238
	239
	240
	241
	242	//_____________________________________________________________________________
	243	AliTPCROC::AliTPCROC()
	244	:TObject(),
	245	fNSectorsAll(0),
	246	fInnerRadiusLow(0.),
	247	fInnerRadiusUp(0.),
	248	fOuterRadiusUp(0.),
	249	fOuterRadiusLow(0.),
	250	fInnerFrameSpace(0.),
	251	fOuterFrameSpace(0.),
	252	fInnerWireMount(0.),
	253	fOuterWireMount(0.),
	254	fZLength(0.),
	255	fInnerAngle(0.),
	256	fOuterAngle(0.),
	257	fNInnerWiresPerPad(0),
	258	fInnerWWPitch(0.),
	259	fInnerDummyWire(0),
	260	fInnerOffWire(0.),
	261	fRInnerFirstWire(0.),
	262	fRInnerLastWire(0.),
	263	fLastWireUp1(0.),
	264	fNOuter1WiresPerPad(0),
	265	fNOuter2WiresPerPad(0),
	266	fOuterWWPitch(0.),
	267	fOuterDummyWire(0),
	268	fOuterOffWire(0),
	269	fROuterFirstWire(0.),
	270	fROuterLastWire(0),
	271	fInnerPadPitchLength(0.),
	272	fInnerPadPitchWidth(0.),
	273	fInnerPadLength(0.),
	274	fInnerPadWidth(0.),
	275	fOuter1PadPitchLength(0.),
	276	fOuter2PadPitchLength(0),
	277	fOuterPadPitchWidth(0),
	278	fOuter1PadLength(0.),
	279	fOuter2PadLength(0),
	280	fOuterPadWidth(0),
	281	fNRowLow(0),
	282	fNRowUp1(0),
	283	fNRowUp2(0),
	284	fNRowUp(0),
	285	fNtRows(0)
	286	{
	287	//
	288	// Default constructor
	289	for (UInt_t i=0;i<2;i++){
	290	fNSectors[i] = 0;
	291	fNRows[i] = 0;
	292	fNChannels[i] = 0;
	293	fNPads[i] = 0;
	294	fRowPosIndex[i]= 0;
	295	}
	296	}
	297
	298
	299	//_____________________________________________________________________________
	300	AliTPCROC::AliTPCROC(const AliTPCROC &roc)
	301	:TObject(roc),
	302	fNSectorsAll(0),
	303	fInnerRadiusLow(0.),
	304	fInnerRadiusUp(0.),
	305	fOuterRadiusUp(0.),
	306	fOuterRadiusLow(0.),
	307	fInnerFrameSpace(0.),
	308	fOuterFrameSpace(0.),
	309	fInnerWireMount(0.),
	310	fOuterWireMount(0.),
	311	fZLength(0.),
	312	fInnerAngle(0.),
	313	fOuterAngle(0.),
	314	fNInnerWiresPerPad(0),
	315	fInnerWWPitch(0.),
	316	fInnerDummyWire(0),
	317	fInnerOffWire(0.),
	318	fRInnerFirstWire(0.),
	319	fRInnerLastWire(0.),
	320	fLastWireUp1(0.),
	321	fNOuter1WiresPerPad(0),
	322	fNOuter2WiresPerPad(0),
	323	fOuterWWPitch(0.),
	324	fOuterDummyWire(0),
	325	fOuterOffWire(0),
	326	fROuterFirstWire(0.),
	327	fROuterLastWire(0),
	328	fInnerPadPitchLength(0.),
	329	fInnerPadPitchWidth(0.),
	330	fInnerPadLength(0.),
	331	fInnerPadWidth(0.),
	332	fOuter1PadPitchLength(0.),
	333	fOuter2PadPitchLength(0),
	334	fOuterPadPitchWidth(0),
	335	fOuter1PadLength(0.),
	336	fOuter2PadLength(0),
	337	fOuterPadWidth(0),
	338	fNRowLow(0),
	339	fNRowUp1(0),
	340	fNRowUp2(0),
	341	fNRowUp(0),
	342	fNtRows(0)
	343
	344	{
	345	//
	346	// AliTPCROC copy constructor
	347	//
	348	fNSectorsAll = roc.fNSectorsAll;
	349	fNSectors[0] = roc.fNSectors[0];
	350	fNSectors[1] = roc.fNSectors[1];
	351	fNRows[0] = roc.fNRows[0];
	352	fNRows[1] = roc.fNRows[1];
	353	fNChannels[0]= roc.fNChannels[0];
	354	fNChannels[1]= roc.fNChannels[1];
	355	//
	356	// number of pads in padrow
	357	fNPads[0] = new UInt_t[fNRows[0]];
	358	fNPads[1] = new UInt_t[fNRows[1]];
	359	//
	360	// padrow index in array
	361	//
	362	fRowPosIndex[0] = new UInt_t[fNRows[0]];
	363	fRowPosIndex[1] = new UInt_t[fNRows[1]];
	364	//
	365	for (UInt_t irow =0; irow<fNRows[0];irow++){
	366	fNPads[0][irow] = roc.fNPads[0][irow];
	367	fRowPosIndex[0][irow] = roc.fRowPosIndex[0][irow];
	368	}
	369	for (UInt_t irow =0; irow<fNRows[1];irow++){
	370	fNPads[1][irow] = roc.fNPads[1][irow];
	371	fRowPosIndex[1][irow] = roc.fRowPosIndex[1][irow];
	372	}
	373	}
	374	//____________________________________________________________________________
	375	AliTPCROC & AliTPCROC::operator =(const AliTPCROC & roc)
	376	{
	377	//
	378	// assignment operator - dummy
	379	//
	380	fZLength = roc.fZLength;
	381	return (*this);
	382	}
	383	//_____________________________________________________________________________
	384	AliTPCROC::~AliTPCROC()
	385	{
	386	//
	387	// AliTPCROC destructor
	388	//
	389	delete [] fNPads[0];
	390	delete [] fNPads[1];
	391	delete [] fRowPosIndex[0];
	392	delete [] fRowPosIndex[1];
	393	fgInstance = 0x0;
	394
	395	}
	396
	397
	398
	399
	400	void AliTPCROC::GetPositionLocal(UInt_t sector, UInt_t row, UInt_t pad, Float_t *pos){
	401	//
	402	// get position of center of pad - ideal frame used
	403	//
	404	pos[2]=fZLength;
	405	if (sector<36){
	406	pos[0] = fPadRowLow[row];
	407	pos[1] = fInnerPadPitchWidth*(Int_t(pad)-Int_t(fNPads[0][row])/2);
	408	}else{
	409	pos[0] = fPadRowUp[row];
	410	pos[1] = fOuterPadPitchWidth*(Int_t(pad)-Int_t(fNPads[1][row])/2);
	411	}
	412	if ((sector%36)>=18){
	413	pos[2] *= -1.;
	414	pos[1] *= -1.;
	415	}
	416	}
	417
	418
	419	void AliTPCROC::GetPositionGlobal(UInt_t sector, UInt_t row, UInt_t pad, Float_t *pos){
	420	//
	421	// get position of center of pad - ideal frame used
	422	//
	423	GetPositionLocal(sector,row,pad,pos);
	424	Double_t alpha = TMath::DegToRad()(10.+20.(sector%18));
	425	Float_t gx = pos[0]TMath::Cos(alpha)-pos[1]TMath::Sin(alpha);
	426	Float_t gy = pos[1]TMath::Cos(alpha)+pos[0]TMath::Sin(alpha);
	427	pos[0] = gx;
	428	pos[1] = gy;
	429	}