Print removed
[u/mrichter/AliRoot.git] / TPC / AliTPCParam.cxx
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 //  Manager and of geomety  classes for set: TPC                     //
20 //                                                                   //
21 //  !sectors are numbered from  0                                     //
22 //  !pad rows are numbered from 0                                     //
23 //  
24 //  12.6.   changed z relative 
25 //  Origin:  Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk // 
26 //                                                                   //  
27 ///////////////////////////////////////////////////////////////////////
28
29 //
30
31 #include <Riostream.h>
32 #include <TMath.h>
33 #include <TObject.h>
34 #include <TRandom.h>
35 #include <AliTPCParam.h>
36
37
38
39
40 ClassImp(AliTPCParam)
41
42
43 //___________________________________________
44 AliTPCParam::AliTPCParam()
45 {   
46   //
47   //constructor sets the default parameters
48   //
49
50   fResponseBin = 0;
51   fResponseWeight = 0;
52   fRotAngle = 0;
53   SetTitle("75x40_100x60_150x60");
54   SetDefault();  
55 }
56
57 AliTPCParam::~AliTPCParam()
58 {
59   //
60   //destructor deletes some dynamicaly alocated variables
61   //
62
63   if (fResponseBin!=0)    delete [] fResponseBin;
64   if (fResponseWeight!=0) delete [] fResponseWeight;
65   if (fRotAngle      !=0) delete [] fRotAngle;
66
67 }
68
69
70
71
72 Int_t  AliTPCParam::Transform0to1(Float_t *xyz, Int_t * index)  const
73 {
74   //
75   // calculates sector number (index[1], undefined on input)
76   // xyz intact
77   //
78
79   Float_t angle,x1;
80   Int_t sector;
81   Float_t r = TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]);
82   if ((xyz[0]==0)&&(xyz[1]==0)) angle = 0.;
83   else
84     {
85       angle =TMath::ASin(xyz[1]/r);
86       if   (xyz[0]<0)   angle=TMath::Pi()-angle;
87       if ( (xyz[0]>0) && (xyz[1]<0) ) angle=2*TMath::Pi()+angle;
88     }
89
90   sector=Int_t(TMath::Nint((angle-fInnerAngleShift)/fInnerAngle));      
91  
92   Float_t cos,sin;
93   AdjustCosSin(sector,cos,sin);
94   x1=xyz[0]*cos + xyz[1]*sin;
95
96   if (x1>fOuterRadiusLow)
97     {
98       sector=Int_t(TMath::Nint((angle-fOuterAngleShift)/fOuterAngle))+fNInnerSector;      
99       if (xyz[2]<0)     sector+=(fNOuterSector>>1);            
100     }
101     else   
102       if (xyz[2]<0) sector+=(fNInnerSector>>1);    
103   index[1]=sector; // calculated sector number
104   index[0]=1; // indicates system after transformation
105   return sector;
106 }
107
108 Bool_t  AliTPCParam::Transform(Float_t */*xyz*/, Int_t *index, Int_t* /*oindex*/)
109 {
110   //transformation from input coodination system to output coordination system
111   switch (index[0]){
112   case 0:
113     break;
114   };
115
116   return kFALSE;
117
118 }
119
120 Int_t AliTPCParam::GetPadRow(Float_t *xyz, Int_t *index) const 
121 {
122   //
123   //calculates pad row of point xyz - transformation to system 8 (digit system)
124   //
125   Int_t system = index[0];
126   if (0==system) {
127     Transform0to1(xyz,index); 
128     system=1;
129   }
130   if (1==system) {
131     Transform1to2(xyz,index); 
132     system=2;
133   }
134     
135   if (fGeometryType==0){ //straight row    
136     if (2==system) {
137       Transform2to3(xyz,index);       
138       system=3;
139     } 
140     if (3==system) {
141       Transform3to4(xyz,index);
142       system=4; 
143     }
144     if (4==system) {
145       Transform4to8(xyz,index);
146       system=8;     
147     }
148     if (8==system) {
149       index[0]=8;
150       return index[2];
151     } 
152   }
153
154   if (fGeometryType==1){ //cylindrical geometry    
155     if (2==system) {
156       Transform2to5(xyz,index);       
157       system=5;
158     } 
159     if (5==system) {
160       Transform2to3(xyz,index);
161       system=6;
162     }
163     if (6==system) {
164       Transform3to4(xyz,index); 
165       system=7;
166     }
167     if (8==system) {
168       index[0]=8;
169       return index[2];
170     }
171   } 
172   index[0]=system;
173   return -1; //if no reasonable system     
174 }
175
176 void  AliTPCParam::SetSectorAngles(Float_t innerangle, Float_t innershift, Float_t outerangle,
177                         Float_t outershift)
178 {
179   //
180   // set opening angles  
181   static const  Float_t  kDegtoRad = 0.01745329251994;
182   fInnerAngle = innerangle;       //opening angle of Inner sector
183   fInnerAngleShift = innershift;  //shift of first inner sector center to the 0
184   fOuterAngle = outerangle;       //opening angle of outer sector
185   fOuterAngleShift = outershift;  //shift of first sector center to the 0  
186   fInnerAngle *=kDegtoRad;
187   fInnerAngleShift *=kDegtoRad;
188   fOuterAngle *=kDegtoRad;
189   fOuterAngleShift *=kDegtoRad;
190 }
191
192 Float_t  AliTPCParam::GetInnerAngle() const
193 {
194   //return angle 
195   return fInnerAngle;
196
197 }
198
199 Float_t  AliTPCParam::GetInnerAngleShift() const
200 {  
201   //return angle   
202   return fInnerAngleShift;  
203 }
204 Float_t  AliTPCParam::GetOuterAngle() const
205
206   //return angle 
207   return fOuterAngle;
208
209 Float_t  AliTPCParam::GetOuterAngleShift() const
210
211   //return angle 
212
213      return fOuterAngleShift;
214
215
216
217 Int_t AliTPCParam::GetIndex(Int_t sector, Int_t row) const
218 {
219   //
220   //give index of the given sector and pad row 
221   //no control if the sectors and rows  are reasonable !!!
222   //
223   if (sector<fNInnerSector) return sector*fNRowLow+row;
224   return (fNInnerSector*fNRowLow)+(sector-fNInnerSector)*fNRowUp+row;  
225 }
226
227 Bool_t   AliTPCParam::AdjustSectorRow(Int_t index, Int_t & sector, Int_t &row) const
228 {
229   //
230   //return sector and padrow for given index
231   //if index is reasonable returns true else return false
232   //
233   if ( (index<0) || (index>fNtRows))  return kFALSE;
234   Int_t outindex = fNInnerSector*fNRowLow;
235   if (index<outindex) {
236     sector = index/fNRowLow;
237     row    = index - sector*fNRowLow;
238     return kTRUE;
239   }
240   index-= outindex;
241   sector = index/fNRowUp;
242   row    = index - sector*fNRowUp;
243   sector += fNInnerSector;
244   return kTRUE;         
245
246
247 void AliTPCParam::SetDefault()
248 {
249   //
250   //set default parameters
251   //
252   //const static  Int_t kMaxRows=600; 
253   //
254   //sector default parameters
255   //
256   static const  Float_t kInnerRadiusLow = 82.97;
257   static const  Float_t kInnerRadiusUp  = 133.17;
258   static const  Float_t kOuterRadiusLow = 133.58;
259   static const  Float_t kOuterRadiusUp  = 247.78;
260   static const  Float_t kInnerAngle = 20; // 20 degrees
261   static const  Float_t kInnerAngleShift = 10;
262   static const  Float_t kOuterAngle = 20; //  20 degrees
263   static const  Float_t kOuterAngleShift = 10;
264   static const  Float_t kInnerFrameSpace = 1.5;
265   static const  Float_t kOuterFrameSpace = 1.5;
266   static const  Float_t kInnerWireMount = 1.370825926;
267   static const  Float_t kOuterWireMount = 1.370825926;
268   static const  Float_t kZLength =250.;
269   static const  Int_t   kGeometryType = 0; //straight rows 
270   static const Int_t kNRowLow = 63;
271   static const Int_t kNRowUp1 = 64;
272   static const Int_t kNRowUp2 = 32;
273   static const Int_t  kNRowUp = 96;
274   //
275   //wires default parameters
276   //
277   static const Int_t    kNInnerWiresPerPad = 3;
278   static const Int_t    kInnerDummyWire = 2;
279   static const Float_t  kInnerWWPitch = 0.25;
280   static const Float_t  kRInnerFirstWire = 84.445;
281   static const Float_t  kRInnerLastWire = 132.445;
282   static const Float_t  kInnerOffWire = 0.5;
283   static const Int_t    kNOuter1WiresPerPad = 4;
284   static const Int_t    kNOuter2WiresPerPad = 6;
285   static const Float_t  kOuterWWPitch = 0.25;  
286   static const Float_t  kROuterFirstWire = 134.305;
287   static const Float_t  kROuterLastWire = 247.055;
288   static const Int_t    kOuterDummyWire = 2;
289   static const Float_t  kOuterOffWire = 0.5;
290   //
291   //pad default parameters
292   // 
293   static const Float_t  kInnerPadPitchLength = 0.75;
294   static const Float_t  kInnerPadPitchWidth = 0.40;
295   static const Float_t  kInnerPadLength = 0.75;
296   static const Float_t  kInnerPadWidth = 0.40;
297   static const Float_t  kOuter1PadPitchLength = 1.0;
298   static const Float_t  kOuterPadPitchWidth = 0.6;
299   static const Float_t  kOuter1PadLength = 1.0;
300   static const Float_t  kOuterPadWidth = 0.6;
301   static const Float_t  kOuter2PadPitchLength = 1.5;
302   static const Float_t  kOuter2PadLength = 1.5;
303
304   static const Bool_t   kBMWPCReadout = kTRUE; //MWPC readout - another possibility GEM 
305   static const Int_t    kNCrossRows = 1; //number of rows to cross-talk
306   
307   //
308   //gas default parameters
309   //
310   static const  Float_t  kDiffT = 2.2e-2; 
311   static const  Float_t  kDiffL = 2.2e-2;
312   static const  Float_t  kGasGain = 2.e4;
313   static const  Float_t  kDriftV  =2.83e6;
314   static const  Float_t  kOmegaTau = 0.145;
315   static const  Float_t  kAttCoef = 250.;
316   static const  Float_t  kOxyCont = 5.e-6;
317   //
318   //electronic default parameters
319   //
320   static const  Float_t  kPadCoupling=0.5;
321   static const  Int_t    kZeroSup=2;
322   static const  Float_t  kNoise = 1000;                            
323   static const  Float_t  kChipGain = 12;
324   static const  Float_t  kChipNorm = 0.4;
325   static const  Float_t  kTSample = 2.e-7; 
326   static const  Float_t  kTFWHM   = 1.9e-7;  //fwhm of charge distribution
327   static const  Int_t    kMaxTBin =445;  
328   static const  Int_t    kADCSat  =1024;  
329   static const  Float_t  kADCDynRange =2000.;  
330   //
331   //
332   //
333   static const  Float_t kBField =0.2; 
334   static const  Float_t kNPrimLoss =10.9;
335   static const  Float_t kNTotalLoss =39.9;
336   // 
337   //response constants
338   //
339   static const Int_t     kNResponseMax=100;
340   static const Float_t   kResponseThreshold=0.01;     
341   fbStatus = kFALSE;
342   //
343   //set sector parameters
344   //
345   SetInnerRadiusLow(kInnerRadiusLow);
346   SetOuterRadiusLow(kOuterRadiusLow);
347   SetInnerRadiusUp(kInnerRadiusUp);
348   SetOuterRadiusUp(kOuterRadiusUp);
349   SetInnerFrameSpace(kInnerFrameSpace);
350   SetOuterFrameSpace(kOuterFrameSpace);
351   SetInnerWireMount(kInnerWireMount);
352   SetOuterWireMount(kOuterWireMount);
353   SetSectorAngles(kInnerAngle,kInnerAngleShift,kOuterAngle,kOuterAngleShift);
354   SetZLength(kZLength);
355   SetGeometryType(kGeometryType);
356   SetRowNLow(kNRowLow);
357   SetRowNUp1 (kNRowUp1);
358   SetRowNUp2(kNRowUp2);
359   SetRowNUp(kNRowUp);
360   //
361   //set wire parameters
362   //
363   SetInnerNWires(kNInnerWiresPerPad);
364   SetInnerDummyWire(kInnerDummyWire);
365   SetInnerOffWire(kInnerOffWire);
366   SetOuter1NWires(kNOuter1WiresPerPad);
367   SetOuter2NWire(kNOuter2WiresPerPad);
368   SetOuterDummyWire(kOuterDummyWire);
369   SetOuterOffWire(kOuterOffWire);
370   SetInnerWWPitch(kInnerWWPitch);
371   SetRInnerFirstWire(kRInnerFirstWire);
372   SetRInnerLastWire(kRInnerLastWire);
373   SetOuterWWPitch(kOuterWWPitch);
374   SetROuterFirstWire(kROuterFirstWire);
375   SetROuterLastWire(kROuterLastWire);  
376   //
377   //set pad parameter
378   //
379   SetInnerPadPitchLength(kInnerPadPitchLength);
380   SetInnerPadPitchWidth(kInnerPadPitchWidth);
381   SetInnerPadLength(kInnerPadLength);
382   SetInnerPadWidth(kInnerPadWidth);
383   SetOuter1PadPitchLength(kOuter1PadPitchLength); 
384   SetOuter2PadPitchLength(kOuter2PadPitchLength);
385   SetOuterPadPitchWidth(kOuterPadPitchWidth);
386   SetOuter1PadLength(kOuter1PadLength);
387   SetOuter2PadLength(kOuter2PadLength);
388   SetOuterPadWidth(kOuterPadWidth); 
389   SetMWPCReadout(kBMWPCReadout);
390   SetNCrossRows(kNCrossRows);
391   //
392   //set gas paremeters
393   //
394   SetDiffT(kDiffT);
395   SetDiffL(kDiffL);
396   SetGasGain(kGasGain);
397   SetDriftV(kDriftV);
398   SetOmegaTau(kOmegaTau);
399   SetAttCoef(kAttCoef);
400   SetOxyCont(kOxyCont);
401   //
402   //set electronivc parameters  
403   //
404   SetPadCoupling(kPadCoupling);
405   SetZeroSup(kZeroSup);
406   SetNoise(kNoise);
407   SetChipGain(kChipGain);
408   SetChipNorm(kChipNorm);   
409   SetTSample(kTSample);
410   SetTFWHM(kTFWHM);
411   SetMaxTBin(kMaxTBin);
412   SetADCSat(kADCSat);
413   SetADCDynRange(kADCDynRange);
414   //set magnetic field
415   SetBField(kBField);
416   SetNPrimLoss(kNPrimLoss);
417   SetNTotalLoss(kNTotalLoss);
418   //
419   //set response  parameters  
420   //
421   SetNResponseMax(kNResponseMax); 
422   SetResponseThreshold(static_cast<int>(kResponseThreshold));
423 }
424
425           
426 Bool_t AliTPCParam::Update()
427 {
428   //
429   // update some calculated parameter which must be updated after changing "base"
430   // parameters 
431   // for example we can change size of pads and according this recalculate number
432   // of pad rows, number of of pads in given row ....
433   //
434   const Float_t kQel = 1.602e-19; // elementary charge
435   fbStatus = kFALSE;
436
437   Int_t i,j;  //loop variables because HP 
438   //-----------------Sector section------------------------------------------
439   //calclulate number of sectors
440   fNInnerSector = Int_t(4*TMath::Pi()/fInnerAngle+0.2); 
441        // number of inner sectors - factor 0.2 to don't be influnced by inprecision
442   if (fNInnerSector%2) return kFALSE;
443   fNOuterSector = Int_t(4*TMath::Pi()/fOuterAngle+0.2); 
444   if (fNOuterSector%2) return kFALSE;
445   fNSector  = fNInnerSector+fNOuterSector;
446
447   if (fRotAngle!=0) delete [] fRotAngle;
448   fRotAngle = new Float_t[4*fNSector];
449   //calculate sin and cosine of rotations angle     
450   //sectors angles numbering from 0
451
452   j=fNInnerSector*2;
453   Float_t angle = fInnerAngleShift; 
454   for (i=0; j<fNInnerSector*4; i+=4, j+=4 , angle +=fInnerAngle){
455     fRotAngle[i]=TMath::Cos(angle);
456     fRotAngle[i+1]=TMath::Sin(angle);
457     fRotAngle[j] =  fRotAngle[i];
458     fRotAngle[j+1] =  fRotAngle[i+1];
459     fRotAngle[i+2] =angle;
460     fRotAngle[j+2] =angle;    
461   }
462   angle = fOuterAngleShift; 
463   j=(fNInnerSector+fNOuterSector/2)*4;
464   for (i=fNInnerSector*4; j<fNSector*4; i+=4,j+=4, angle +=fOuterAngle){
465     fRotAngle[i]=TMath::Cos(angle);
466     fRotAngle[i+1]=TMath::Sin(angle);
467     fRotAngle[j] =  fRotAngle[i];
468     fRotAngle[j+1] =  fRotAngle[i+1];
469     fRotAngle[i+2] =angle;
470     fRotAngle[j+2] =angle;    
471   }
472   fZWidth = fTSample*fDriftV;  
473   fTotalNormFac = fPadCoupling*fChipNorm*kQel*1.e15*fChipGain*fADCSat/fADCDynRange;
474   fNoiseNormFac = kQel*1.e15*fChipGain*fADCSat/fADCDynRange;
475   //wire section 
476   /*  Int_t nwire;
477   Float_t wspace; //available space for wire
478   Float_t dummyspace; //dummyspace for wire
479  
480   wspace =fInnerRadiusUp-fInnerRadiusLow-2*fInnerOffWire;
481   nwire = Int_t(wspace/fInnerWWPitch);
482   wspace = Float_t(nwire)*fInnerWWPitch;
483   dummyspace =(fInnerRadiusUp-fInnerRadiusLow-wspace)/2.;  
484   wspace =fOuterRadiusUp-fOuterRadiusLow-2*fOuterOffWire;
485   nwire = Int_t(wspace/fOuterWWPitch);
486   wspace = Float_t(nwire)*fOuterWWPitch;
487   dummyspace =(fOuterRadiusUp-fOuterRadiusLow-wspace)/2.; 
488   fROuterFirstWire = fOuterRadiusLow+dummyspace;
489   fROuterLastWire = fROuterFirstWire+fOuterWWPitch*(Float_t)(nwire);
490   */
491   
492   //
493   //response data
494   //
495   if (fResponseBin==0) delete [] fResponseBin;
496   if (fResponseWeight==0) delete [] fResponseBin;
497   fResponseBin    = new Int_t[3*fNResponseMax];
498   fResponseWeight = new Float_t[fNResponseMax];
499   
500   fbStatus = kTRUE;
501   return kTRUE;
502 }
503
504
505
506 Bool_t AliTPCParam::GetStatus()
507 {
508   //get information about object consistency
509   return fbStatus;
510 }
511
512 Int_t AliTPCParam::GetNRowLow() const
513 {
514   //get the number of pad rows in low sector
515   return fNRowLow;
516 }
517 Int_t AliTPCParam::GetNRowUp() const
518 {
519   //get the number of pad rows in up sector
520   return fNRowUp;
521 }
522 Int_t AliTPCParam::GetNRowUp1() const
523 {
524   //get the number of pad rows in up1 sector
525   return fNRowUp1;
526 }
527 Int_t AliTPCParam::GetNRowUp2() const
528 {
529   //get the number of pad rows in up2 sector
530   return fNRowUp2;
531 }
532 Float_t AliTPCParam::GetPadRowRadiiLow(Int_t irow) const
533 {
534   //get the pad row (irow) radii
535   if ( !(irow<0) && (irow<fNRowLow) ) 
536     return  fPadRowLow[irow];
537   else
538     return 0;
539 }
540
541 Float_t AliTPCParam::GetPadRowRadiiUp(Int_t irow) const
542 {
543   //get the pad row (irow) radii
544  if ( !(irow<0) && (irow<fNRowUp) ) 
545     return  fPadRowUp[irow];
546   else
547     return 0;
548 }
549
550 Int_t AliTPCParam::GetNPadsLow(Int_t irow) const
551 {
552   //get the number of pads in row irow
553   if ( !(irow<0) && (irow<fNRowLow) ) 
554     return  fNPadsLow[irow];
555   else
556     return 0;
557 }
558
559
560 Int_t AliTPCParam::GetNPadsUp(Int_t irow) const
561 {
562   //get the number of pads in row irow
563   if ( !(irow<0) && (irow<fNRowUp) ) 
564     return  fNPadsUp[irow];
565   else
566     return 0;
567 }
568 Float_t AliTPCParam::GetYInner(Int_t irow) const
569 {
570   return fYInner[irow];
571 }
572
573
574 Float_t AliTPCParam::GetYOuter(Int_t irow) const
575 {
576   return fYOuter[irow];
577 }
578
579
580
581
582
583
584
585