AliRoot Core  3dc7879 (3dc7879)
AliTPCParam.cxx
Go to the documentation of this file.
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 
26 
27 //
28 
29 #include <AliTPCParam.h>
30 
31 #include <TGeoManager.h>
32 #include <TGeoPhysicalNode.h>
33 #include <TString.h>
34 #include "AliAlignObj.h"
35 #include "AliAlignObjParams.h"
36 #include "AliLog.h"
37 #include "TGraphErrors.h"
38 #include "AliTPCcalibDB.h"
39 #include "AliTPCROC.h"
40 #include "AliExternalTrackParam.h"
41 
43 
45 ClassImp(AliTPCParam)
47 
48 
49 //___________________________________________
52  fbStatus(kFALSE),
53  fInnerRadiusLow(0.),
54  fInnerRadiusUp(0.),
55  fOuterRadiusUp(0.),
56  fOuterRadiusLow(0.),
57  fInnerAngle(0.),
58  fInnerAngleShift(0.),
59  fOuterAngle(0.),
60  fOuterAngleShift(0.),
61  fInnerFrameSpace(0.),
62  fOuterFrameSpace(0.),
63  fInnerWireMount(0.),
64  fOuterWireMount(0.),
65  fNInnerSector(0),
66  fNOuterSector(0),
67  fNSector(0),
68  fZLength(0),
69  fRotAngle(),
70  fGeometryType(0),
71  fTrackingMatrix(0),
72  fClusterMatrix(0),
73  fGlobalMatrix(0),
74  fNInnerWiresPerPad(0),
75  fInnerWWPitch(0),
76  fInnerDummyWire(0),
77  fInnerOffWire(0.),
78  fRInnerFirstWire(0.),
79  fRInnerLastWire(0.),
80  fLastWireUp1(0.),
81  fNOuter1WiresPerPad(0),
82  fNOuter2WiresPerPad(0),
83  fOuterWWPitch(0.),
84  fOuterDummyWire(0),
85  fOuterOffWire(0.),
86  fROuterFirstWire(0.),
87  fROuterLastWire(0.),
88  fInnerPadPitchLength(0.),
89  fInnerPadPitchWidth(0.),
90  fInnerPadLength(0.),
91  fInnerPadWidth(0.),
92  fOuter1PadPitchLength(0.),
93  fOuter2PadPitchLength(0.),
94  fOuterPadPitchWidth(0.),
95  fOuter1PadLength(0.),
96  fOuter2PadLength(0.),
97  fOuterPadWidth(0.),
98  fBMWPCReadout(kFALSE),
99  fNCrossRows(0),
100  fNRowLow(0),
101  fNRowUp1(0),
102  fNRowUp2(0),
103  fNRowUp(0),
104  fNtRows(0),
105  fDiffT(0.),
106  fDiffL(0.),
107  fGasGain(0.),
108  fDriftV(0.),
109  fOmegaTau(0.),
110  fAttCoef(0.),
111  fOxyCont(0.),
112  fFpot(0.),
113  fNprim(0.),
114  fNtot(0.),
115  fWmean(0.),
116  fExp(0.),
117  fEend(0.),
118  fBetheBloch(0x0), // dE/dx:BG - used in the reconstruction
119  fBetheBlochMC(0x0), // dN_{prim}/dx:BG - used for the simulation of energy loss
120  fGainSlopesHV(0), // graph with the gain slope as function of HV - per chamber
121  fGainSlopesPT(0), // graph with the gain slope as function of P/T - per chamber
122  fPadCoupling(0.),
123  fZeroSup(0),
124  fNoise(0.),
125  fChipGain(0.),
126  fChipNorm(0.),
127  fTSample(0.),
128  fZWidth(0.),
129  fTSigma(0.),
130  fMaxTBin(0),
131  fADCSat(0),
132  fADCDynRange(0.),
133  fTotalNormFac(0.),
134  fNoiseNormFac(0.),
135  fUseGlitchFilter(kTRUE),
136  fSigmaRangePIDinTracking(15.),
137  fNominalVoltage(),
138  fMaxVoltageDeviation(40.),
139  fMaxDipVoltage(2.),
140  fMaxHVfractionBad(.4),
141  fVoltageDipScanPeriod(1.),
142  fNResponseMax(0),
143  fResponseThreshold(0.),
144  fCurrentMax(0),
145  fResponseBin(0),
146  fResponseWeight(0),
147  fGateDelay(0.),
148  fL1Delay(0.),
149  fNTBinsBeforeL1(0),
150  fNTBinsL1(0.)
151 {
152  //
153  //constructor sets the default parameters
154  //
155 
156  SetTitle("75x40_100x60_150x60");
157  SetDefault();
158  if (!fBBParam) fBBParam= new TObjArray(1000);
159  fRegionGain[0]=fRegionGain[1]=fRegionGain[2]=0.;
160 }
161 
163 {
165 
166  if (fResponseBin!=0) delete [] fResponseBin;
167  if (fResponseWeight!=0) delete [] fResponseWeight;
168  if (fRotAngle !=0) delete [] fRotAngle;
169 
171 
172 }
173 
174 Int_t AliTPCParam::Transform0to1(Float_t *xyz, Int_t * index) const
175 {
178 
179  Float_t angle,x1;
180  Int_t sector;
181  Float_t r = TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]);
182  if ((xyz[0]==0)&&(xyz[1]==0)) angle = 0.;
183  else
184  {
185  angle =TMath::ASin(xyz[1]/r);
186  if (xyz[0]<0) angle=TMath::Pi()-angle;
187  if ( (xyz[0]>0) && (xyz[1]<0) ) angle=2*TMath::Pi()+angle;
188  }
189 
190  sector=Int_t(TMath::Nint((angle-fInnerAngleShift)/fInnerAngle));
191 
192  Float_t cos,sin;
193  AdjustCosSin(sector,cos,sin);
194  x1=xyz[0]*cos + xyz[1]*sin;
195 
196  if (x1>fOuterRadiusLow)
197  {
198  sector=Int_t(TMath::Nint((angle-fOuterAngleShift)/fOuterAngle))+fNInnerSector;
199  if (xyz[2]<0) sector+=(fNOuterSector>>1);
200  }
201  else
202  if (xyz[2]<0) sector+=(fNInnerSector>>1);
203  if (sector<0 || sector>=fNSector) AliError(Form("Wrong sector %d",sector));
204  index[1]=sector; // calculated sector number
205  index[0]=1; // indicates system after transformation
206  return sector;
207 }
208 
209 Bool_t AliTPCParam::Transform(Float_t */*xyz*/, Int_t *index, Int_t* /*oindex*/)
210 {
212 
213  switch (index[0]){
214  case 0:
215  break;
216  };
217 
218  return kFALSE;
219 
220 }
221 
222 Int_t AliTPCParam::GetPadRow(Float_t *xyz, Int_t *index) const
223 {
225 
226  Int_t system = index[0];
227  if (0==system) {
228  Transform0to1(xyz,index);
229  system=1;
230  }
231  if (1==system) {
232  Transform1to2(xyz,index);
233  system=2;
234  }
235 
236  if (fGeometryType==0){ //straight row
237  if (2==system) {
238  Transform2to3(xyz,index);
239  system=3;
240  }
241  if (3==system) {
242  Transform3to4(xyz,index);
243  system=4;
244  }
245  if (4==system) {
246  Transform4to8(xyz,index);
247  system=8;
248  }
249  if (8==system) {
250  index[0]=8;
251  return index[2];
252  }
253  }
254 
255  if (fGeometryType==1){ //cylindrical geometry
256  if (2==system) {
257  Transform2to5(xyz,index);
258  system=5;
259  }
260  if (5==system) {
261  Transform2to3(xyz,index);
262  system=6;
263  }
264  if (6==system) {
265  Transform3to4(xyz,index);
266  system=7;
267  }
268  if (8==system) {
269  index[0]=8;
270  return index[2];
271  }
272  }
273  index[0]=system;
274  return -1; //if no reasonable system
275 }
276 
277 void AliTPCParam::SetSectorAngles(Float_t innerangle, Float_t innershift, Float_t outerangle,
278  Float_t outershift)
279 {
281 
282  static const Float_t kDegtoRad = 0.01745329251994;
283  fInnerAngle = innerangle; //opening angle of Inner sector
284  fInnerAngleShift = innershift; //shift of first inner sector center to the 0
285  fOuterAngle = outerangle; //opening angle of outer sector
286  fOuterAngleShift = outershift; //shift of first sector center to the 0
287  fInnerAngle *=kDegtoRad;
288  fInnerAngleShift *=kDegtoRad;
289  fOuterAngle *=kDegtoRad;
290  fOuterAngleShift *=kDegtoRad;
291 }
292 
294 {
296 
297  return fInnerAngle;
298 
299 }
300 
302 {
304 
305  return fInnerAngleShift;
306 }
308 {
310 
311  return fOuterAngle;
312 }
314 {
316 
317  return fOuterAngleShift;
318 }
319 
320 
321 Int_t AliTPCParam::GetIndex(Int_t sector, Int_t row) const
322 {
325 
326  if (sector<fNInnerSector) return sector*fNRowLow+row;
327  return (fNInnerSector*fNRowLow)+(sector-fNInnerSector)*fNRowUp+row;
328 }
329 
330 Bool_t AliTPCParam::AdjustSectorRow(Int_t index, Int_t & sector, Int_t &row) const
331 {
334 
335  if ( (index<0) || (index>fNtRows)) return kFALSE;
336  Int_t outindex = fNInnerSector*fNRowLow;
337  if (index<outindex) {
338  sector = index/fNRowLow;
339  row = index - sector*fNRowLow;
340  return kTRUE;
341  }
342  index-= outindex;
343  sector = index/fNRowUp;
344  row = index - sector*fNRowUp;
345  sector += fNInnerSector;
346  return kTRUE;
347 }
348 
350 {
356 
357  static const Float_t kInnerRadiusLow = 83.65;
358  static const Float_t kInnerRadiusUp = 133.3;
359  static const Float_t kOuterRadiusLow = 133.5;
360  static const Float_t kOuterRadiusUp = 247.7;
361  static const Float_t kInnerAngle = 20; // 20 degrees
362  static const Float_t kInnerAngleShift = 10;
363  static const Float_t kOuterAngle = 20; // 20 degrees
364  static const Float_t kOuterAngleShift = 10;
365  static const Float_t kInnerFrameSpace = 1.5;
366  static const Float_t kOuterFrameSpace = 1.5;
367  static const Float_t kInnerWireMount = 1.2;
368  static const Float_t kOuterWireMount = 1.4;
369  static const Float_t kZLength =250.;
370  static const Int_t kGeometryType = 0; //straight rows
371  static const Int_t kNRowLow = 63;
372  static const Int_t kNRowUp1 = 64;
373  static const Int_t kNRowUp2 = 32;
374  static const Int_t kNRowUp = 96;
375  //
376  //wires default parameters
377  //
378  static const Int_t kNInnerWiresPerPad = 3;
379  static const Int_t kInnerDummyWire = 2;
380  static const Float_t kInnerWWPitch = 0.25;
381  static const Float_t kRInnerFirstWire = 84.475;
382  static const Float_t kRInnerLastWire = 132.475;
383  static const Float_t kInnerOffWire = 0.5;
384  static const Int_t kNOuter1WiresPerPad = 4;
385  static const Int_t kNOuter2WiresPerPad = 6;
386  static const Float_t kOuterWWPitch = 0.25;
387  static const Float_t kROuterFirstWire = 134.225;
388  static const Float_t kROuterLastWire = 246.975;
389  static const Int_t kOuterDummyWire = 2;
390  static const Float_t kOuterOffWire = 0.5;
391  //
392  //pad default parameters
393  //
394  static const Float_t kInnerPadPitchLength = 0.75;
395  static const Float_t kInnerPadPitchWidth = 0.40;
396  static const Float_t kInnerPadLength = 0.75;
397  static const Float_t kInnerPadWidth = 0.40;
398  static const Float_t kOuter1PadPitchLength = 1.0;
399  static const Float_t kOuterPadPitchWidth = 0.6;
400  static const Float_t kOuter1PadLength = 1.0;
401  static const Float_t kOuterPadWidth = 0.6;
402  static const Float_t kOuter2PadPitchLength = 1.5;
403  static const Float_t kOuter2PadLength = 1.5;
404 
405  static const Bool_t kBMWPCReadout = kTRUE; //MWPC readout - another possibility GEM
406  static const Int_t kNCrossRows = 1; //number of rows to cross-talk
407 
408  //
409  //gas default parameters
410  //
411  static const Float_t kDiffT = 2.2e-2;
412  static const Float_t kDiffL = 2.2e-2;
413  static const Float_t kGasGain = 2.e4;
414  static const Float_t kDriftV =2.83e6;
415  static const Float_t kOmegaTau = 0.145;
416  static const Float_t kAttCoef = 250.;
417  static const Float_t kOxyCont = 5.e-6;
418  static const Float_t kFpot = 22.77e-9;
419  static const Float_t kNprim=14.35;
420  static const Float_t kNtot=42.66;
421  static const Float_t kWmean = 35.97e-9;
422  static const Float_t kExp = 2.2;
423  static const Float_t kEend = 10.e-6;
424  //
425  //electronic default parameters
426  //
427  static const Float_t kPadCoupling=0.5;
428  static const Int_t kZeroSup=2;
429  static const Float_t kNoise = 1000;
430  static const Float_t kChipGain = 12;
431  static const Float_t kChipNorm = 0.4;
432  static const Float_t kTSample = 2.e-7;
433  static const Float_t kTFWHM = 1.9e-7; //fwhm of charge distribution
434  static const Int_t kMaxTBin =445;
435  static const Int_t kADCSat =1024;
436  static const Float_t kADCDynRange =2000.;
437  //
438  //response constants
439  //
440  static const Int_t kNResponseMax=100;
441  static const Float_t kResponseThreshold=0.01;
442  //L1 constants
443  // static const Float_t kGateDelay=6.1e-6; //In s
444  static const Float_t kGateDelay=0.; //For the moment no gating
445  // static const Float_t kL1Delay=6.5e-6; //In s
446  static const Float_t kL1Delay=0.; //For the moment no delay
447  // static const UShort_t kNTBinsBeforeL1=14;
448  static const UShort_t kNTBinsBeforeL1=0; //For the moment no shift
449  fbStatus = kFALSE;
450  //
451  //set sector parameters
452  //
453  SetInnerRadiusLow(kInnerRadiusLow);
454  SetOuterRadiusLow(kOuterRadiusLow);
455  SetInnerRadiusUp(kInnerRadiusUp);
456  SetOuterRadiusUp(kOuterRadiusUp);
457  SetInnerFrameSpace(kInnerFrameSpace);
458  SetOuterFrameSpace(kOuterFrameSpace);
459  SetInnerWireMount(kInnerWireMount);
460  SetOuterWireMount(kOuterWireMount);
461  SetSectorAngles(kInnerAngle,kInnerAngleShift,kOuterAngle,kOuterAngleShift);
462  SetZLength(kZLength);
463  SetGeometryType(kGeometryType);
464  SetRowNLow(kNRowLow);
465  SetRowNUp1 (kNRowUp1);
466  SetRowNUp2(kNRowUp2);
467  SetRowNUp(kNRowUp);
468  //
469  //set wire parameters
470  //
471  SetInnerNWires(kNInnerWiresPerPad);
472  SetInnerDummyWire(kInnerDummyWire);
473  SetInnerOffWire(kInnerOffWire);
474  SetOuter1NWires(kNOuter1WiresPerPad);
475  SetOuter2NWire(kNOuter2WiresPerPad);
476  SetOuterDummyWire(kOuterDummyWire);
477  SetOuterOffWire(kOuterOffWire);
478  SetInnerWWPitch(kInnerWWPitch);
479  SetRInnerFirstWire(kRInnerFirstWire);
480  SetRInnerLastWire(kRInnerLastWire);
481  SetOuterWWPitch(kOuterWWPitch);
482  SetROuterFirstWire(kROuterFirstWire);
483  SetROuterLastWire(kROuterLastWire);
484  //
485  //set pad parameter
486  //
487  SetInnerPadPitchLength(kInnerPadPitchLength);
488  SetInnerPadPitchWidth(kInnerPadPitchWidth);
489  SetInnerPadLength(kInnerPadLength);
490  SetInnerPadWidth(kInnerPadWidth);
491  SetOuter1PadPitchLength(kOuter1PadPitchLength);
492  SetOuter2PadPitchLength(kOuter2PadPitchLength);
493  SetOuterPadPitchWidth(kOuterPadPitchWidth);
494  SetOuter1PadLength(kOuter1PadLength);
495  SetOuter2PadLength(kOuter2PadLength);
496  SetOuterPadWidth(kOuterPadWidth);
497  SetMWPCReadout(kBMWPCReadout);
498  SetNCrossRows(kNCrossRows);
499  //
500  //set gas paremeters
501  //
502  SetDiffT(kDiffT);
503  SetDiffL(kDiffL);
504  SetGasGain(kGasGain);
505  SetDriftV(kDriftV);
506  SetOmegaTau(kOmegaTau);
507  SetAttCoef(kAttCoef);
508  SetOxyCont(kOxyCont);
509  SetFpot(kFpot);
510  SetNprim(kNprim);
511  SetNtot(kNtot);
512  SetWmean(kWmean);
513  SetExp(kExp);
514  SetEend(kEend);
515  //
516  SetComposition(0.9,0.,0.1,0.,0.,0.);// Ne-CO2 90/10
517  //
520  //
521  //set electronivc parameters
522  //
523  SetPadCoupling(kPadCoupling);
524  SetZeroSup(kZeroSup);
525  SetNoise(kNoise);
526  SetChipGain(kChipGain);
527  SetChipNorm(kChipNorm);
528  SetTSample(kTSample);
529  SetTFWHM(kTFWHM);
530  SetMaxTBin(kMaxTBin);
531  SetADCSat(kADCSat);
532  SetADCDynRange(kADCDynRange);
533  for (UInt_t i=0; i<36; i++)
534  {
535  SetNominalVoltage(1196.0, i);
536  }
537  for (UInt_t i=36; i<72; i++)
538  {
539  SetNominalVoltage(1417.0, i);
540  }
541 // //set magnetic field
542 // SetBField(kBField);
543 // SetNPrimLoss(kNPrimLoss);
544 // SetNTotalLoss(kNTotalLoss);
545  //
546  //set response parameters
547  //
548  SetNResponseMax(kNResponseMax);
549  SetResponseThreshold(static_cast<int>(kResponseThreshold));
550  //L1 data
551  SetGateDelay(kGateDelay);
552  SetL1Delay(kL1Delay);
553  SetNTBinsBeforeL1(kNTBinsBeforeL1);
555 }
556 
557 
559 {
564 
565  const Float_t kQel = 1.602e-19; // elementary charge
566  fbStatus = kFALSE;
567 
568  Int_t i,j; //loop variables because HP
569  //-----------------Sector section------------------------------------------
570  //calclulate number of sectors
571  fNInnerSector = Int_t(4*TMath::Pi()/fInnerAngle+0.2);
572  // number of inner sectors - factor 0.2 to don't be influnced by inprecision
573  if (fNInnerSector%2) return kFALSE;
574  fNOuterSector = Int_t(4*TMath::Pi()/fOuterAngle+0.2);
575  if (fNOuterSector%2) return kFALSE;
577 
578  if (fRotAngle!=0) delete [] fRotAngle;
579  fRotAngle = new Float_t[4*fNSector];
580  //calculate sin and cosine of rotations angle
581  //sectors angles numbering from 0
582 
583  j=fNInnerSector*2;
584  Float_t angle = fInnerAngleShift;
585  for (i=0; j<fNInnerSector*4; i+=4, j+=4 , angle +=fInnerAngle){
586  fRotAngle[i]=TMath::Cos(angle);
587  fRotAngle[i+1]=TMath::Sin(angle);
588  fRotAngle[j] = fRotAngle[i];
589  fRotAngle[j+1] = fRotAngle[i+1];
590  fRotAngle[i+2] =angle;
591  fRotAngle[j+2] =angle;
592  fRotAngle[i+3] =angle;
593  fRotAngle[j+3] =angle;
594  }
595  angle = fOuterAngleShift;
596  j=(fNInnerSector+fNOuterSector/2)*4;
597  for (i=fNInnerSector*4; j<fNSector*4; i+=4,j+=4, angle +=fOuterAngle){
598  fRotAngle[i]=TMath::Cos(angle);
599  fRotAngle[i+1]=TMath::Sin(angle);
600  fRotAngle[j] = fRotAngle[i];
601  fRotAngle[j+1] = fRotAngle[i+1];
602  fRotAngle[i+2] =angle;
603  fRotAngle[j+2] =angle;
604  fRotAngle[i+3] =angle;
605  fRotAngle[j+3] =angle;
606  }
607 
611  //wire section
612  /* Int_t nwire;
613  Float_t wspace; //available space for wire
614  Float_t dummyspace; //dummyspace for wire
615 
616  wspace =fInnerRadiusUp-fInnerRadiusLow-2*fInnerOffWire;
617  nwire = Int_t(wspace/fInnerWWPitch);
618  wspace = Float_t(nwire)*fInnerWWPitch;
619  dummyspace =(fInnerRadiusUp-fInnerRadiusLow-wspace)/2.;
620  wspace =fOuterRadiusUp-fOuterRadiusLow-2*fOuterOffWire;
621  nwire = Int_t(wspace/fOuterWWPitch);
622  wspace = Float_t(nwire)*fOuterWWPitch;
623  dummyspace =(fOuterRadiusUp-fOuterRadiusLow-wspace)/2.;
624  fROuterFirstWire = fOuterRadiusLow+dummyspace;
625  fROuterLastWire = fROuterFirstWire+fOuterWWPitch*(Float_t)(nwire);
626  */
627 
628  //
629  //response data
630  //
631  if (fResponseBin) delete [] fResponseBin;
632  if (fResponseWeight) delete [] fResponseWeight;
633  fResponseBin = new Int_t[3*fNResponseMax];
634  fResponseWeight = new Float_t[fNResponseMax];
635 
636  //L1 data
638  fbStatus = kTRUE;
639  return kTRUE;
640 }
641 
644 
645  if (fTrackingMatrix) {
646  for(Int_t i = 0; i < fNSector; i++)
647  delete fTrackingMatrix[i];
648  delete [] fTrackingMatrix;
649  }
650 
651  if (fClusterMatrix) {
652  for(Int_t i = 0; i < fNSector; i++)
653  delete fClusterMatrix[i];
654  delete [] fClusterMatrix;
655  }
656 
657  if (fGlobalMatrix) {
658  for(Int_t i = 0; i < fNSector; i++)
659  delete fGlobalMatrix[i];
660  delete [] fGlobalMatrix;
661  }
662 
663  return;
664 }
665 
668 
669  if (!gGeoManager){
670  AliFatal("Geo manager not initialized\n");
671  }
673  //
674 
675  // clean geo matrices
677 
678  // create new geo matrices
679  fTrackingMatrix = new TGeoHMatrix*[fNSector];
680  fClusterMatrix = new TGeoHMatrix*[fNSector];
681  fGlobalMatrix = new TGeoHMatrix*[fNSector];
682  for (Int_t isec=0; isec<fNSector; isec++) {
683  fGlobalMatrix[isec] = 0;
684  fClusterMatrix[isec]= 0;
685  fTrackingMatrix[isec]=0;
686  }
687  //
688  for (Int_t isec=0; isec<fNSector; isec++) {
689  fGlobalMatrix[isec] = 0;
690  fClusterMatrix[isec]= 0;
691  fTrackingMatrix[isec]=0;
693  Int_t iModule;
694 
695  if(isec<fNInnerSector) {
696  iLayer = AliGeomManager::kTPC1;
697  iModule = isec;
698  }
699  else {
700  iLayer = AliGeomManager::kTPC2;
701  iModule = isec - fNInnerSector;
702  }
703 
704  UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iModule);
705  TGeoPNEntry* pne = gGeoManager->GetAlignableEntryByUID(volid);
706  if(!pne)
707  {
708  AliError(Form("Alignable entry for volume ID %d not in geometry. Exiting!",volid));
709  return kFALSE;
710  }
711  const char *path = pne->GetTitle();
712  if (!gGeoManager->cd(path)) return kFALSE;
713  TGeoHMatrix *m = gGeoManager->GetCurrentMatrix();
714  // Since GEANT4 does not allow reflections, in this case the reflection
715  // component if the matrix is embedded by TGeo inside TGeoScaledShape
716  if (gGeoManager->GetCurrentVolume()->GetShape()->IsReflected())
717  m->ReflectZ(kFALSE, kTRUE);
718  //
719  TGeoRotation mchange;
720  mchange.RotateY(90); mchange.RotateX(90);
721  Float_t ROCcenter[3];
722  GetChamberCenter(isec,ROCcenter);
723  //
724  // Convert to global coordinate system
725  //
726  fGlobalMatrix[isec] = new TGeoHMatrix(*m);
727  const TGeoHMatrix& mchangei = mchange.Inverse();
728  fGlobalMatrix[isec]->Multiply(&mchangei);
729  TGeoTranslation center("center",-ROCcenter[0],-ROCcenter[1],-ROCcenter[2]);
730  fGlobalMatrix[isec]->Multiply(&center);
731  //
732  // cluster correction matrix
733  //
734  fClusterMatrix[isec] = new TGeoHMatrix;
735  Double_t sectorAngle = 20.*(isec%18)+10;
736  TGeoHMatrix rotMatrix;
737  rotMatrix.RotateZ(sectorAngle);
738  if (GetGlobalMatrix(isec)->GetTranslation()[2]>0){
739  //
740  // mirrored system
741  //
742  TGeoRotation mirrorZ;
743  mirrorZ.SetAngles(90,0,90,90,180,0);
744  fClusterMatrix[isec]->Multiply(&mirrorZ);
745  }
746  TGeoTranslation trans(0,0,GetZLength(isec));
747  fClusterMatrix[isec]->MultiplyLeft(&trans);
748  fClusterMatrix[isec]->MultiplyLeft((GetGlobalMatrix(isec)));
749  const TGeoHMatrix& rotmatrixi = rotMatrix.Inverse();
750  fClusterMatrix[isec]->MultiplyLeft(&rotmatrixi);
751  }
752  return kTRUE;
753 }
754 
755 TGeoHMatrix * AliTPCParam::Tracking2LocalMatrix(const TGeoHMatrix * geoMatrix, Int_t sector) const{
757 
758  Double_t sectorAngle = 20.*(sector%18)+10;
759  TGeoHMatrix *newMatrix = new TGeoHMatrix();
760  newMatrix->RotateZ(sectorAngle);
761  const TGeoHMatrix& geomatrixi = geoMatrix->Inverse();
762  newMatrix->MultiplyLeft(&geomatrixi);
763  return newMatrix;
764 }
765 
766 
767 
768 
770 {
772 
773  return fbStatus;
774 }
775 
777 {
779 
780  return fNRowLow;
781 }
783 {
785 
786  return fNRowUp;
787 }
789 {
791 
792  return fNRowUp1;
793 }
795 {
797 
798  return fNRowUp2;
799 }
800 Float_t AliTPCParam::GetPadRowRadiiLow(Int_t irow) const
801 {
803 
804  if ( !(irow<0) && (irow<fNRowLow) )
805  return fPadRowLow[irow];
806  else
807  return 0;
808 }
809 
810 Float_t AliTPCParam::GetPadRowRadiiUp(Int_t irow) const
811 {
813 
814  if ( !(irow<0) && (irow<fNRowUp) )
815  return fPadRowUp[irow];
816  else
817  return 0;
818 }
819 
820 Int_t AliTPCParam::GetNPadsLow(Int_t irow) const
821 {
823 
824  if ( !(irow<0) && (irow<fNRowLow) )
825  return fNPadsLow[irow];
826  else
827  return 0;
828 }
829 
830 
831 Int_t AliTPCParam::GetNPadsUp(Int_t irow) const
832 {
834 
835  if ( !(irow<0) && (irow<fNRowUp) )
836  return fNPadsUp[irow];
837  else
838  return 0;
839 }
840 
841 Int_t AliTPCParam::GetWireSegment(Int_t sector, Int_t row) const
842 {
846 
847  Int_t wireIndex = -1;
848  // check if the given set of sector and row is OK
849  if ( (sector<0 || sector>=72) || (row<0 || row>95) || (sector<36 && row>64) ){
850  AliError("No matching anode wire segment for this set of sector-row \n");
851  return wireIndex;
852  }
853  // find the wire index for given sector-row
854  if ( sector<36 ){ // IROC anode wire segments
855  if (row<16) wireIndex=0;
856  else if (row>=16 && row<32) wireIndex=1;
857  else if (row>=32 && row<48) wireIndex=2;
858  else wireIndex=3;
859  } else { // OROC anode wire segments
860  if (row<16) wireIndex=4;
861  else if ( row>=16 && row<32) wireIndex=5;
862  else if ( row>=32 && row<48) wireIndex=6;
863  else if ( row>=48 && row<64) wireIndex=7;
864  else if ( row>=64 && row<75) wireIndex=8;
865  else if ( row>=75 && row<85) wireIndex=9;
866  else wireIndex=10;
867  }
868  return wireIndex;
869 }
870 
871 Int_t AliTPCParam::GetNPadsPerSegment(Int_t wireSegmentID) const
872 {
877 
878  if ( wireSegmentID<0 || wireSegmentID>10 ){
879  AliError("Wrong anode wire segment index. it should be [0,10] \n");
880  return -1;
881  }
882  // get sector type from wireSegmentID
883  Int_t sector = (wireSegmentID<4) ? 0 : 36; // ROC [0,35] --> IROC, ROC [36,71] --> OROC
884  // get the upper and lower row number for the given wireSegmentID
885  Int_t segRowDown = 0;
886  Int_t segRowUp = 0;
887 
888  if ( wireSegmentID == 0 || wireSegmentID == 4 ) {
889  segRowDown = 0;
890  segRowUp = 16;
891  } else if ( wireSegmentID == 1 || wireSegmentID == 5 ) {
892  segRowDown = 16;
893  segRowUp = 32;
894  } else if ( wireSegmentID == 2 || wireSegmentID == 6 ) {
895  segRowDown = 32;
896  segRowUp = 48;
897  } else if ( wireSegmentID == 3 || wireSegmentID == 7 ) {
898  segRowDown = 48;
899  segRowUp = 63;
900  } else if ( wireSegmentID == 8 ) {
901  segRowDown = 64;
902  segRowUp = 75;
903  } else if ( wireSegmentID == 9 ) {
904  segRowDown = 75;
905  segRowUp = 85;
906  } else {
907  segRowDown = 85;
908  segRowUp = 95;
909  }
910  // count the number of pads on the given segment
912  Int_t nPads=0;
913  for (Int_t irow = segRowDown; irow < segRowUp ; irow++){
914  nPads += r->GetNPads(sector,irow);
915  }
916  return nPads;
917 }
918 
919 Float_t AliTPCParam::GetYInner(Int_t irow) const
920 {
921  return fYInner[irow];
922 }
923 
924 
925 Float_t AliTPCParam::GetYOuter(Int_t irow) const
926 {
927  return fYOuter[irow];
928 }
929 
930 Int_t AliTPCParam::GetSectorIndex(Float_t angle, Int_t row, Float_t z) const
931 {
934 
935  if(row<0) return -1;
936 
937  if (angle > 2.*TMath::Pi()) angle -= 2.*TMath::Pi();
938  if (angle < 0. ) angle += 2.*TMath::Pi();
939 
940  Int_t sector;
941  if(row<fNRowLow) {
942  sector=Int_t(TMath::Nint((angle-fInnerAngleShift)/fInnerAngle));
943  if (z<0) sector += (fNInnerSector>>1);
944  }
945  else {
946  sector=Int_t(TMath::Nint((angle-fOuterAngleShift)/fOuterAngle))+fNInnerSector;
947  if (z<0) sector += (fNOuterSector>>1);
948  }
949 
950  return sector;
951 }
952 
953 Float_t AliTPCParam::GetChamberCenter(Int_t isec, Float_t * center) const
954 {
957 
958  const Float_t kROCcenterIn = 110.2;
959  const Float_t kROCcenterOut = 188.45;
960 
961  if (isec<fNInnerSector){
962  if (center){
963  center[0] = kROCcenterIn;
964  center[1] = 0;
965  center[2] = -5.51-0.08;
966  }
967  return kROCcenterIn;
968  }
969  else{
970  if (center){
971  center[0] = kROCcenterOut;
972  center[1] = 0;
973  center[2] = -5.61-0.08;
974  }
975  return kROCcenterOut;
976  }
977 }
978 
983 
984  Float_t sector[72]={0};
985  Float_t gainHV[72]={0};
986  Float_t gainPT[72]={0};
987  //
988  for (Int_t isec=0; isec<72; isec++){
989  sector[isec]=isec;
990  gainHV[isec]=0.0115; // change of the Gain dG/G per 1 Volt of voltage change(1/V) - it is roughly the same for IROC and OROC
991  gainPT[isec]=2.2; // change of the Gains dG/G per P/T change ()
992  }
993  fGainSlopesHV = new TGraphErrors(72,sector,gainHV,0,0);
994  fGainSlopesPT = new TGraphErrors(72,sector,gainPT,0,0);
995  fGainSlopesHV->SetName("GainSlopesHV");
996  fGainSlopesPT->SetName("GainSlopesPT");
997 }
998 
999 
1004 
1005  TVectorD v(5);
1006  v(0)=0.76176e-1;
1007  v(1)=10.632;
1008  v(2)=0.13279e-4;
1009  v(3)=1.8631;
1010  v(4)=1.9479;
1011  return new TVectorD(v);
1012 }
1013 
1019 
1020  TVectorD v(5);
1021  v[0] = 0.0851148;
1022  v[1] = 9.25771;
1023  v[2] = 2.6558e-05;
1024  v[3] = 2.32742;
1025  v[4] = 1.83039;
1026  return new TVectorD(v);
1027 }
1028 
1032 
1033  TVectorD v(5);
1034  v[0] =0.0820172 ;
1035  v[1] =9.94795 ;
1036  v[2] =8.97292e-05;
1037  v[3] =2.05873 ;
1038  v[4] =1.65272 ;
1039 
1040  return new TVectorD(v);
1041 }
1042 
1043 
1044 Double_t AliTPCParam::BetheBlochAleph(Double_t bg, Int_t type){
1047  if (bg<=0) return 0;
1048  TVectorD * paramBB =0;
1049  if (type==0) {
1051  if (param) paramBB=param->GetBetheBlochParameters();
1052  }
1053  if (type==1){
1054  paramBB = (TVectorD*)fBBParam->At(type);
1055  }
1056  if (!paramBB) return 0;
1057  //
1058  return AliExternalTrackParam::BetheBlochAleph(bg,(*paramBB)(0),(*paramBB)(1),(*paramBB)(2),(*paramBB)(3),(*paramBB)(4));
1059 }
1060 
1061 
1062 void AliTPCParam::RegisterBBParam(TVectorD* param, Int_t position){
1064 
1065  fBBParam->AddAt(param,position);
1066 }
Int_t * fResponseBin
! array with bins -calulated
Definition: AliTPCParam.h:542
static AliTPCcalibDB * Instance()
TGraphErrors * fGainSlopesHV
graph with the gain slope as function of HV - per chamber
Definition: AliTPCParam.h:505
Float_t fTSample
sampling time
Definition: AliTPCParam.h:516
static Double_t BetheBlochAleph(Double_t bb, Int_t type=0)
Float_t fPadCoupling
coupling factor ration of anode signal
Definition: AliTPCParam.h:510
Int_t Transform0to1(Float_t *xyz, Int_t *index) const
void SetOuterFrameSpace(Float_t frspace)
Definition: AliTPCParam.h:129
UInt_t GetNPads(UInt_t sector, UInt_t row) const
Definition: AliTPCROC.h:30
Float_t GetYInner(Int_t irow) const
void SetDiffT(Float_t DiffT)
Definition: AliTPCParam.h:176
void SetInnerRadiusLow(Float_t InnerRadiusLow)
Definition: AliTPCParam.h:122
void SetNominalVoltage(Float_t v, UInt_t i)
Definition: AliTPCParam.h:231
void SetNominalGainSlopes()
void SetNResponseMax(Int_t max)
Definition: AliTPCParam.h:239
Float_t fOuterAngleShift
shift of first sector center to the 0
Definition: AliTPCParam.h:414
void SetOuterWWPitch(Float_t wwPitch)
Definition: AliTPCParam.h:154
Int_t GetNPadsPerSegment(Int_t segmentID) const
void SetOuter1NWires(Int_t nWires)
Definition: AliTPCParam.h:147
Float_t fADCDynRange
input dynamic range (mV)
Definition: AliTPCParam.h:521
void SetPadCoupling(Float_t PadCoupling)
Definition: AliTPCParam.h:216
void SetAttCoef(Float_t AttCoef)
Definition: AliTPCParam.h:182
void SetDiffL(Float_t DiffL)
Definition: AliTPCParam.h:177
Float_t fPadRowLow[600]
Lower sector, pad row radii -calculated.
Definition: AliTPCParam.h:478
void SetInnerPadPitchWidth(Float_t PadPitchWidth)
Definition: AliTPCParam.h:162
#define TObjArray
void Transform2to5(Float_t *xyz, Int_t *index) const
Definition: AliTPCParam.h:730
Float_t fNTBinsL1
Overall L1 delay in time bins.
Definition: AliTPCParam.h:551
Manager class for detector parameters.
Bool_t fbStatus
indicates consistency of the data
Definition: AliTPCParam.h:403
void SetRInnerFirstWire(Float_t firstWire)
Definition: AliTPCParam.h:152
void SetBetheBloch(TVectorD *v)
Definition: AliTPCParam.h:199
Float_t * fRotAngle
sin and cos of rotation angles for different sectors - calculated
Definition: AliTPCParam.h:424
void SetRowNUp2(Int_t NRowUp2)
Definition: AliTPCParam.h:139
void SetGasGain(Float_t GasGain)
Definition: AliTPCParam.h:178
const char * path
Manager and of geomety classes for set: TPC.
Definition: AliTPCParam.h:18
void SetChipNorm(Float_t ChipNorm)
Definition: AliTPCParam.h:220
void SetRInnerLastWire(Float_t lastWire)
Definition: AliTPCParam.h:153
void SetGateDelay(Float_t delay)
Definition: AliTPCParam.h:242
static TVectorD * GetBetheBlochParamAlice()
virtual Bool_t Transform(Float_t *xyz, Int_t *index, Int_t *oindex)
virtual Int_t GetPadRow(Float_t *xyz, Int_t *index) const
void SetOuterWireMount(Float_t fmount)
Definition: AliTPCParam.h:131
void SetMWPCReadout(Bool_t type)
Definition: AliTPCParam.h:171
void SetNoise(Float_t Noise)
Definition: AliTPCParam.h:218
static TVectorD * GetBetheBlochParamNa49()
void SetTFWHM(Float_t fwhm)
Definition: AliTPCParam.h:222
Float_t fDriftV
drift velocity constant
Definition: AliTPCParam.h:491
virtual Bool_t ReadGeoMatrices()
AliTPCParam * GetParameters() const
Int_t fGeometryType
type of geometry -0 straight rows
Definition: AliTPCParam.h:425
Float_t GetPadRowRadiiLow(Int_t irow) const
void SetL1Delay(Float_t delay)
Definition: AliTPCParam.h:243
void SetZeroSup(Int_t ZeroSup)
Definition: AliTPCParam.h:217
void SetOxyCont(Float_t OxyCont)
Definition: AliTPCParam.h:183
void SetInnerPadPitchLength(Float_t PadPitchLength)
Definition: AliTPCParam.h:161
void SetInnerFrameSpace(Float_t frspace)
Definition: AliTPCParam.h:128
static TObjArray * fBBParam
array of the Bethe-Bloch parameters.
Definition: AliTPCParam.h:553
Float_t fOuterRadiusLow
lower radius of outer sector-IP
Definition: AliTPCParam.h:410
void SetOuterOffWire(Float_t offset)
Definition: AliTPCParam.h:150
void SetOuter1PadPitchLength(Float_t PadPitchLength)
Definition: AliTPCParam.h:165
static void RegisterBBParam(TVectorD *param, Int_t position)
TGraphErrors * fGainSlopesPT
graph with the gain slope as function of P/T - per chamber
Definition: AliTPCParam.h:506
void Transform4to8(Float_t *xyz, Int_t *index) const
Definition: AliTPCParam.h:759
void SetMaxTBin(Int_t maxtbin)
Definition: AliTPCParam.h:223
Int_t Transform2to3(Float_t *xyz, Int_t *index) const
Definition: AliTPCParam.h:682
Int_t fNInnerSector
number of inner sectors -calculated
Definition: AliTPCParam.h:419
bool trans(const AliFMDIndex &x, const AliFMDIndex &y, const AliFMDIndex &z)
Definition: TestIndex.C:94
void SetInnerPadWidth(Float_t PadWidth)
Definition: AliTPCParam.h:164
TGeoHMatrix * Tracking2LocalMatrix(const TGeoHMatrix *geoMatrix, Int_t sector) const
static TVectorD * GetBetheBlochParamAliceMC()
void SetChipGain(Float_t ChipGain)
Definition: AliTPCParam.h:219
Bool_t bg
Definition: RunAnaESD.C:6
void SetSectorAngles(Float_t innerangle, Float_t innershift, Float_t outerangle, Float_t outershift)
Float_t fPadRowUp[600]
Upper sector, pad row radii -calculated.
Definition: AliTPCParam.h:479
void SetNTBinsBeforeL1(UShort_t nbins)
Definition: AliTPCParam.h:244
Int_t GetNPadsLow(Int_t irow) const
void SetOuterRadiusLow(Float_t OuterRadiusLow)
Definition: AliTPCParam.h:123
Float_t fYInner[600]
Inner sector, wire-length.
Definition: AliTPCParam.h:482
void SetInnerDummyWire(Int_t dummy)
Definition: AliTPCParam.h:145
UShort_t fNTBinsBeforeL1
Number of time bins before L1 arrival which are being read out.
Definition: AliTPCParam.h:550
Int_t fNRowUp
number of pad rows per sector up -calculated
Definition: AliTPCParam.h:476
Float_t GetOuterAngle() const
Float_t GetYOuter(Int_t irow) const
Int_t GetSectorIndex(Float_t angle, Int_t row, Float_t z) const
Float_t fNoiseNormFac
normalisation factor to transform noise in electron to ADC channel
Definition: AliTPCParam.h:523
Float_t fOuterAngle
opening angle of outer sector
Definition: AliTPCParam.h:413
Float_t fChipGain
preamp shaper constant
Definition: AliTPCParam.h:514
TGeoHMatrix ** fClusterMatrix
transformation matrices of the cluster coordinate system
Definition: AliTPCParam.h:435
Int_t fNSector
total number of sectors -calculated
Definition: AliTPCParam.h:421
void SetOuter1PadLength(Float_t PadLength)
Definition: AliTPCParam.h:168
Int_t GetNRowUp2() const
Float_t GetInnerAngle() const
Int_t fNResponseMax
maximal dimension of response
Definition: AliTPCParam.h:539
Float_t * fResponseWeight
! array with response -calulated
Definition: AliTPCParam.h:543
Int_t fNPadsLow[600]
Lower sector, number of pads per row -calculated.
Definition: AliTPCParam.h:480
Geometry class for a single ROC.
Definition: AliTPCROC.h:14
Float_t fChipNorm
preamp shaper normalisation
Definition: AliTPCParam.h:515
void SetOuter2PadLength(Float_t PadLength)
Definition: AliTPCParam.h:169
Int_t GetNRowUp() const
Bool_t GetStatus() const
void SetNprim(Float_t prim)
Definition: AliTPCParam.h:194
Int_t fNPadsUp[600]
Upper sector, number of pads per row -calculated.
Definition: AliTPCParam.h:481
void SetInnerWWPitch(Float_t wwPitch)
Definition: AliTPCParam.h:151
void SetOuterDummyWire(Int_t dummy)
Definition: AliTPCParam.h:149
void SetInnerPadLength(Float_t PadLength)
Definition: AliTPCParam.h:163
TGeoManager * gGeoManager
virtual void SetDefault()
TGeoHMatrix ** fGlobalMatrix
fTrackingMatrix * fClusterMatrix
Definition: AliTPCParam.h:437
void SetOuterRadiusUp(Float_t OuterRadiusUp)
Definition: AliTPCParam.h:125
Float_t GetOuterAngleShift() const
Float_t fInnerAngle
opening angle of Inner sector
Definition: AliTPCParam.h:411
void SetInnerNWires(Int_t nWires)
Definition: AliTPCParam.h:144
void SetRowNLow(Int_t NRowLow)
Definition: AliTPCParam.h:137
void SetTSample(Float_t TSample)
Definition: AliTPCParam.h:221
Float_t fL1Delay
Delay of L1 arrival for the TPC readout.
Definition: AliTPCParam.h:549
Int_t fADCSat
saturation value of ADC (10 bits)
Definition: AliTPCParam.h:520
virtual Bool_t Update()
void SetDriftV(Float_t DriftV)
Definition: AliTPCParam.h:180
void SetRowNUp(Int_t NRowUp)
Definition: AliTPCParam.h:140
void SetResponseThreshold(Int_t threshold)
Definition: AliTPCParam.h:240
void CleanGeoMatrices()
Bool_t AdjustSectorRow(Int_t index, Int_t &sector, Int_t &row) const
Float_t fInnerAngleShift
shift of first inner sector center to the 0
Definition: AliTPCParam.h:412
Int_t GetIndex(Int_t sector, Int_t row) const
#define AliFatal(message)
Definition: AliLog.h:640
TVectorD * GetBetheBlochParameters()
Definition: AliTPCParam.h:355
Float_t fTotalNormFac
full normalisation factor - calculated
Definition: AliTPCParam.h:522
void SetExp(Float_t exp)
Definition: AliTPCParam.h:197
void SetROuterLastWire(Float_t lastWire)
Definition: AliTPCParam.h:157
void SetZLength(Float_t zlength)
Definition: AliTPCParam.h:132
Float_t fYOuter[600]
Outer sector, wire-length.
Definition: AliTPCParam.h:483
Int_t GetWireSegment(Int_t sector, Int_t row) const
TGeoHMatrix ** fTrackingMatrix
transformation matrices of the tracking coordinate system
Definition: AliTPCParam.h:433
Float_t GetPadRowRadiiUp(Int_t irow) const
TGeoHMatrix * GetGlobalMatrix(Int_t isec) const
Definition: AliTPCParam.h:331
Float_t fZWidth
derived value calculated using TSample and driftw -computed
Definition: AliTPCParam.h:517
void SetOmegaTau(Float_t OmegaTau)
Definition: AliTPCParam.h:181
void AdjustCosSin(Int_t isec, Float_t &cos, Float_t &sin) const
Definition: AliTPCParam.h:583
void SetGeometryType(Int_t type)
Definition: AliTPCParam.h:133
Float_t GetInnerAngleShift() const
Int_t GetNPadsUp(Int_t irow) const
void SetOuterPadPitchWidth(Float_t PadPitchWidth)
Definition: AliTPCParam.h:167
void SetNCrossRows(Int_t rows)
Definition: AliTPCParam.h:172
Int_t fNOuterSector
number of outer sectors -calculated
Definition: AliTPCParam.h:420
void SetRowNUp1(Int_t NRowUp1)
Definition: AliTPCParam.h:138
static UShort_t LayerToVolUID(ELayerID layerId, Int_t modId)
void SetBetheBlochMC(TVectorD *v)
Definition: AliTPCParam.h:204
void SetADCDynRange(Float_t adcdynrange)
Definition: AliTPCParam.h:225
Int_t fNRowLow
number of pad rows per low sector -set
Definition: AliTPCParam.h:473
static AliTPCROC * Instance()
Definition: AliTPCROC.cxx:34
virtual ~AliTPCParam()
void SetInnerWireMount(Float_t fmount)
Definition: AliTPCParam.h:130
#define AliError(message)
Definition: AliLog.h:591
void SetOuter2NWire(Int_t nWires)
Definition: AliTPCParam.h:148
void SetOuterPadWidth(Float_t PadWidth)
Definition: AliTPCParam.h:170
Float_t GetZLength(Int_t sector=0) const
Definition: AliTPCParam.h:841
void SetADCSat(Int_t adcsat)
Definition: AliTPCParam.h:224
void SetNtot(Float_t ntot)
Definition: AliTPCParam.h:195
Int_t fNRowUp1
number of short pad rows per sector up -set
Definition: AliTPCParam.h:474
void SetROuterFirstWire(Float_t firstWire)
Definition: AliTPCParam.h:156
void Transform3to4(Float_t *xyz, Int_t *index) const
Definition: AliTPCParam.h:699
void SetEend(Float_t end)
Definition: AliTPCParam.h:198
void SetWmean(Float_t wmean)
Definition: AliTPCParam.h:196
void Transform1to2(Float_t *xyz, Int_t *index) const
Definition: AliTPCParam.h:617
void SetComposition(Float_t c1, Float_t c2, Float_t c3, Float_t c4, Float_t c5, Float_t c6)
Definition: AliTPCParam.h:187
static Double_t BetheBlochAleph(Double_t bg, Double_t kp1=0.76176e-1, Double_t kp2=10.632, Double_t kp3=0.13279e-4, Double_t kp4=1.8631, Double_t kp5=1.9479)
void SetInnerOffWire(Float_t offset)
Definition: AliTPCParam.h:146
Int_t fNRowUp2
number of long pad rows per sector up -set
Definition: AliTPCParam.h:475
Int_t GetNRowLow() const
void SetFpot(Float_t fpot)
Definition: AliTPCParam.h:193
void SetOuter2PadPitchLength(Float_t PadPitchLength)
Definition: AliTPCParam.h:166
void SetInnerRadiusUp(Float_t InnerRadiusUp)
Definition: AliTPCParam.h:124
Int_t fNtRows
total number of rows in TPC -calculated
Definition: AliTPCParam.h:477
Int_t GetNRowUp1() const
Float_t GetChamberCenter(Int_t isec, Float_t *center=0) const