[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);  
} 


//_____________________________________________________________________________
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;
  
}
Commit	Line	Data
7a0ff78e	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
c5bbaa2c	64	fNPads[0] = new UInt_t[fNRows[0]];
c5bbaa2c	65	fNPads[1] = new UInt_t[fNRows[1]];
7a0ff78e	66	//
	67	// padrow index in array
	68	//
c5bbaa2c	69	fRowPosIndex[0] = new UInt_t[fNRows[0]];
c5bbaa2c	70	fRowPosIndex[1] = new UInt_t[fNRows[1]];
7a0ff78e	71	//
	72	// inner sectors
	73	//
c5bbaa2c	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);
7a0ff78e	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.;
c5bbaa2c	86	for (UInt_t irow=0; irow<fNRows[1];irow++){
c5bbaa2c	87	UInt_t npads = (irow<64) ?
7a0ff78e	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.;
c5bbaa2c	115	const UInt_t kNRowLow = 63;
	116	const UInt_t kNRowUp1 = 64;
	117	const UInt_t kNRowUp2 = 32;
	118	const UInt_t kNRowUp = 96;
7a0ff78e	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	//
c5bbaa2c	138	// const UInt_t kNInnerWiresPerPad = 3;
c5bbaa2c	139	// const UInt_t kInnerDummyWire = 2;
7a0ff78e	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;
c5bbaa2c	144	// const UInt_t kNOuter1WiresPerPad = 4;
c5bbaa2c	145	// const UInt_t kNOuter2WiresPerPad = 6;
7a0ff78e	146	// const Float_t kOuterWWPitch = 0.25;
	147	// const Float_t kROuterFirstWire = 134.225;
	148	// const Float_t kROuterLastWire = 246.975;
c5bbaa2c	149	// const UInt_t kOuterDummyWire = 2;
7a0ff78e	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
	202
	203
	204
	205	//_____________________________________________________________________________
179c6296	206	AliTPCROC::AliTPCROC()
	207	:TObject(),
	208	fNSectorsAll(0),
	209	fInnerRadiusLow(0.),
	210	fInnerRadiusUp(0.),
	211	fOuterRadiusUp(0.),
	212	fOuterRadiusLow(0.),
	213	fInnerFrameSpace(0.),
	214	fOuterFrameSpace(0.),
	215	fInnerWireMount(0.),
	216	fOuterWireMount(0.),
	217	fZLength(0.),
	218	fInnerAngle(0.),
	219	fOuterAngle(0.),
	220	fNInnerWiresPerPad(0),
	221	fInnerWWPitch(0.),
	222	fInnerDummyWire(0),
	223	fInnerOffWire(0.),
	224	fRInnerFirstWire(0.),
	225	fRInnerLastWire(0.),
	226	fLastWireUp1(0.),
	227	fNOuter1WiresPerPad(0),
	228	fNOuter2WiresPerPad(0),
	229	fOuterWWPitch(0.),
	230	fOuterDummyWire(0),
	231	fOuterOffWire(0),
	232	fROuterFirstWire(0.),
	233	fROuterLastWire(0),
	234	fInnerPadPitchLength(0.),
	235	fInnerPadPitchWidth(0.),
	236	fInnerPadLength(0.),
	237	fInnerPadWidth(0.),
	238	fOuter1PadPitchLength(0.),
	239	fOuter2PadPitchLength(0),
	240	fOuterPadPitchWidth(0),
	241	fOuter1PadLength(0.),
	242	fOuter2PadLength(0),
	243	fOuterPadWidth(0),
	244	fNRowLow(0),
	245	fNRowUp1(0),
	246	fNRowUp2(0),
	247	fNRowUp(0),
	248	fNtRows(0)
7a0ff78e	249	{
	250	//
	251	// Default constructor
c5bbaa2c	252	for (UInt_t i=0;i<2;i++){
7a0ff78e	253	fNSectors[i] = 0;
	254	fNRows[i] = 0;
	255	fNChannels[i] = 0;
	256	fNPads[i] = 0;
	257	fRowPosIndex[i]= 0;
	258	}
	259	}
	260
	261
	262	//_____________________________________________________________________________
179c6296	263	AliTPCROC::AliTPCROC(const AliTPCROC &roc)
	264	:TObject(roc),
	265	fNSectorsAll(0),
	266	fInnerRadiusLow(0.),
	267	fInnerRadiusUp(0.),
	268	fOuterRadiusUp(0.),
	269	fOuterRadiusLow(0.),
	270	fInnerFrameSpace(0.),
	271	fOuterFrameSpace(0.),
	272	fInnerWireMount(0.),
	273	fOuterWireMount(0.),
	274	fZLength(0.),
	275	fInnerAngle(0.),
	276	fOuterAngle(0.),
	277	fNInnerWiresPerPad(0),
	278	fInnerWWPitch(0.),
	279	fInnerDummyWire(0),
	280	fInnerOffWire(0.),
	281	fRInnerFirstWire(0.),
	282	fRInnerLastWire(0.),
	283	fLastWireUp1(0.),
	284	fNOuter1WiresPerPad(0),
	285	fNOuter2WiresPerPad(0),
	286	fOuterWWPitch(0.),
	287	fOuterDummyWire(0),
	288	fOuterOffWire(0),
	289	fROuterFirstWire(0.),
	290	fROuterLastWire(0),
	291	fInnerPadPitchLength(0.),
	292	fInnerPadPitchWidth(0.),
	293	fInnerPadLength(0.),
	294	fInnerPadWidth(0.),
	295	fOuter1PadPitchLength(0.),
	296	fOuter2PadPitchLength(0),
	297	fOuterPadPitchWidth(0),
	298	fOuter1PadLength(0.),
	299	fOuter2PadLength(0),
	300	fOuterPadWidth(0),
	301	fNRowLow(0),
	302	fNRowUp1(0),
	303	fNRowUp2(0),
	304	fNRowUp(0),
	305	fNtRows(0)
	306
7a0ff78e	307	{
	308	//
	309	// AliTPCROC copy constructor
	310	//
	311	fNSectorsAll = roc.fNSectorsAll;
	312	fNSectors[0] = roc.fNSectors[0];
	313	fNSectors[1] = roc.fNSectors[1];
	314	fNRows[0] = roc.fNRows[0];
	315	fNRows[1] = roc.fNRows[1];
	316	fNChannels[0]= roc.fNChannels[0];
	317	fNChannels[1]= roc.fNChannels[1];
	318	//
	319	// number of pads in padrow
c5bbaa2c	320	fNPads[0] = new UInt_t[fNRows[0]];
c5bbaa2c	321	fNPads[1] = new UInt_t[fNRows[1]];
7a0ff78e	322	//
	323	// padrow index in array
	324	//
c5bbaa2c	325	fRowPosIndex[0] = new UInt_t[fNRows[0]];
c5bbaa2c	326	fRowPosIndex[1] = new UInt_t[fNRows[1]];
7a0ff78e	327	//
c5bbaa2c	328	for (UInt_t irow =0; irow<fNRows[0];irow++){
7a0ff78e	329	fNPads[0][irow] = roc.fNPads[0][irow];
	330	fRowPosIndex[0][irow] = roc.fRowPosIndex[0][irow];
	331	}
c5bbaa2c	332	for (UInt_t irow =0; irow<fNRows[1];irow++){
7a0ff78e	333	fNPads[1][irow] = roc.fNPads[1][irow];
	334	fRowPosIndex[1][irow] = roc.fRowPosIndex[1][irow];
	335	}
	336	}
179c6296	337	//____________________________________________________________________________
	338	AliTPCROC & AliTPCROC::operator =(const AliTPCROC & roc)
	339	{
	340	//
	341	// assignment operator - dummy
	342	//
	343	fZLength = roc.fZLength;
	344	return (*this);
	345	}
7a0ff78e	346	//_____________________________________________________________________________
	347	AliTPCROC::~AliTPCROC()
	348	{
	349	//
	350	// AliTPCROC destructor
	351	//
	352	delete [] fNPads[0];
	353	delete [] fNPads[1];
	354	delete [] fRowPosIndex[0];
	355	delete [] fRowPosIndex[1];
a411fffe	356	fgInstance = 0x0;
7a0ff78e	357
	358	}
	359