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