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