]>
Commit | Line | Data |
---|---|---|
2b680d9b | 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 | ||
803d1ab0 | 16 | /* $Id$ */ |
2b680d9b | 17 | |
18 | ////////////////////////////////////////////////////////////////////////////// | |
19 | // // | |
20 | // Inner Traking System version 11 // | |
21 | // This class contains the base procedures for the Inner Tracking System // | |
22 | // // | |
23 | // Authors: R. Barbera // | |
24 | // version 6. // | |
25 | // Created 2000. // | |
26 | // // | |
27 | // NOTE: THIS IS THE SYMMETRIC PPR geometry of the ITS. // | |
28 | // THIS WILL NOT WORK // | |
29 | // with the geometry or module classes or any analysis classes. You are // | |
30 | // strongly encouraged to uses AliITSv5. // | |
31 | // // | |
32 | ////////////////////////////////////////////////////////////////////////////// | |
33 | // See AliITSv11::StepManager(). | |
541f7ba6 | 34 | // General C/C++ includes |
2b680d9b | 35 | #include <stdio.h> |
36 | #include <stdlib.h> | |
541f7ba6 | 37 | // General Root includes |
38 | #include <Riostream.h> | |
2b680d9b | 39 | #include <TMath.h> |
2b680d9b | 40 | #include <TFile.h> // only required for Tracking function? |
2b680d9b | 41 | #include <TObjArray.h> |
541f7ba6 | 42 | #include <TClonesArray.h> |
2b680d9b | 43 | #include <TLorentzVector.h> |
44 | #include <TObjString.h> | |
541f7ba6 | 45 | // Root Geometry includes |
46 | #include <TGeoManager.h> | |
47 | #include <TGeoPcon.h> | |
48 | #include <TGeoTube.h> | |
49 | #include <TGeoNode.h> | |
50 | #include <TGeoMaterial.h> | |
51 | // General AliRoot includes | |
2b680d9b | 52 | #include "AliRun.h" |
53 | #include "AliMagF.h" | |
54 | #include "AliConst.h" | |
541f7ba6 | 55 | // ITS specific includes |
2b680d9b | 56 | #include "AliITShit.h" |
2b680d9b | 57 | #include "AliITSgeom.h" |
58 | #include "AliITSgeomSPD.h" | |
59 | #include "AliITSgeomSDD.h" | |
60 | #include "AliITSgeomSSD.h" | |
61 | #include "AliITSDetType.h" | |
62 | #include "AliITSresponseSPD.h" | |
63 | #include "AliITSresponseSDD.h" | |
64 | #include "AliITSresponseSSD.h" | |
65 | #include "AliITSsegmentationSPD.h" | |
66 | #include "AliITSsegmentationSDD.h" | |
67 | #include "AliITSsegmentationSSD.h" | |
68 | #include "AliITSsimulationSPD.h" | |
69 | #include "AliITSsimulationSDD.h" | |
70 | #include "AliITSsimulationSSD.h" | |
71 | #include "AliITSClusterFinderSPD.h" | |
72 | #include "AliITSClusterFinderSDD.h" | |
73 | #include "AliITSClusterFinderSSD.h" | |
541f7ba6 | 74 | #include "AliITSBaseGeometry.h" |
75 | #include "AliITSv11.h" | |
76 | ||
77 | // Units, Convert from k?? to cm,degree,GeV,seconds, | |
78 | const Double_t kmm = 0.10; // Convert mm to TGeom's cm. | |
79 | const Double_t kcm = 1.00; // Convert cv to TGeom's cm. | |
2b680d9b | 80 | |
81 | ClassImp(AliITSv11) | |
82 | ||
541f7ba6 | 83 | /* |
84 | Some temparary #define's used untill ROOT has addoppted the proper | |
85 | Getter in it's classes. | |
86 | These Below are for TGeoPcon functions. | |
87 | */ | |
88 | ||
2b680d9b | 89 | //______________________________________________________________________ |
90 | AliITSv11::AliITSv11() : AliITS() { | |
aa9bc63b | 91 | // Standard default constructor for the ITS version 11. |
2b680d9b | 92 | // Inputs: |
aa9bc63b | 93 | // none. |
2b680d9b | 94 | // Outputs: |
aa9bc63b | 95 | // none. |
96 | // Return | |
97 | // A default constructed AliITSv11 class. | |
2b680d9b | 98 | |
541f7ba6 | 99 | //fITSV = 0; |
100 | //fcS = 0; | |
162acd47 | 101 | // fcD = 0; |
2b680d9b | 102 | } |
103 | //______________________________________________________________________ | |
aa9bc63b | 104 | AliITSv11::AliITSv11(const char *title) : AliITS("ITS", title){ |
105 | // Standard constructor for the ITS version 11. | |
2b680d9b | 106 | // Inputs: |
162acd47 | 107 | // const char *title The title of for this geometry. |
2b680d9b | 108 | // Outputs: |
aa9bc63b | 109 | // none. |
110 | // Return | |
111 | // A Standard constructed AliITSv11 class. | |
2b680d9b | 112 | |
541f7ba6 | 113 | //fITSV = 0; |
114 | //fcS = 0; | |
162acd47 | 115 | // fcD = 0; |
2b680d9b | 116 | } |
117 | //______________________________________________________________________ | |
aa9bc63b | 118 | AliITSv11::~AliITSv11() { |
119 | // Standard destructor for the ITS version 11. | |
dfefbaec | 120 | // Inputs: |
aa9bc63b | 121 | // none. |
dfefbaec | 122 | // Outputs: |
aa9bc63b | 123 | // none. |
124 | // Return | |
125 | // none. | |
dfefbaec | 126 | |
541f7ba6 | 127 | // if(fITSV!=0) delete fITSV; |
128 | // if(fcS!=0) delete fcS; | |
162acd47 | 129 | // if(fcD!=0) delete fcD; |
130 | } | |
131 | //______________________________________________________________________ | |
541f7ba6 | 132 | AliITSv11::AliITSv11(const AliITSv11 &source) : AliITS(source){ |
162acd47 | 133 | // Copy Constructor for ITS version 11. |
134 | // Inputs: | |
135 | // AliITSv11 &source class to be copied from. | |
136 | // Outputs: | |
137 | // none. | |
138 | // Return | |
139 | // none. | |
140 | ||
141 | if(&source == this) return; | |
142 | Error("Copy Constructor","Not allowed to copy AliITSv11"); | |
143 | return; | |
144 | } | |
145 | //______________________________________________________________________ | |
146 | AliITSv11& AliITSv11::operator=(const AliITSv11 &source){ | |
147 | // Assignment operator for the ITS version 11. | |
148 | // Inputs: | |
149 | // AliITSv11 &source class to be copied from. | |
150 | // Outputs: | |
151 | // none. | |
152 | // Return | |
153 | // none. | |
154 | ||
155 | if(&source == this) return *this; | |
156 | Error("= operator","Not allowed to copy AliITSv11"); | |
157 | return *this; | |
dfefbaec | 158 | } |
159 | //______________________________________________________________________ | |
aa9bc63b | 160 | void AliITSv11::BuildGeometry(){ |
162acd47 | 161 | // This routine defines and Creates the geometry for version 11 of |
162 | // the ITS for use in the simulation display routines. This is a | |
163 | // very simplified geometry for speed of viewing. | |
2b680d9b | 164 | // Inputs: |
aa9bc63b | 165 | // none. |
2b680d9b | 166 | // Outputs: |
aa9bc63b | 167 | // none. |
168 | // Return | |
169 | // none. | |
162acd47 | 170 | TVector3 t(0.0,0.0,0.0); |
2b680d9b | 171 | |
541f7ba6 | 172 | //if(fITSV==0) fITSV = new AliITSGeometryITSV(this,"ALIC"); |
173 | //if(fcS==0) fcS = new AliITSGeometrySSDCone(this,t,"TSV",1); | |
2b680d9b | 174 | |
541f7ba6 | 175 | //fcS->BuildDisplayGeometry(); |
2b680d9b | 176 | } |
177 | //______________________________________________________________________ | |
aa9bc63b | 178 | void AliITSv11::CreateGeometry(){ |
162acd47 | 179 | // This routine defines and Creates the geometry for version 11 of |
180 | // the ITS. The geometry is used by the particle trasport routines, | |
181 | // and therefore, is very detailed. | |
dfefbaec | 182 | // Inputs: |
aa9bc63b | 183 | // none. |
dfefbaec | 184 | // Outputs: |
aa9bc63b | 185 | // none. |
186 | // Return | |
187 | // none. | |
aa9bc63b | 188 | TVector3 t(0.0,0.0,0.0); |
162acd47 | 189 | |
541f7ba6 | 190 | TGeoManager *mgr = gGeoManager; |
191 | TGeoVolume *ALIC = mgr->GetTopVolume(); | |
192 | ||
193 | TGeoPcon *itsv = new TGeoPcon("ITS Top Volume, Daughter of ALIC",0.0,360.0,2); | |
194 | // DefineSection(section number, Z, Rmin, Rmax). | |
195 | itsv->DefineSection(0,-100.0*kcm,0.01*kcm,50.0*kcm); | |
196 | itsv->DefineSection(1,+100.0*kcm,0.01*kcm,50.0*kcm); | |
197 | TGeoVolume *ITSV = new TGeoVolume("ITSV",itsv,0); | |
198 | mgr->AddVolume(ITSV); | |
199 | ALIC->AddNode(ITSV,1,0); | |
162acd47 | 200 | // |
541f7ba6 | 201 | SSDCone(ITSV); |
3717ba94 | 202 | } |
203 | //______________________________________________________________________ | |
541f7ba6 | 204 | Double_t AliITSv11::RmaxFrom2Points(TGeoPcon *p,Int_t i1,Int_t i2,Double_t z){ |
205 | // functions Require at parts of Volume A to be already defined. | |
206 | // Retruns the value of Rmax corresponding to point z alone the line | |
207 | // defined by the two points p.Rmax(i1),p-GetZ(i1) and p->GetRmax(i2), | |
208 | // p->GetZ(i2). | |
209 | ||
210 | return p->GetRmax(i2)+(p->GetRmax(i1)-p->GetRmax(i2))*(z-p->GetZ(i2))/ | |
211 | (p->GetZ(i1)-p->GetZ(i2)); | |
212 | } | |
213 | //______________________________________________________________________ | |
214 | Double_t AliITSv11::RminFrom2Points(TGeoPcon *p,Int_t i1,Int_t i2,Double_t z){ | |
215 | // Retruns the value of Rmin corresponding to point z alone the line | |
216 | // defined by the two points p->GetRmin(i1),p->GetZ(i1) and p->GetRmin(i2), | |
217 | // p->GetZ(i2). | |
162acd47 | 218 | |
541f7ba6 | 219 | return p->GetRmin(i2)+(p->GetRmin(i1)-p->GetRmin(i2))*(z-p->GetZ(i2))/ |
220 | (p->GetZ(i1)-p->GetZ(i2)); | |
221 | } | |
222 | //______________________________________________________________________ | |
223 | Double_t AliITSv11::RFrom2Points(Double_t *p,Double_t *Z,Int_t i1,Int_t i2,Double_t z){ | |
224 | // Retruns the value of Rmin corresponding to point z alone the line | |
225 | // defined by the two points p->GetRmin(i1),p->GetZ(i1) and p->GetRmin(i2), | |
226 | // p->GetZ(i2). | |
162acd47 | 227 | |
541f7ba6 | 228 | return p[i2]+(p[i1]-p[i2])*(z-Z[i2])/(Z[i1]-Z[i2]); |
229 | } | |
230 | //______________________________________________________________________ | |
231 | Double_t AliITSv11::Zfrom2MinPoints(TGeoPcon *p,Int_t i1,Int_t i2,Double_t r){ | |
232 | // Retruns the value of Z corresponding to point R alone the line | |
233 | // defined by the two points p->GetRmin(i1),p->GetZ(i1) and | |
234 | // p->GetRmin(i2),p->GetZ(i2) | |
162acd47 | 235 | |
541f7ba6 | 236 | return p->GetZ(i2)+(p->GetZ(i1)-p->GetZ(i2))*(r-p->GetRmin(i2))/ |
237 | (p->GetRmin(i1)-p->GetRmin(i2)); | |
238 | } | |
239 | //______________________________________________________________________ | |
240 | Double_t AliITSv11::Zfrom2MaxPoints(TGeoPcon *p,Int_t i1,Int_t i2,Double_t r){ | |
241 | // Retruns the value of Z corresponding to point R alone the line | |
242 | // defined by the two points p->GetRmax(i1),p->GetZ(i1) and | |
243 | // p->GetRmax(i2),p->GetZ(i2) | |
162acd47 | 244 | |
541f7ba6 | 245 | return p->GetZ(i2)+(p->GetZ(i1)-p->GetZ(i2))*(r-p->GetRmax(i2))/ |
246 | (p->GetRmax(i1)-p->GetRmax(i2)); | |
247 | } | |
248 | //______________________________________________________________________ | |
249 | Double_t AliITSv11::Zfrom2Points(Double_t *Z,Double_t *p,Int_t i1,Int_t i2,Double_t r){ | |
250 | // Retruns the value of Z corresponding to point R alone the line | |
251 | // defined by the two points p->GetRmax(i1),p->GetZ(i1) and | |
252 | // p->GetRmax(i2),p->GetZ(i2) | |
162acd47 | 253 | |
541f7ba6 | 254 | return Z[i2]+(Z[i1]-Z[i2])*(r-p[i2])/(p[i1]-p[i2]); |
255 | } | |
256 | //______________________________________________________________________ | |
257 | Double_t AliITSv11::RmaxFromZpCone(TGeoPcon *p,Double_t tc,Double_t z,Double_t th){ | |
258 | // General SSD Outer Cone surface equation Rmax. | |
259 | Double_t tantc = TMath::Tan(tc*TMath::DegToRad()); | |
260 | Double_t costc = TMath::Cos(tc*TMath::DegToRad()); | |
162acd47 | 261 | |
541f7ba6 | 262 | return -tantc*(z-p->GetZ(4))+p->GetRmax(4)+th/costc; |
263 | } | |
264 | //______________________________________________________________________ | |
265 | Double_t AliITSv11::RmaxFromZpCone(Double_t *GetRmax,Double_t *GetZ,Double_t tc,Double_t z,Double_t th){ | |
266 | // General SSD Outer Cone surface equation Rmax. | |
267 | Double_t tantc = TMath::Tan(tc*TMath::DegToRad()); | |
268 | Double_t costc = TMath::Cos(tc*TMath::DegToRad()); | |
162acd47 | 269 | |
541f7ba6 | 270 | return -tantc*(z-GetZ[4])+GetRmax[4]+th/costc; |
271 | } | |
272 | //______________________________________________________________________ | |
273 | Double_t AliITSv11::RminFromZpCone(TGeoPcon *p,Double_t tc,Double_t z,Double_t th){ | |
274 | // General SSD Inner Cone surface equation Rmin. | |
275 | Double_t tantc = TMath::Tan(tc*TMath::DegToRad()); | |
276 | Double_t costc = TMath::Cos(tc*TMath::DegToRad()); | |
162acd47 | 277 | |
541f7ba6 | 278 | return -tantc*(z-p->GetZ(3))+p->GetRmin(3)+th/costc; |
279 | } | |
280 | //______________________________________________________________________ | |
281 | Double_t AliITSv11::RminFromZpCone(Double_t *GetRmin,Double_t *GetZ,Double_t tc,Double_t z,Double_t th){ | |
282 | // General SSD Inner Cone surface equation Rmin. | |
283 | Double_t tantc = TMath::Tan(tc*TMath::DegToRad()); | |
284 | Double_t costc = TMath::Cos(tc*TMath::DegToRad()); | |
162acd47 | 285 | |
541f7ba6 | 286 | return -tantc*(z-GetZ[3])+GetRmin[3]+th/costc; |
287 | } | |
288 | //______________________________________________________________________ | |
289 | Double_t AliITSv11::ZFromRmaxpCone(TGeoPcon *p,Double_t tc,Double_t r,Double_t th){ | |
290 | // General SSD Outer cone Surface equation for z. | |
291 | Double_t tantc = TMath::Tan(tc*TMath::DegToRad()); | |
292 | Double_t costc = TMath::Cos(tc*TMath::DegToRad()); | |
162acd47 | 293 | |
541f7ba6 | 294 | return p->GetZ(4)+(p->GetRmax(4)+th/costc-r)/tantc; |
295 | } | |
296 | //______________________________________________________________________ | |
297 | Double_t AliITSv11::ZFromRmaxpCone(Double_t *GetRmax,Double_t *GetZ,Double_t tc,Double_t r,Double_t th){ | |
298 | // General SSD Outer cone Surface equation for z. | |
299 | Double_t tantc = TMath::Tan(tc*TMath::DegToRad()); | |
300 | Double_t costc = TMath::Cos(tc*TMath::DegToRad()); | |
162acd47 | 301 | |
541f7ba6 | 302 | return GetZ[4]+(GetRmax[4]+th/costc-r)/tantc; |
303 | } | |
304 | //______________________________________________________________________ | |
305 | Double_t AliITSv11::ZFromRminpCone(TGeoPcon *p,Double_t tc,Double_t r,Double_t th){ | |
306 | // General SSD Inner cone Surface equation for z. | |
307 | Double_t tantc = TMath::Tan(tc*TMath::DegToRad()); | |
308 | Double_t costc = TMath::Cos(tc*TMath::DegToRad()); | |
3717ba94 | 309 | |
541f7ba6 | 310 | return p->GetZ(3)+(p->GetRmin(3)+th/costc-r)/tantc; |
311 | } | |
312 | //______________________________________________________________________ | |
313 | void AliITSv11::RadiusOfCurvature(Double_t rc,Double_t theta0,Double_t z0, | |
314 | Double_t r0,Double_t theta1,Double_t &z1, | |
315 | Double_t &r1){ | |
316 | // Given a initial point z0,r0, the initial angle theta0, and the radius | |
317 | // of curvature, returns the point z1, r1 at the angle theta1. Theta | |
318 | // measured from the r axis in the clock wise direction [degrees]. | |
319 | Double_t sin0 = TMath::Sin(theta0*TMath::DegToRad()); | |
320 | Double_t cos0 = TMath::Cos(theta0*TMath::DegToRad()); | |
321 | Double_t sin1 = TMath::Sin(theta1*TMath::DegToRad()); | |
322 | Double_t cos1 = TMath::Cos(theta1*TMath::DegToRad()); | |
323 | ||
324 | z1 = rc*(sin1-sin0)+z0; | |
325 | r1 = rc*(cos1-cos0)+r0; | |
326 | return; | |
327 | } | |
328 | //______________________________________________________________________ | |
329 | void AliITSv11::SPDCone(TGeoVolume *Moth){ | |
330 | // Define the detail SPD support cone geometry. | |
331 | // Inputs: | |
332 | // none. | |
333 | // Outputs: | |
334 | // none. | |
335 | // Return: | |
336 | // none. | |
337 | } | |
338 | //______________________________________________________________________ | |
339 | void AliITSv11::SDDCone(TGeoVolume *Moth){ | |
340 | // Define the detail SDD support cone geometry. | |
341 | // Inputs: | |
342 | // none. | |
343 | // Outputs: | |
344 | // none. | |
345 | // Return: | |
346 | // none. | |
347 | } | |
348 | //______________________________________________________________________ | |
349 | void AliITSv11::SSDCone(TGeoVolume *Moth){ | |
350 | // Define the detail SSD support cone geometry. | |
351 | // Inputs: | |
352 | // none. | |
353 | // Outputs: | |
354 | // none. | |
355 | // Return: | |
356 | // none. | |
357 | const Double_t Thickness = 13.0*kmm; // Thickness of Rohacell+carbon fiber | |
358 | const Double_t Cthick = 1.5*kmm; // Carbon finber thickness | |
359 | const Double_t Rcurv = 15.0*kmm; // Radius of curvature. | |
360 | const Double_t Tc = 51.0; // angle of SSD cone [degrees]. | |
361 | const Double_t Sintc = TMath::Sin(Tc*TMath::DegToRad()); | |
362 | const Double_t Costc = TMath::Cos(Tc*TMath::DegToRad()); | |
363 | const Double_t Tantc = TMath::Tan(Tc*TMath::DegToRad()); | |
364 | const Double_t ZouterMilled = (13.5-5.0)*kmm; | |
365 | const Double_t Zcylinder = 170.0*kmm; | |
366 | const Double_t Z0 = Zcylinder + 100.0*kmm; | |
367 | const Int_t Nspoaks = 12; | |
368 | const Int_t Nmounts = 4; | |
369 | const Double_t DmountAngle = 9.0; // degrees | |
370 | const Double_t RoutMax = 0.5*985.0*kmm; | |
371 | const Double_t RoutHole = 0.5*965.0*kmm; | |
372 | const Double_t RoutMin = 0.5*945.0*kmm; | |
373 | const Double_t RholeMax = 0.5*890.0*kmm; | |
374 | const Double_t RholeMin = 0.5*740.0*kmm; | |
375 | const Double_t RpostMin = 316.0*kmm; | |
376 | const Double_t ZpostMax = 196.0*kmm; | |
377 | const Int_t Nposts = 6; | |
378 | const Double_t Phi0Post = 0.0; // degree | |
379 | const Double_t dRpost = 23.0*kmm; | |
380 | const Double_t RinMax = 0.5*590.0*kmm; | |
381 | const Double_t RinCylinder = 0.5*597.0*kmm; | |
382 | const Double_t RinHole = 0.5*575.0*kmm; | |
383 | const Double_t RinMin = 0.5*562.0*kmm; | |
384 | const Double_t dZin = 15.0*kmm; | |
385 | // SSD-SDD Thermal/Mechanical cylinder mounts | |
386 | const Int_t NinScrews = 40; | |
387 | const Double_t Phi0Screws = 0.5*360.0/((const Double_t)NinScrews);//d | |
388 | const Double_t RcylinderScrews = 0.5*570.0*kmm;//from older drawing???? | |
389 | const Double_t DscrewHead = 8.0*kmm; | |
390 | const Double_t DscrewShaft = 4.6*kmm; | |
391 | const Double_t ThScrewHeadHole = 8.5*kmm; | |
392 | // SDD mounting bracket, SSD part | |
393 | const Double_t NssdSupports = 3;// mounting of U and T | |
394 | const Double_t DssdsddBracketAngle = 9.0; // degrees | |
395 | const Double_t Phi0SDDsupports = 0.0; // degree | |
396 | const Double_t RsddSupportPlate = 0.5*585.0*kmm; | |
397 | const Double_t ThSDDsupportPlate = 4.0*kmm; | |
398 | const Double_t WsddSupportPlate = 70.0*kmm; | |
399 | TGeoMedium *SSDcf = 0; // SSD support cone Carbon Fiber materal number. | |
400 | TGeoMedium *SSDfs = 0; // SSD support cone inserto stesalite 4411w. | |
401 | TGeoMedium *SSDfo = 0; // SSD support cone foam, Rohacell 50A. | |
402 | TGeoMedium *SSDss = 0; // SSD support cone screw material,Stainless steal | |
403 | TGeoMedium *SSDair = 0; // SSD support cone Air | |
404 | TGeoMedium *SSDal = 0; // SSD support cone SDD mounting bracket Al | |
405 | ||
406 | // Lets start with the upper left outer carbon fiber surface. | |
407 | // Between za[2],rmaxa[2] and za[4],rmaxa[4] there is a curved section | |
408 | // given by rmaxa = rmaxa[2]-r*Sind(t) for 0<=t<=Tc and | |
409 | // za = za[2] + r*Cosd(t) for 0<=t<=Tc. Simularly between za[1],rmina[1 | |
410 | // and za[3],rmina[3] there is a curve section given by | |
411 | // rmina = rmina[1]-r*Sind(t) for 0<=t<=Tc and za = za[1]+r&Sind(t) | |
412 | // for t<=0<=Tc. These curves have been replaced by straight lines | |
413 | // between the equivelent points for simplicity. | |
414 | Double_t dza = Thickness/Sintc-(RoutMax-RoutMin)/Tantc; | |
415 | Int_t i,j; | |
416 | Double_t z[9],rn[9],rx[9],phi,dphi; | |
417 | Double_t t,t0,Z,Rmin,Rmax; // Temp variables. | |
418 | if(dza<=0){ // The number or order of the points are in error for a proper | |
419 | // call to pcons! | |
420 | Error("SSDcone","The definition of the points for a call to PCONS is" | |
421 | " in error. abort."); | |
422 | return; | |
423 | } // end if | |
424 | // Poly-cone Volume A. Top part of SSD cone Carbon Fiber. | |
425 | phi = 0.0; | |
426 | dphi = 360.0; | |
427 | z[0] = 0.0; | |
428 | rn[0] = RoutMin; | |
429 | rx[0] = RoutMax; | |
430 | z[1] = z[0]+ZouterMilled - dza; // za[2] - dza. | |
431 | rn[1] = rn[0]; | |
432 | rx[1] = rx[0]; | |
433 | z[2] = z[0]+ZouterMilled;//From Drawing ALR-0767 and ALR-0767/3 | |
434 | rx[2] = rx[0]; | |
435 | RadiusOfCurvature(Rcurv,0.,z[1],rn[1],Tc,z[3],rn[3]); | |
436 | rn[2] = RFrom2Points(rn,z,3,1,z[2]); | |
437 | RadiusOfCurvature(Rcurv,0.,z[2],rx[2],Tc,z[4],rx[4]); | |
438 | rn[4] = RminFromZpCone(rn,z,Tc,z[4]); | |
439 | rx[3] = RFrom2Points(rx,z,4,2,z[3]); | |
440 | rn[5] = RholeMax; | |
441 | z[5] = Zfrom2Points(z,rn,4,3,rn[5]); | |
442 | rx[5] = RmaxFromZpCone(rx,z,Tc,z[5]); | |
443 | rn[6] = RholeMax; | |
444 | rx[6] = rn[6]; | |
445 | z[6] = ZFromRmaxpCone(z,rx,Tc,rx[6]); | |
446 | TGeoPcon *A = new TGeoPcon("ITS SSD Suport cone Carbon Fiber " | |
447 | "Surface outer left",phi,dphi,7); | |
448 | for(i=0;i<A->GetNz();i++){ | |
449 | if(fDebug) cout<<i<<"A: z="<<z[i]<<" Rmin="<<rn[i]<<" Rmax="<<rx[i]<<endl; | |
450 | A->DefineSection(i,z[i],rn[i],rx[i]); | |
451 | } // end for i | |
452 | // | |
453 | // Poly-cone Volume B. Stesalite inside volume A. | |
454 | // Now lets define the Inserto Stesalite 4411w material volume. | |
455 | phi = 0.0; | |
456 | dphi = 360.0; | |
457 | z[0] = A->GetZ(0); | |
458 | rn[0] = A->GetRmin(0)+Cthick; | |
459 | rx[0] = A->GetRmax(0)-Cthick; | |
460 | z[1] = A->GetZ(1); | |
461 | rn[1] = rn[0]; | |
462 | rx[1] = rx[0]; | |
463 | z[2] = A->GetZ(2); | |
464 | rx[2] = rx[1]; | |
465 | RadiusOfCurvature(Rcurv-Cthick,0.,z[2],rx[2],Tc,z[3],rx[3]); | |
466 | RadiusOfCurvature(Rcurv+Cthick,0.,z[1],rn[1],Tc,z[4],rn[4]); | |
467 | rn[2] = RFrom2Points(rn,z,4,1,z[2]); | |
468 | rn[3] = RFrom2Points(rn,z,4,1,z[3]); | |
469 | z[5] = z[4]+(Thickness-2.0*Cthick)/Sintc; | |
470 | rn[5] = RmaxFromZpCone(A,Tc,z[5],-Cthick); | |
471 | rx[5] = rn[5]; | |
472 | rx[4] = RFrom2Points(rx,z,5,3,z[4]); | |
473 | TGeoPcon *B = new TGeoPcon("ITS SSD Suport cone Inserto Stesalite " | |
474 | "left edge",phi,dphi,6); | |
475 | for(i=0;i<B->GetNz();i++){ | |
476 | if(fDebug) cout<<i<<"B: z="<<z[i]<<" Rmin="<<rn[i]<<" Rmax="<<rx[i]<<endl; | |
477 | B->DefineSection(i,z[i],rn[i],rx[i]); | |
478 | } // end for i | |
479 | // | |
480 | // Poly-cone Volume C. Foam inside volume A. | |
481 | // Now lets define the Rohacell foam material volume. | |
482 | phi = 0.0; | |
483 | dphi = 360.0; | |
484 | z[0] = B->GetZ(4); | |
485 | rn[0] = B->GetRmin(4); | |
486 | rx[0] = rn[0]; | |
487 | z[1] = B->GetZ(5); | |
488 | rx[1] = B->GetRmin(5); | |
489 | rn[2] = A->GetRmin(5)+Cthick;//space for carbon fiber covering hole | |
490 | z[2] = ZFromRminpCone(A,Tc,rn[2],+Cthick); | |
491 | rn[1] = RFrom2Points(rn,z,2,0,z[1]); | |
492 | rx[3] = A->GetRmin(6)+Cthick; | |
493 | rn[3] = rx[3]; | |
494 | z[3] = ZFromRmaxpCone(A,Tc,rx[3],-Cthick); | |
495 | rx[2] = RFrom2Points(rx,z,3,1,z[2]); | |
496 | TGeoPcon *C = new TGeoPcon("ITS SSD Suport cone Rohacell foam " | |
497 | "left edge",phi,dphi,4); | |
498 | for(i=0;i<C->GetNz();i++){ | |
499 | if(fDebug) cout<<i<<"C: z="<<z[i]<<" Rmin="<<rn[i]<<" Rmax="<<rx[i]<<endl; | |
500 | C->DefineSection(i,z[i],rn[i],rx[i]); | |
501 | } // end for i | |
502 | // | |
503 | // In volume SCB, th Inserto Stesalite 4411w material volume, there | |
504 | // are a number of Stainless steel screw and pin studs which will be | |
505 | // filled with screws/studs. | |
506 | rn[0] = 0.0,rx[0] = 6.0,z[0] = 0.5*10.0; // mm | |
507 | TGeoTube *D = new TGeoTube("ITS Screw+stud used to mount things to " | |
508 | "the SSD support cone",rn[0],rx[0],z[0]); | |
509 | rn[0] = 0.0;rx[0] = 6.0;z[0] = 0.5*12.0; // mm | |
510 | TGeoTube *E = new TGeoTube("ITS pin used to mount things to the " | |
511 | "SSD support cone",rn[0],rx[0],z[0]); | |
512 | // | |
513 | // Poly-cone Volume F. Foam in spoak reagion, inside volume A. | |
514 | // There is no carbon fiber between this upper left section and the | |
515 | // SSD spoaks. We remove it by replacing it with Rohacell foam. | |
516 | t = Cthick/(0.5*(RholeMax+RholeMin));// It is not posible to get | |
517 | // the carbon fiber thickness uniform in this phi direction. We can only | |
518 | // make it a fixed angular thickness. | |
519 | t *= 180.0/TMath::Pi(); | |
520 | phi = 12.5+t; // degrees see drawing ALR-0767. | |
521 | dphi = 5.0 - 2.0*t; // degrees | |
522 | z[0] = C->GetZ(2); | |
523 | rn[0] = C->GetRmin(3); | |
524 | rx[0] = rn[0]; | |
525 | rn[1] = A->GetRmin(5); | |
526 | rx[1] = rn[0]; | |
527 | z[1] = ZFromRminpCone(A,Tc,rn[1],+Cthick); | |
528 | z[2] = C->GetZ(3); | |
529 | rn[2] = rn[1]; | |
530 | rx[2] = rx[1]; | |
531 | rn[3] = A->GetRmin(6); | |
532 | rx[3] = rn[3]; | |
533 | z[3] = ZFromRmaxpCone(A,Tc,rx[3],-Cthick); | |
534 | TGeoPcon *F = new TGeoPcon("ITS SSD Top Suport cone Rohacell foam " | |
535 | "Spoak",phi,dphi,4); | |
536 | for(i=0;i<F->GetNz();i++){ | |
537 | if(fDebug) cout<<i<<"F: z="<<z[i]<<" Rmin="<<rn[i]<<" Rmax="<<rx[i]<<endl; | |
538 | F->DefineSection(i,z[i],rn[i],rx[i]); | |
539 | } // end for i | |
540 | //================================================================= | |
541 | // Poly-cone Volume G. | |
542 | // Now for the spoak part of the SSD cone. | |
543 | // It is not posible to inclue the radius of curvature between | |
544 | // the spoak part and the upper left part of the SSD cone or lowwer right | |
545 | // part. This would be discribed by the following curves. | |
546 | // R = Rmax - (5mm)*Sin(t) phi = phi0+(5mm*180/(Pi*RoutHole))*Sin(t) | |
547 | // where 0<=t<=90 For the inner curve a simular equiation holds. | |
548 | phi = 12.5; // degrees see drawing ALR-0767. | |
549 | dphi = 5.0; // degrees | |
550 | z[0] = A->GetZ(5); | |
551 | rn[0] = A->GetRmin(5); | |
552 | rx[0] = rn[0]; | |
553 | z[1] = A->GetZ(6); | |
554 | rn[1] = RminFromZpCone(A,Tc,z[1]); | |
555 | rx[1] = rx[0]; | |
556 | rn[2] = RholeMin; | |
557 | z[2] = ZFromRminpCone(A,Tc,rn[2]); | |
558 | rx[2] = RmaxFromZpCone(A,Tc,z[2]); | |
559 | rn[3] = rn[2]; | |
560 | rx[3] = rn[3]; | |
561 | z[3] = ZFromRmaxpCone(A,Tc,rx[3]); | |
562 | TGeoPcon *G = new TGeoPcon("ITS SSD spoak carbon fiber surfaces", | |
563 | phi,dphi,4); | |
564 | for(i=0;i<G->GetNz();i++){ | |
565 | if(fDebug) cout<<i<<"G: z="<<z[i]<<" Rmin="<<rn[i]<<" Rmax="<<rx[i]<<endl; | |
566 | G->DefineSection(i,z[i],rn[i],rx[i]); | |
567 | } // end for i | |
568 | // For the foam core. | |
569 | // Poly-cone Volume H. | |
570 | t = Cthick/(0.5*(RholeMax+RholeMin));// It is not posible to get the | |
571 | // carbon fiber thickness uniform in this phi direction. We can only | |
572 | // make it a fixed angular thickness. | |
573 | t *= 180.0/TMath::Pi(); | |
574 | phi = 12.5+t; // degrees | |
575 | dphi = 5.0 - 2.0*t; // degrees see drawing ALR-0767. | |
576 | z[0] = F->GetZ(1); | |
577 | rn[0] = G->GetRmin(0); | |
578 | rx[0] = rn[0]; | |
579 | z[1] = F->GetZ(3); | |
580 | rn[1] = RminFromZpCone(A,Tc,z[1],+Cthick); | |
581 | rx[1] = rx[0]; | |
582 | z[2] = ZFromRminpCone(A,Tc,G->GetRmin(2),+Cthick); | |
583 | rn[2] = G->GetRmin(2); | |
584 | rx[2] = RmaxFromZpCone(A,Tc,z[2],-Cthick); | |
585 | z[3] = ZFromRmaxpCone(A,Tc,G->GetRmin(3),-Cthick); | |
586 | rn[3] = G->GetRmin(3); | |
587 | rx[3] = rn[3]; | |
588 | TGeoPcon *H = new TGeoPcon("ITS SSD support cone Rohacell foam Spoak", | |
589 | phi,dphi,4); | |
590 | for(i=0;i<H->GetNz();i++){ | |
591 | if(fDebug) cout<<i<<"H: z="<<z[i]<<" Rmin="<<rn[i]<<" Rmax="<<rx[i]<<endl; | |
592 | H->DefineSection(i,z[i],rn[i],rx[i]); | |
593 | } // end for i | |
594 | // | |
595 | //================================================================== | |
596 | // Now for the Inner most part of the SSD cone. | |
597 | //Poly-cone Volume I. | |
598 | phi = 0.0; | |
599 | dphi = 360.0; | |
600 | z[0] = G->GetZ(2); | |
601 | rn[0] = G->GetRmin(2); | |
602 | rx[0] = rn[0]; | |
603 | z[1] = G->GetZ(3); | |
604 | rn[1] = RminFromZpCone(A,Tc,z[1]); | |
605 | rx[1] = rx[0]; | |
606 | rn[4] = RinMin; | |
607 | rn[5] = RinMin; | |
608 | RadiusOfCurvature(Rcurv,90.0,0.0,RinMax,90.0-Tc,Z,rx[5]); // z dummy | |
609 | z[5] = ZFromRmaxpCone(A,Tc,rx[5]); | |
610 | z[6] = Zcylinder; | |
611 | rn[6] = RinMin; | |
612 | z[7] = z[6]; | |
613 | rn[7] = RinCylinder; | |
614 | rn[8] = RinCylinder; | |
615 | rx[8] = rn[8]; | |
616 | Rmin = rn[5]; | |
617 | RadiusOfCurvature(Rcurv,90.0-Tc,z[5],rx[5],90.0,Z,Rmax); | |
618 | Rmax = RinMax; | |
619 | z[8] = Z+(z[5]-Z)*(rx[8]-Rmax)/(rx[5]-Rmax); | |
620 | rx[6] = RFrom2Points(rx,z,8,5,z[6]); | |
621 | rx[7] = rx[6]; | |
622 | z[3] = Z-dZin; | |
623 | z[4] = z[3]; | |
624 | rx[3] = RmaxFromZpCone(A,Tc,z[3]); | |
625 | rx[4] = rx[3]; | |
626 | //rmin dummy | |
627 | RadiusOfCurvature(Rcurv,90.,z[3],0.,90.-Tc,z[2],Rmin); | |
628 | rn[2] = RminFromZpCone(A,Tc,z[2]); | |
629 | rx[2] = RmaxFromZpCone(A,Tc,z[2]); | |
630 | // z dummy | |
631 | RadiusOfCurvature(Rcurv,90.-Tc,0.0,rn[2],90.0,Z,rn[3]); | |
632 | TGeoPcon *I = new TGeoPcon("ITS SSD lower/inner right part of SSD " | |
633 | "cone",phi,dphi,9); | |
634 | for(i=0;i<I->GetNz();i++){ | |
635 | if(fDebug) cout<<i<<"I: z="<<z[i]<<" Rmin="<<rn[i]<<" Rmax="<<rx[i]<<endl; | |
636 | I->DefineSection(i,z[i],rn[i],rx[i]); | |
637 | } // end for i | |
638 | // Now for Inserto volume at the inner most radius. | |
639 | // Poly-cone Volume K. | |
640 | phi = 0.0; | |
641 | dphi = 360.0; | |
642 | z[1] = I->GetZ(3)+Cthick; | |
643 | rn[1] = I->GetRmin(3); | |
644 | z[2] = z[1]; | |
645 | rn[2] = I->GetRmin(4); | |
646 | rn[3] = rn[2]; | |
647 | rn[4] = rn[2]; | |
648 | rx[4] = I->GetRmax(5)-Cthick*Sintc; | |
649 | RadiusOfCurvature(Rcurv+Cthick,90.0,z[1],rn[1],90.0-Tc,z[0],rn[0]); | |
650 | rx[0] = rn[0]; | |
651 | z[3] = z[0]+(Thickness-2.0*Cthick)*Costc;; | |
652 | rx[3] = rx[0]+(Thickness-2.0*Cthick)*Sintc; | |
653 | rx[1] = RFrom2Points(rx,z,3,0,z[1]); | |
654 | rx[2] = rx[1]; | |
655 | z[4] = ZFromRmaxpCone(A,Tc,rx[4],-Cthick); | |
656 | rn[5] = rn[2]; | |
657 | z[5] = I->GetZ(6); | |
658 | rx[5] = (I->GetRmax(5)-I->GetRmax(8))/(I->GetZ(5)-I->GetZ(8))*(z[5]-z[4])+ | |
659 | rx[4]; | |
660 | TGeoPcon *K = new TGeoPcon("ITS SSD inner most inserto material", | |
661 | phi,dphi,6); | |
662 | for(i=0;i<K->GetNz();i++){ | |
663 | if(fDebug) cout<<i<<"K: z="<<z[i]<<" Rmin="<<rn[i]<<" Rmax="<<rx[i]<<endl; | |
664 | K->DefineSection(i,z[i],rn[i],rx[i]); | |
665 | } // end for i | |
666 | // Now for foam core at the inner most radius. | |
667 | // Poly-cone Volume J. | |
668 | phi = 0.0; | |
669 | dphi = 360.0; | |
670 | rn[0] = I->GetRmin(0)-Cthick; | |
671 | z[0] = ZFromRminpCone(A,Tc,rn[0],+Cthick); | |
672 | rx[0] = rn[0]; | |
673 | rx[1] = rx[0]; | |
674 | z[1] = ZFromRmaxpCone(A,Tc,rx[1],-Cthick); | |
675 | rn[1] = RminFromZpCone(A,Tc,z[1],+Cthick); | |
676 | z[2] = K->GetZ(0); | |
677 | rn[2] = K->GetRmin(0); | |
678 | rx[2] = RmaxFromZpCone(A,Tc,z[2],-Cthick); | |
679 | z[3] = K->GetZ(3); | |
680 | rn[3] = K->GetRmax(3); | |
681 | rx[3] = rn[3]; | |
682 | TGeoPcon *J = new TGeoPcon("ITS SSD inner most foam core",phi,dphi,4); | |
683 | for(i=0;i<J->GetNz();i++){ | |
684 | if(fDebug) cout<<i<<"J: z="<<z[i]<<" Rmin="<<rn[i]<<" Rmax="<<rx[i]<<endl; | |
685 | J->DefineSection(i,z[i],rn[i],rx[i]); | |
686 | } // end for i | |
687 | // Now for foam core at the top of the inner most radius where | |
688 | // the spoaks are. | |
689 | t = Cthick/(0.5*(RholeMax+RholeMin));// It is not posible to get the | |
690 | // carbon fiber thickness uniform in this phi direction. We can only | |
691 | // make it a fixed angular thickness. | |
692 | // Poly-cone Volume L. | |
693 | t *= 180.0/TMath::Pi(); | |
694 | phi = 12.5+t; // degrees | |
695 | dphi = 5.0 - 2.0*t; // degrees see drawing ALR-0767. | |
696 | z[0] = H->GetZ(2); | |
697 | rn[0] = H->GetRmin(2); | |
698 | rx[0] = rn[0]; | |
699 | z[1] = J->GetZ(0); | |
700 | rn[1] = J->GetRmin(0); | |
701 | rx[1] = I->GetRmax(1); | |
702 | z[2] = H->GetZ(3); | |
703 | rn[2] = rn[1]; | |
704 | rx[2] = rx[1]; | |
705 | z[3] = J->GetZ(1); | |
706 | rn[3] = rn[2]; | |
707 | rx[3] = rn[3]; | |
708 | TGeoPcon *L = new TGeoPcon("ITS SSD Bottom cone Rohacell foam Spoak", | |
709 | phi,dphi,4); | |
710 | for(i=0;i<L->GetNz();i++){ | |
711 | if(fDebug) cout<<i<<"L: z="<<z[i]<<" Rmin="<<rn[i]<<" Rmax="<<rx[i]<<endl; | |
712 | L->DefineSection(i,z[i],rn[i],rx[i]); | |
713 | } // end for i | |
714 | // Now for the SSD mounting posts | |
715 | // Poly-cone Volume O. | |
716 | dphi = 180.0*dRpost/(RpostMin+0.5*dRpost)/TMath::Pi(); // | |
717 | phi = Phi0Post-0.5*dphi; // degrees | |
718 | rn[0] = RpostMin+dRpost; | |
719 | rx[0] = rn[0]; | |
720 | z[0] = ZFromRmaxpCone(A,Tc,rx[0]); | |
721 | rn[1] = RpostMin; | |
722 | z[1] = ZFromRmaxpCone(A,Tc,rn[1]); | |
723 | rx[1] = rx[0]; | |
724 | z[2] = ZpostMax; | |
725 | rn[2] = RpostMin; | |
726 | rx[2] = rn[2]+dRpost; | |
727 | TGeoPcon *O = new TGeoPcon("ITS SSD mounting post, carbon fiber", | |
728 | phi,dphi,3); | |
729 | for(i=0;i<O->GetNz();i++){ | |
730 | if(fDebug) cout<<i<<"O: z="<<z[i]<<" Rmin="<<rn[i]<<" Rmax="<<rx[i]<<endl; | |
731 | O->DefineSection(i,z[i],rn[i],rx[i]); | |
732 | } // end for i | |
733 | // Now for the SSD mounting posts | |
734 | // Poly-cone Volume P. | |
735 | t = 180.0*Cthick/(RpostMin+0.5*dRpost)/TMath::Pi(); | |
736 | dphi = O->GetDphi()-2.0*t; // degrees | |
737 | phi = O->GetPhi1()+t; // | |
738 | rn[0] = O->GetRmin(0)-Cthick; | |
739 | rx[0] = rn[0]; | |
740 | z[0] = ZFromRmaxpCone(A,Tc,rx[0]); | |
741 | rn[1] = O->GetRmin(1)+Cthick; | |
742 | rx[1] = O->GetRmin(0)-Cthick; | |
743 | z[1] = ZFromRmaxpCone(A,Tc,rn[1]); | |
744 | rn[2] = rn[1]; | |
745 | rx[2] = rx[1]; | |
746 | z[2] = ZpostMax; | |
747 | TGeoPcon *P = new TGeoPcon("ITS SSD mounting post, Inserto", | |
748 | phi,dphi,3); | |
749 | for(i=0;i<P->GetNz();i++){ | |
750 | if(fDebug) cout<<i<<"P: z="<<z[i]<<" Rmin="<<rn[i]<<" Rmax="<<rx[i]<<endl; | |
751 | P->DefineSection(i,z[i],rn[i],rx[i]); | |
752 | } // end for i | |
753 | // This insrto continues into the SSD cone displacing the foam | |
754 | // and the carbon fiber surface at those points where the posts are. | |
755 | //Poly-cone Vol. M | |
756 | phi = P->GetPhi1(); | |
757 | dphi = P->GetDphi(); | |
758 | rn[0] = RpostMin+dRpost-Cthick; | |
759 | rx[0] = rn[0]; | |
760 | z[0] = ZFromRminpCone(A,Tc,rn[0],+Cthick); | |
761 | rx[1] = rx[0]; | |
762 | z[1] = ZFromRmaxpCone(A,Tc,rx[1],-Cthick); | |
763 | rn[1] = RminFromZpCone(A,Tc,z[1],+Cthick); | |
764 | rn[2] = RpostMin+Cthick; | |
765 | z[2] = ZFromRminpCone(A,Tc,rn[2],+Cthick); | |
766 | rx[2] = RmaxFromZpCone(A,Tc,z[2],-Cthick); | |
767 | rn[3] = rn[2]; | |
768 | rx[3] = rn[3]; | |
769 | z[3] = ZFromRmaxpCone(A,Tc,rx[3],-Cthick); | |
770 | TGeoPcon *M = new TGeoPcon("ITS SSD mounting post foam substitute, " | |
771 | "Inserto",phi,dphi,4); | |
772 | for(i=0;i<M->GetNz();i++){ | |
773 | if(fDebug) cout<<i<<"M: z="<<z[i]<<" Rmin="<<rn[i]<<" Rmax="<<rx[i]<<endl; | |
774 | M->DefineSection(i,z[i],rn[i],rx[i]); | |
775 | } // end for i | |
776 | // | |
777 | //Poly-cone Vol. N | |
778 | phi = P->GetPhi1(); | |
779 | dphi = P->GetDphi(); | |
780 | z[0] = M->GetZ(1); | |
781 | rn[0] = M->GetRmax(1); | |
782 | rx[0] = rn[0]; | |
783 | rx[1] = rx[0]; | |
784 | z[1] = ZFromRmaxpCone(A,Tc,rx[1]); | |
785 | rn[1] = RmaxFromZpCone(A,Tc,z[1],-Cthick); | |
786 | z[2] = M->GetZ(3); | |
787 | rn[2] = M->GetRmin(3); | |
788 | rx[2] = RmaxFromZpCone(A,Tc,z[2]); | |
789 | rn[3] = rn[2]; | |
790 | rx[3] = rn[3]; | |
791 | z[3] = ZFromRmaxpCone(A,Tc,rx[3]); | |
792 | TGeoPcon *N = new TGeoPcon("ITS SSD mounting post CF subsititute, " | |
793 | "Inserto",phi,dphi,4); | |
794 | for(i=0;i<N->GetNz();i++){ | |
795 | if(fDebug) cout<<i<<"N: z="<<z[i]<<" Rmin="<<rn[i]<<" Rmax="<<rx[i]<<endl; | |
796 | N->DefineSection(i,z[i],rn[i],rx[i]); | |
797 | } // end for i | |
798 | // Bolt heads holding the SSD-SDD tube to the SSD cone. | |
799 | // Bolt -- PolyCone | |
800 | //Poly-cone Volume Q. | |
801 | phi = 0.0; | |
802 | dphi = 360.0; | |
803 | z[0] = I->GetZ(4)-ThSDDsupportPlate; | |
804 | rn[0] = 0.0; | |
805 | rx[0] = 0.5*DscrewHead; | |
806 | z[1] = I->GetZ(4)-ThScrewHeadHole; | |
807 | rn[1] = 0.0; | |
808 | rx[1] = 0.5*DscrewHead; | |
809 | z[2] = z[1]; | |
810 | rn[2] = 0.0; | |
811 | rx[2] = 0.5*DscrewShaft; | |
812 | z[3] = z[2]; | |
813 | rn[3] = 0.0; | |
814 | rx[3] = rx[2]; | |
815 | TGeoPcon *Q = new TGeoPcon("ITS SSD Thermal sheal stainless steel " | |
816 | "bolts",phi,dphi,4); | |
817 | for(i=0;i<Q->GetNz();i++){ | |
818 | if(fDebug) cout<<i<<"Q: z="<<z[i]<<" Rmin="<<rn[i]<<" Rmax="<<rx[i]<<endl; | |
819 | Q->DefineSection(i,z[i],rn[i],rx[i]); | |
820 | } // end for i | |
821 | // air infront of bolt (stasolit Volume K) -- Tube | |
822 | z[0] = 0.5*(Thickness-ThScrewHeadHole); | |
823 | rn[0] = 0.0; | |
824 | rx[0] = 0.5*DscrewHead; | |
825 | TGeoTube *R = new TGeoTube("ITS Air in front of bolt (in stasolit)", | |
826 | rn[0],rx[0],z[0]); | |
827 | // air infront of bolt (carbon fiber volume I) -- Tube | |
828 | z[0] = 0.5*Thickness; | |
829 | rn[0] = 0.0; | |
830 | rx[0] = R->GetRmax(); | |
831 | TGeoTube *S = new TGeoTube("ITS Air in front of Stainless Steal " | |
832 | "Screw end, N6",rn[0],rx[0],z[0]); | |
833 | // SDD support plate, SSD side. | |
834 | //Poly-cone Volume T. | |
835 | dphi = 180.0*WsddSupportPlate/(RsddSupportPlate*TMath::Pi()); | |
836 | phi = Phi0SDDsupports-0.5*dphi; | |
837 | z[0] = K->GetZ(2); | |
838 | rn[0] = I->GetRmin(4); | |
839 | rx[0] = RsddSupportPlate; | |
840 | z[1] = I->GetZ(4) - ThSDDsupportPlate; | |
841 | rn[1] = rn[0]; | |
842 | rx[1] = rx[0]; | |
843 | TGeoPcon *T = new TGeoPcon("ITS SSD-SDD mounting bracket Inserto->Al.", | |
844 | phi,dphi,2); | |
845 | for(i=0;i<T->GetNz();i++){ | |
846 | if(fDebug) cout<<i<<"T: z="<<z[i]<<" Rmin="<<rn[i]<<" Rmax="<<rx[i]<<endl; | |
847 | T->DefineSection(i,z[i],rn[i],rx[i]); | |
848 | } // end for i | |
849 | // | |
850 | // Poly-cone Volume U. | |
851 | TGeoPcon *U; | |
852 | if(I->GetRmin(3)<T->GetRmax(0)){ | |
853 | dphi = T->GetDphi(); | |
854 | phi = T->GetPhi1(); | |
855 | z[2] = I->GetZ(4); | |
856 | rn[2] = T->GetRmin(0); | |
857 | rx[2] = T->GetRmax(0); | |
858 | z[3] = K->GetZ(2); | |
859 | rn[3] = rn[2]; | |
860 | rx[3] = rx[2]; | |
861 | z[1] = z[2]; | |
862 | rn[1] = I->GetRmin(3); | |
863 | rx[1] = rx[3]; | |
864 | rx[0] = T->GetRmax(0); | |
865 | rn[0] = rx[0]; | |
866 | z[0] = Zfrom2MinPoints(I,2,3,rn[0]); | |
867 | U = new TGeoPcon("ITS SSD-SDD mounting bracket CF->Al.",phi,dphi,4); | |
868 | }else{ | |
869 | dphi = T->GetDphi(); | |
870 | phi = T->GetPhi1(); | |
871 | z[0] = I->GetZ(4); | |
872 | rn[0] = T->GetRmin(0); | |
873 | rx[0] = T->GetRmax(0); | |
874 | z[1] = K->GetZ(2); | |
875 | rn[1] = rn[0]; | |
876 | rx[1] = rx[0]; | |
877 | U = new TGeoPcon("ITS SSD-SDD mounting bracket CF->Al.",phi,dphi,2); | |
878 | }// end if | |
879 | for(i=0;i<U->GetNz();i++){ | |
880 | if(fDebug) cout<<i<<"U: z="<<z[i]<<" Rmin="<<rn[i]<<" Rmax="<<rx[i]<<endl; | |
881 | U->DefineSection(i,z[i],rn[i],rx[i]); | |
882 | } // end for i | |
883 | // | |
884 | TGeoManager *mgr = gGeoManager; | |
885 | SSDcf = mgr->GetMedium("ITSssdCarbonFiber"); | |
886 | SSDfs = mgr->GetMedium("ITSssdStaselite4411w"); | |
887 | SSDfo = mgr->GetMedium("ITSssdRohacell50A"); | |
888 | SSDss = mgr->GetMedium("ITSssdStainlessSteal"); | |
889 | SSDair= mgr->GetMedium("ITSssdAir"); | |
890 | SSDal = mgr->GetMedium("ITSssdAl"); | |
891 | TGeoVolume *Av,*Bv,*Cv,*Dv,*Ev,*Fv,*Gv,*Hv,*Iv,*Jv,*Kv,*Lv,*Mv,*Nv, | |
892 | *Ov,*Pv,*Qv,*Rv,*Sv,*Tv,*Uv; | |
893 | Av = new TGeoVolume("ITSssdConeA",A,SSDcf); | |
894 | mgr->AddVolume(Av); | |
895 | Av->SetLineColor(1); | |
896 | Av->SetLineWidth(1); | |
897 | Bv = new TGeoVolume("ITSssdConeB",B,SSDfs); | |
898 | mgr->AddVolume(Bv); | |
899 | Cv = new TGeoVolume("ITSssdConeC",C,SSDfo); | |
900 | mgr->AddVolume(Cv); | |
901 | Dv = new TGeoVolume("ITSssdConeD",D,SSDss); | |
902 | mgr->AddVolume(Dv); | |
903 | Ev = new TGeoVolume("ITSssdConeE",E,SSDss); | |
904 | mgr->AddVolume(Ev); | |
905 | Fv = new TGeoVolume("ITSssdConeF",F,SSDfo); | |
906 | mgr->AddVolume(Fv); | |
907 | Gv = new TGeoVolume("ITSssdConeG",G,SSDcf); | |
908 | mgr->AddVolume(Gv); | |
909 | Gv->SetLineColor(2); | |
910 | Gv->SetLineWidth(2); | |
911 | Hv = new TGeoVolume("ITSssdConeH",H,SSDfo); | |
912 | mgr->AddVolume(Hv); | |
913 | Iv = new TGeoVolume("ITSssdConeI",I,SSDcf); | |
914 | mgr->AddVolume(Iv); | |
915 | Iv->SetLineColor(3); | |
916 | Iv->SetLineWidth(3); | |
917 | Jv = new TGeoVolume("ITSssdConeJ",J,SSDfo); | |
918 | mgr->AddVolume(Jv); | |
919 | Kv = new TGeoVolume("ITSssdConeK",K,SSDfs); | |
920 | mgr->AddVolume(Kv); | |
921 | Lv = new TGeoVolume("ITSssdConeL",L,SSDfo); | |
922 | mgr->AddVolume(Lv); | |
923 | Mv = new TGeoVolume("ITSssdConeM",M,SSDfs); | |
924 | mgr->AddVolume(Mv); | |
925 | Nv = new TGeoVolume("ITSssdConeN",N,SSDfs); | |
926 | mgr->AddVolume(Nv); | |
927 | Ov = new TGeoVolume("ITSssdConeO",O,SSDcf); | |
928 | mgr->AddVolume(Ov); | |
929 | Iv->SetLineColor(4); | |
930 | Iv->SetLineWidth(4); | |
931 | Pv = new TGeoVolume("ITSssdConeP",P,SSDfs); | |
932 | mgr->AddVolume(Pv); | |
933 | Qv = new TGeoVolume("ITSssdConeQ",Q,SSDss); | |
934 | mgr->AddVolume(Qv); | |
935 | Rv = new TGeoVolume("ITSssdConeR",R,SSDair); | |
936 | mgr->AddVolume(Rv); | |
937 | Sv = new TGeoVolume("ITSssdConeS",S,SSDair); | |
938 | mgr->AddVolume(Sv); | |
939 | Tv = new TGeoVolume("ITSssdConeT",T,SSDal); | |
940 | mgr->AddVolume(Tv); | |
941 | Uv = new TGeoVolume("ITSssdConeU",U,SSDal); | |
942 | mgr->AddVolume(Uv); | |
943 | // | |
944 | TGeoTranslation *tran = new TGeoTranslation("ITSssdConeTrans",0.0,0.0,-Z0); | |
945 | TGeoRotation *rot180 = new TGeoRotation("ITSssdConeRot180",0.0,180.0,0.0); | |
946 | TGeoCombiTrans *flip = new TGeoCombiTrans("ITSssdConeFlip",0.0,0.0,Z0,rot180); | |
947 | TGeoTranslation *tranR,*tranS; | |
948 | TGeoCombiTrans *fliptran,*rottran; | |
949 | TGeoRotation *rot,*zspoaks,*zspoaks180; | |
950 | Av->AddNode(Bv,1,0); | |
951 | Av->AddNode(Cv,1,0); | |
952 | Moth->AddNode(Av,1,tran); // RB24 side | |
953 | Moth->AddNode(Av,2,flip); // RB26 side (Absorber) | |
954 | Moth->AddNode(Iv,1,tran); // RB24 side | |
955 | Moth->AddNode(Iv,2,flip); // RB26 side (Absorber) | |
956 | Gv->AddNode(Hv,1,0); | |
957 | for(i=0;i<Nspoaks;i++){ // SSD Cone Spoaks | |
958 | zspoaks = new TGeoRotation("",0.0,0.0, | |
959 | ((Double_t)i*360.)/((Double_t)Nspoaks)); | |
960 | rottran = new TGeoCombiTrans("",0.0,0.0,-Z0,zspoaks); | |
961 | Moth->AddNode(Gv,i+1,rottran); // RB24 side | |
962 | Av->AddNode(Fv,i+1,zspoaks); | |
963 | Iv->AddNode(Lv,i+1,zspoaks); | |
964 | zspoaks180 = new TGeoRotation("",0.0,180.0, | |
965 | ((Double_t)i*360.)/((Double_t)Nspoaks)); | |
966 | fliptran = new TGeoCombiTrans("",0.0,0.0,Z0,zspoaks180); | |
967 | Moth->AddNode(Gv,Nspoaks+i+1,fliptran); // RB26 side | |
968 | } // end for i | |
969 | Iv->AddNode(Jv,1,0); | |
970 | Iv->AddNode(Kv,1,0); | |
971 | Ov->AddNode(Pv,1,0); | |
972 | //Pv->AddNode(Qv,2,?); // Screw head | |
973 | //Pv->AddNode(Qv,3,?); // Screw head | |
974 | //Pv->AddNode(Vv,1,?); // Air hole in Posts | |
975 | //Pv->AddNode(Vv,2,?); // Air hole in Posts | |
976 | //Mv->AddNode(Wv,1,?); // Air hole in Posts | |
977 | //Mv->AddNode(Wv,2,?); // Air hole in Posts | |
978 | //Nv->AddNode(Xv,1,?); // Air hole in Posts | |
979 | //Nv->AddNode(Xv,2,?); // Air hole in Posts | |
980 | TGeoRotation *zposts,*zposts180; | |
981 | for(i=0;i<Nposts;i++){ // SSD Cone mounting posts | |
982 | zposts = new TGeoRotation("",0.0,0.0, | |
983 | ((Double_t)i*360.)/((Double_t)Nposts)); | |
984 | rottran = new TGeoCombiTrans("",0.0,0.0,-Z0,zposts); | |
985 | Moth->AddNode(Ov,i+1,rottran); // RB24 side | |
986 | Jv->AddNode(Mv,i+1,zposts); | |
987 | Iv->AddNode(Nv,i+1,zposts); | |
988 | //Jv->AddNode(Xv,2*i+3,?); // Air hole in Posts | |
989 | //Jv->AddNode(Xv,2*i+4,?); // Air hole in Posts | |
990 | zposts180 = new TGeoRotation("",0.0,180.0, | |
991 | ((Double_t)i*360.)/((Double_t)Nposts)); | |
992 | fliptran = new TGeoCombiTrans("",0.0,0.0,Z0,zposts180); | |
993 | Moth->AddNode(Ov,Nposts+i+1,fliptran); // RB26 side | |
994 | } // end for i | |
995 | // | |
996 | for(i=0;i<NinScrews;i++){ | |
997 | t = Phi0Screws+360.*((Double_t)i)/((Double_t)NinScrews); | |
998 | t *= TMath::DegToRad(); | |
999 | tran= new TGeoTranslation("",RcylinderScrews*TMath::Cos(t), | |
1000 | RcylinderScrews*TMath::Sin(t),0.0); | |
1001 | Kv->AddNode(Qv,i+4,rottran); | |
1002 | if(/*not where volumes U and T are*/kTRUE){ | |
1003 | tranR = new TGeoTranslation("",RinHole*TMath::Cos(t), | |
1004 | RinHole*TMath::Sin(t), | |
1005 | K->GetZ(2)+R->GetDz()); | |
1006 | tranS = new TGeoTranslation("",RinHole*TMath::Cos(t), | |
1007 | RinHole*TMath::Sin(t), | |
1008 | I->GetZ(4)+S->GetDz()); | |
1009 | Kv->AddNode(Rv,i,tranR); | |
1010 | Iv->AddNode(Sv,i,tranS); | |
1011 | } // end if | |
1012 | } // end for i | |
1013 | Int_t NcD=1,NcE=1,NcR=1,NcS=1; | |
1014 | const Int_t Nbscrew=2,Nbpins=3,Nrailsc=4,Nrailp=2; | |
1015 | Double_t da[] = {-3.5,-1.5,1.5,3.5}; | |
1016 | for(i=0;i<2;i++){ // Mounting for ITS-TPC bracket or ITS-Rails | |
1017 | t0 = TMath::Pi()*((Double_t)i); | |
1018 | for(j=-Nbscrew/2;j<=Nbscrew/2;j++)if(j!=0){//screws per ITS-TPC bracket | |
1019 | t = t0 + 5.0*((Double_t)j)*TMath::DegToRad(); | |
1020 | tran = new TGeoTranslation("",RoutHole*TMath::Cos(t), | |
1021 | RoutHole*TMath::Sin(t), | |
1022 | B->GetZ(0)-D->GetDz()); | |
1023 | Bv->AddNode(Dv,NcD,tran); | |
1024 | if(fDebug) cout << "D: NcD="<<NcD<<endl; | |
1025 | NcD++; | |
1026 | } // end or j | |
1027 | for(j=-Nbpins/2;j<=Nbpins/2;j++){ // pins per ITS-TPC bracket | |
1028 | t = t0 + 3.0*((Double_t)j)*TMath::DegToRad(); | |
1029 | tran = new TGeoTranslation("",RoutHole*TMath::Cos(t), | |
1030 | RoutHole*TMath::Sin(t), | |
1031 | B->GetZ(0)-D->GetDz()); | |
1032 | Bv->AddNode(Ev,NcE,tran); | |
1033 | if(fDebug) cout << "E: NcE="<<NcE<<endl; | |
1034 | NcE++; | |
1035 | } // end or j | |
1036 | t0 = (96.5+187.*((Double_t)i))*TMath::DegToRad(); | |
1037 | for(j=0;j<Nrailsc;j++){ // screws per ITS-rail bracket | |
1038 | t = t0+da[j]*TMath::DegToRad(); | |
1039 | tran = new TGeoTranslation("",RoutHole*TMath::Cos(t), | |
1040 | RoutHole*TMath::Sin(t), | |
1041 | B->GetZ(0)-D->GetDz()); | |
1042 | Bv->AddNode(Dv,NcD,tran); | |
1043 | if(fDebug) cout << "D2: NcD="<<NcD<<endl; | |
1044 | NcD++; | |
1045 | } // end or j | |
1046 | t0 = (91.5+184.*((Double_t)i))*TMath::DegToRad(); | |
1047 | for(j=-Nrailp/2;j<=Nrailp/2;j++)if(j!=0){ // pins per ITS-rail bracket | |
1048 | t = t0+(7.0*((Double_t)j))*TMath::DegToRad(); | |
1049 | tran = new TGeoTranslation("",RoutHole*TMath::Cos(t), | |
1050 | RoutHole*TMath::Sin(t), | |
1051 | B->GetZ(0)-D->GetDz()); | |
1052 | Bv->AddNode(Ev,NcE,tran); | |
1053 | if(fDebug) cout << "E2: NcE="<<NcE<<endl; | |
1054 | NcE++; | |
1055 | } // end or j | |
1056 | } // end for i | |
1057 | for(i=0;i<Nmounts;i++){ // mounting points for SPD-cone+Beam-pipe support | |
1058 | t0 = (45.0+((Double_t)i)*360./((Double_t)Nmounts))*TMath::DegToRad(); | |
1059 | for(j=-1;j<=1;j++)if(j!=0){ // 2 screws per bracket | |
1060 | t = t0+((Double_t)j)*0.5*DmountAngle; | |
1061 | tran = new TGeoTranslation("",RoutHole*TMath::Cos(t), | |
1062 | RoutHole*TMath::Sin(t), | |
1063 | B->GetZ(0)-D->GetDz()); | |
1064 | Bv->AddNode(Dv,NcD,tran); | |
1065 | if(fDebug) cout << "D3: NcD="<<NcD<<endl; | |
1066 | NcD++; | |
1067 | } // end for j | |
1068 | for(j=0;j<1;j++){ // 1 pin per bracket | |
1069 | t = t0; | |
1070 | tran = new TGeoTranslation("",RoutHole*TMath::Cos(t), | |
1071 | RoutHole*TMath::Sin(t), | |
1072 | B->GetZ(0)-D->GetDz()); | |
1073 | Bv->AddNode(Ev,NcE,tran); | |
1074 | if(fDebug) cout << "E3: NcE="<<NcE<<endl; | |
1075 | NcE++; | |
1076 | } // end for j | |
1077 | } // end for i | |
1078 | tran = new TGeoTranslation("",TMath::Cos(T->GetPhi1()+0.5*T->GetDphi()), | |
1079 | TMath::Sin(T->GetPhi1()+0.5*T->GetDphi()), | |
1080 | T->GetZ(T->GetNz()-1)+R->GetDz()); | |
1081 | Tv->AddNode(Rv,NcR++,tran); | |
1082 | tran = new TGeoTranslation("",TMath::Cos(U->GetPhi1()+0.5*U->GetDphi()), | |
1083 | TMath::Sin(U->GetPhi1()+0.5*U->GetDphi()), | |
1084 | U->GetZ(U->GetNz()-1)+S->GetDz()); | |
1085 | Uv->AddNode(Sv,NcS++,tran); | |
1086 | for(i=0;i<NssdSupports;i++){ // mounting braclets for SSD/SDD | |
1087 | t0 = ((Double_t)i*360./((Double_t)NssdSupports)); | |
1088 | rot = new TGeoRotation("",0.0,0.0,t0); | |
1089 | Kv->AddNode(Tv,i+1,rot); | |
1090 | Iv->AddNode(Uv,i+1,rot); | |
1091 | if(fDebug) cout << "T/U: copy number="<<i+1<<endl; | |
1092 | //for(j=0;j<1;j++){ // 1 screws per bracket | |
1093 | // t = t0; | |
1094 | //} // end for j | |
1095 | for(j=0;j<2;j++)if(j!=0){ // 2 pin per bracket | |
1096 | t = t0 + ((Double_t)j)*0.5*DssdsddBracketAngle; | |
1097 | tran = new TGeoTranslation("",RinHole*TMath::Cos(t), | |
1098 | RinHole*TMath::Sin(t), | |
1099 | T->GetZ(T->GetNz()-1)-E->GetDz()); | |
1100 | Kv->AddNode(Ev,NcE++,tran); | |
1101 | } // end for j | |
1102 | } // end for i | |
1103 | } | |
1104 | //______________________________________________________________________ | |
1105 | void AliITSv11::CreateMaterials(){ | |
1106 | // Create ITS materials | |
1107 | // This function defines the default materials used in the Geant | |
1108 | // Monte Carlo simulations for the geometries AliITSv11. | |
1109 | // In general it is automatically replaced by | |
1110 | // Inputs: | |
1111 | // none. | |
1112 | // Outputs: | |
1113 | // none. | |
1114 | // Return | |
1115 | // none. | |
aa9bc63b | 1116 | |
541f7ba6 | 1117 | //TGeoMaterial *C = new TGeoMaterial("ITSCarbon",12.0,6.0,2.265); |
1118 | TGeoMaterial *Al = new TGeoMaterial("ITSAluminum",26.981539,13.0,2.07); | |
1119 | TGeoMixture *Cfiber = new TGeoMixture("ITSCarbonFiber",6,1.930); | |
1120 | TGeoMixture *Rohacell = new TGeoMixture("ITSRohacell",6,1.930); | |
1121 | TGeoMixture *Staselite = new TGeoMixture("ITSStaselite4411w",6,1.930); | |
1122 | TGeoMixture *Air = new TGeoMixture("ITSAir",6,1.205*1.E-3); | |
1123 | TGeoMixture *Stainless = new TGeoMixture("ITSStainless",6,1.930); | |
1124 | // | |
1125 | Double_t SSDcone[20]; | |
1126 | SSDcone[0] = 1.0; // imat | |
1127 | SSDcone[1] = 0.0; // isvol | |
1128 | SSDcone[2] = gAlice->Field()->Integ(); // ifield | |
1129 | SSDcone[3] = gAlice->Field()->Max(); // fieldm | |
1130 | SSDcone[4] = 1.0; // tmaxfd [degrees] | |
1131 | SSDcone[5] = 1.0; // stemax [cm] | |
1132 | SSDcone[6] = 0.5; // deemax [fraction] | |
1133 | SSDcone[7] = 1.0E-3; // epsil [cm] | |
1134 | SSDcone[8] = 0.0; // stmin [cm] | |
1135 | new TGeoMedium("ITSssdCarbonFiber",1,Cfiber,SSDcone); | |
1136 | SSDcone[0] += 1.0; | |
1137 | new TGeoMedium("ITSssdStaselite4411w",2,Staselite,SSDcone); | |
1138 | SSDcone[0] += 1.0; | |
1139 | new TGeoMedium("ITSssdRohacell50A",3,Rohacell,SSDcone); | |
1140 | SSDcone[0] += 1.0; | |
1141 | new TGeoMedium("ITSssdStainlesSteal",4,Stainless,SSDcone); | |
1142 | SSDcone[0] += 1.0; | |
1143 | new TGeoMedium("ITSssdAir",5,Air,SSDcone); | |
1144 | SSDcone[0] += 1.0; | |
1145 | new TGeoMedium("ITSssdAl",6,Al,SSDcone); | |
dfefbaec | 1146 | } |
1147 | //______________________________________________________________________ | |
1148 | void AliITSv11::InitAliITSgeom(){ | |
aa9bc63b | 1149 | // Based on the geometry tree defined in Geant 3.21, this |
162acd47 | 1150 | // routine initilizes the Class AliITSgeom from the Geant 3.21 ITS |
1151 | // geometry sturture. | |
aa9bc63b | 1152 | // Inputs: |
1153 | // none. | |
1154 | // Outputs: | |
1155 | // none. | |
1156 | // Return | |
1157 | // none. | |
dfefbaec | 1158 | } |
dfefbaec | 1159 | //______________________________________________________________________ |
1160 | void AliITSv11::Init(){ | |
aa9bc63b | 1161 | // Initialise the ITS after it has been created. |
1162 | // Inputs: | |
1163 | // none. | |
1164 | // Outputs: | |
1165 | // none. | |
1166 | // Return | |
1167 | // none. | |
dfefbaec | 1168 | } |
1169 | //______________________________________________________________________ | |
1170 | void AliITSv11::SetDefaults(){ | |
162acd47 | 1171 | // Sets the default segmentation, response, digit and raw cluster |
1172 | // classes to be used. These defaults can be overwritten in the | |
1173 | // macros that do these later steps. Defaults are give hear for the | |
1174 | // general user. | |
aa9bc63b | 1175 | // Inputs: |
1176 | // none. | |
1177 | // Outputs: | |
1178 | // none. | |
1179 | // Return | |
1180 | // none. | |
dfefbaec | 1181 | } |
1182 | //______________________________________________________________________ | |
1183 | void AliITSv11::DrawModule(){ | |
162acd47 | 1184 | // Draw a standard set of shaded view of the ITS version 11. |
aa9bc63b | 1185 | // Inputs: |
1186 | // none. | |
1187 | // Outputs: | |
1188 | // none. | |
1189 | // Return | |
1190 | // none. | |
dfefbaec | 1191 | } |
1192 | //______________________________________________________________________ | |
1193 | void AliITSv11::StepManager(){ | |
aa9bc63b | 1194 | // Called for every step in the ITS, then calles the AliITShit class |
dfefbaec | 1195 | // creator with the information to be recoreded about that hit. |
aa9bc63b | 1196 | // The value of the macro ALIITSPRINTGEOM if set to 1 will allow the |
dfefbaec | 1197 | // printing of information to a file which can be used to create a .det |
1198 | // file read in by the routine CreateGeometry(). If set to 0 or any other | |
1199 | // value except 1, the default behavior, then no such file is created nor | |
162acd47 | 1200 | // is the extra variables and the like used in the printing allocated. |
2b680d9b | 1201 | } |
dfefbaec | 1202 |