]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ITS/AliITSv11GeometrySDD.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
New geometry: SDD, cables and update on V11 (L. Gaudichet)
[u/mrichter/AliRoot.git] / ITS / AliITSv11GeometrySDD.cxx
CommitLineData
db486a6e 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
b7943f00 16
db486a6e 17//*************************************************************************
18// SDD geometry, based on ROOT geometrical modeler
19//
b7943f00 20// Ludovic Gaudichet gaudichet@to.infn.it
db486a6e 21//*************************************************************************
22
23
db486a6e 24
25// General Root includes
b7943f00 26//#include <Riostream.h>
db486a6e 27#include <TMath.h>
28
29// Root Geometry includes
30#include <TGeoManager.h>
31#include <TGeoVolume.h>
db486a6e 32#include <TGeoCone.h>
33#include <TGeoTube.h>
34#include <TGeoArb8.h>
35#include <TGeoCompositeShape.h>
36#include <TGeoMatrix.h>
c789ee28 37#include <TGeoNode.h>
db486a6e 38
b7943f00 39#include "AliITSgeom.h"
40#include "AliITSgeomSDD.h"
db486a6e 41#include "AliITSv11GeometrySDD.h"
b7943f00 42#include "AliITSv11GeomCableFlat.h"
43#include "AliITSv11GeomCableRound.h"
44
45
46const char* AliITSv11GeometrySDD::fgSDDsensitiveVolName = "ITSsddSensitiv";
47const Double_t AliITSv11GeometrySDD::fgkSegmentLength = 37.2*2*fgkmm;
48const Double_t AliITSv11GeometrySDD::fgkLadderWidth = 50.0*fgkmm;
49const Double_t AliITSv11GeometrySDD::fgkLadderHeight = 30.0*fgkmm;
50const Double_t AliITSv11GeometrySDD::fgkLadderSegBoxDW = 3.5*fgkmm;
51const Double_t AliITSv11GeometrySDD::fgkLadderSegBoxDH = 3.*fgkmm;
52
53const Double_t AliITSv11GeometrySDD::fgkLadderBeamRadius = 0.6*fgkmm;
54const Double_t AliITSv11GeometrySDD::fgkLadderLa = 3.*fgkmm;
55const Double_t AliITSv11GeometrySDD::fgkLadderHa = 0.6*fgkmm; //total ???
56const Double_t AliITSv11GeometrySDD::fgkLadderLb = 3.7*fgkmm;
57const Double_t AliITSv11GeometrySDD::fgkLadderHb = 0.6*fgkmm; //total ???
58const Double_t AliITSv11GeometrySDD::fgkLadderl = 0.25*fgkmm;
59
60const Double_t AliITSv11GeometrySDD::fgkBottomBeamAngle = 56.5;
61const Double_t AliITSv11GeometrySDD::fgkBeamSidePhi = 65;
62
63const Double_t AliITSv11GeometrySDD::fgkLadWaferSep = 2*fgkmm;
64const Double_t AliITSv11GeometrySDD::fgkPinSuppWidth = 2.5*fgkmm; // ???
65const Double_t AliITSv11GeometrySDD::fgkPinSuppHeight = 2.*fgkmm; // ???
66const Double_t AliITSv11GeometrySDD::fgkPinSuppRmax = 2.5/2.*fgkmm;
67const Double_t AliITSv11GeometrySDD::fgkPinR = 1.5/2.*fgkmm;
68const Double_t AliITSv11GeometrySDD::fgkPinSuppLength = 5.*fgkmm;
69const Double_t AliITSv11GeometrySDD::fgkPinSuppThickness = 0.5*fgkmm;
70const Double_t AliITSv11GeometrySDD::fgkPinSuppConeAngle = 4;
71const Double_t AliITSv11GeometrySDD::fgkPinDXminOnSensor = (39./2.)*fgkmm;
72const Double_t AliITSv11GeometrySDD::fgkPinPinDDXOnSensor = 3*fgkmm;
73const Double_t AliITSv11GeometrySDD::fgkPinDYOnSensor = (52.5/2.)*fgkmm;
db486a6e 74
b7943f00 75// parameters from ALR-0752/3
76const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppHeight = 3.2*fgkmm;
77const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppMaxLength = 14*fgkmm;
78const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppWidthExt = 0.4*fgkmm;
79const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppWidthIn = 0.65*fgkmm;
80const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppHoleDiam = 2*fgkmm;
81const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppFulWidth = 5.15*fgkmm;
82const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppTongW = 0.8*fgkmm;
83const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppAngle = 22.5;
84const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppSlitL = 4.9*fgkmm;
85const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppAxeDist = 3.05*fgkmm;
86const Double_t AliITSv11GeometrySDD::fgkCoolPipeInnerDiam = 1.84*fgkmm;
87const Double_t AliITSv11GeometrySDD::fgkCoolPipeOuterDiam = 2.*fgkmm;
88
89const Double_t AliITSv11GeometrySDD::fgkBTBthick = 0.25 *fgkmm;
90const Double_t AliITSv11GeometrySDD::fgkBTBlength = 55. *fgkmm;
91const Double_t AliITSv11GeometrySDD::fgkBTBwidth = 18*fgkmm;
92const Double_t AliITSv11GeometrySDD::fgkBTBaxisAtoBottom = 4*fgkmm;
93const Double_t AliITSv11GeometrySDD::fgkBTBaxisAtoBase = 1.2*fgkmm;
94const Double_t AliITSv11GeometrySDD::fgkRadiusAminBTB = 1. *fgkmm;
95const Double_t AliITSv11GeometrySDD::fgkRadiusBminBTB = 0.53 *fgkmm;
96const Double_t AliITSv11GeometrySDD::fgkBTBHoleLength = 15 *fgkmm;
97const Double_t AliITSv11GeometrySDD::fgkBTBHolewidth = 6 *fgkmm;
98const Double_t AliITSv11GeometrySDD::fgkBTBHoleRefX = 10 *fgkmm;
99const Double_t AliITSv11GeometrySDD::fgkBTBHoleRefY = 6.5 *fgkmm;
100
101const Double_t AliITSv11GeometrySDD::fgkLay3Rmin = 145.*fgkmm; // not min! Rmin virtual tube
102const Double_t AliITSv11GeometrySDD::fgkLay3Rmax = 205.*fgkmm; // not min! Rmax virtual tube
103const Double_t AliITSv11GeometrySDD::fgkLay3Length = (524.+0.)*fgkmm; // ladder+supporting rings (length of the virtual tube)
104const Double_t AliITSv11GeometrySDD::fgkLay3LadderLength = 524.*fgkmm;
105const Double_t AliITSv11GeometrySDD::fgkLay3DetShortRadius = 146.0*fgkmm;
106const Double_t AliITSv11GeometrySDD::fgkLay3DetLongRadius = 152.0*fgkmm;
107const Double_t AliITSv11GeometrySDD::fgkLay3LaddTopCornerEnd = 15.6*fgkmm;
108const Int_t AliITSv11GeometrySDD::fgkLay3Ndet = 6;
109const Int_t AliITSv11GeometrySDD::fgkLay3Nladd = 14;
110const Double_t AliITSv11GeometrySDD::fgkLay3CoolPipeSuppH = 7.5*fgkmm;
111
112const Double_t AliITSv11GeometrySDD::fgkLay4Rmin = 220.*fgkmm; // not min! Rmin virtual tube
113const Double_t AliITSv11GeometrySDD::fgkLay4Rmax = 290.*fgkmm; // not min! Rmax virtual tube
114const Double_t AliITSv11GeometrySDD::fgkLay4Length = (671.+0.)*fgkmm; // ladder+supporting rings (length of the virtual tube)
115const Double_t AliITSv11GeometrySDD::fgkLay4LadderLength = 671.*fgkmm;
116const Double_t AliITSv11GeometrySDD::fgkLay4DetShortRadius = 235.0*fgkmm;
117const Double_t AliITSv11GeometrySDD::fgkLay4DetLongRadius = 240.5*fgkmm;
118const Double_t AliITSv11GeometrySDD::fgkLay4LaddTopCornerEnd = 15.6*fgkmm;
119const Int_t AliITSv11GeometrySDD::fgkLay4Ndet = 8;
120const Int_t AliITSv11GeometrySDD::fgkLay4Nladd = 22;
121const Double_t AliITSv11GeometrySDD::fgkLay4CoolPipeSuppH = 7.5*fgkmm;
122
123//hybrid
124const Double_t AliITSv11GeometrySDD::fgkHybridAngle = 46; // approx !!!
125// Origine taken at the hybrid corner :
126const Double_t AliITSv11GeometrySDD::fgkHybridLength = 65*fgkmm;
127const Double_t AliITSv11GeometrySDD::fgkHybridWidth = 41*fgkmm;
128const Double_t AliITSv11GeometrySDD::fgkHybRndHoleRad = 1.05*fgkmm;
129const Double_t AliITSv11GeometrySDD::fgkHybRndHoleZ = 2.5*fgkmm;
130const Double_t AliITSv11GeometrySDD::fgkHybRndHoleX = fgkHybridWidth-23.599*fgkmm;
131
132const Double_t AliITSv11GeometrySDD::fgkHybFLlowHoleDZ = 9.698*fgkmm;
133const Double_t AliITSv11GeometrySDD::fgkHybFLlowHolePasDX = 10.754*fgkmm;
134const Double_t AliITSv11GeometrySDD::fgkHybFLlowHoleAmbDX = 9.122*fgkmm;
135 // center of ships to the border
136const Double_t AliITSv11GeometrySDD::fgkHybFLlowChipZ4 = fgkHybridLength-(4.654 )*fgkmm-fgkHybFLlowHoleDZ/2;
137const Double_t AliITSv11GeometrySDD::fgkHybFLlowChipZ3 = fgkHybridLength-(4.654+15. )*fgkmm-fgkHybFLlowHoleDZ/2;
138const Double_t AliITSv11GeometrySDD::fgkHybFLlowChipZ2 = fgkHybridLength-(4.654+15.*2)*fgkmm-fgkHybFLlowHoleDZ/2;
139const Double_t AliITSv11GeometrySDD::fgkHybFLlowChipZ1 = fgkHybridLength-(4.654+15.*3)*fgkmm-fgkHybFLlowHoleDZ/2;
140const Double_t AliITSv11GeometrySDD::fgkHybFLlowPasX = fgkHybridWidth-32.775*fgkmm;
141const Double_t AliITSv11GeometrySDD::fgkHybFLlowAmbX = fgkHybridWidth-20.791*fgkmm;
142const Double_t AliITSv11GeometrySDD::fgkHybChipsDZ = 9.221*fgkmm;
143const Double_t AliITSv11GeometrySDD::fgkHybPascalDX = 10.245*fgkmm;
144const Double_t AliITSv11GeometrySDD::fgkHybAmbraDX = 8.51*fgkmm;
145const Double_t AliITSv11GeometrySDD::fgkHybFLUpperWidth = 15.012*fgkmm;
146const Double_t AliITSv11GeometrySDD::fgkHybFLUpperLength = 59.878*fgkmm;
147const Double_t AliITSv11GeometrySDD::fgkHybFLUpperAlDZ = 11.183*fgkmm;
148const Double_t AliITSv11GeometrySDD::fgkHybFLUpperAldx = 2.307*fgkmm;
149const Double_t AliITSv11GeometrySDD::fgkmu = 1*fgkmicron; // can be increase for checking thin objects
150const Double_t AliITSv11GeometrySDD::fgkHybridThBridgeThick = 0.25*fgkmm; // ???
151const Double_t AliITSv11GeometrySDD::fgkHybAlThick = 30*fgkmu;
152const Double_t AliITSv11GeometrySDD::fgkHybUpThick = 20*fgkmu;
153const Double_t AliITSv11GeometrySDD::fgkHybGlueScrnThick = 50*fgkmu; // ??? ?????
154const Double_t AliITSv11GeometrySDD::fgkHybGlueLowThick = 90*fgkmu;
155const Double_t AliITSv11GeometrySDD::fgkHybGlueUpThick = 90*fgkmu; // sur ?????
156const Double_t AliITSv11GeometrySDD::fgkHybAlCCThick = 12*fgkmu;
157const Double_t AliITSv11GeometrySDD::fgkHybUpCCThick = 12*fgkmu;
158const Double_t AliITSv11GeometrySDD::fgkHybChipThick = 150*fgkmu;
159const Double_t AliITSv11GeometrySDD::fgkHybGlueAgThick = 50*fgkmu; // ??? ????
160const Double_t AliITSv11GeometrySDD::fgkHybUnderNiThick = 20*fgkmu; // ??? ????
161const Int_t AliITSv11GeometrySDD::fgkNHybSMD = 25;
162const Double_t AliITSv11GeometrySDD::fgkHybSMDposX[fgkNHybSMD] =
163 {2.92*fgkmm,6.5*fgkmm,10.13*fgkmm,13.59*fgkmm,21.40*fgkmm,
164 2.92*fgkmm,6.5*fgkmm,10.13*fgkmm,13.59*fgkmm,19.91*fgkmm,
165 2.92*fgkmm,6.5*fgkmm,10.13*fgkmm,13.59*fgkmm,17.09*fgkmm,21.40*fgkmm,
166 2.92*fgkmm,6.5*fgkmm,10.13*fgkmm,13.59*fgkmm,19.91*fgkmm,
167 1.63*fgkmm,5.22*fgkmm,13.59*fgkmm,21.40*fgkmm};
168const Double_t AliITSv11GeometrySDD::fgkHybSMDposZ[fgkNHybSMD] =
169 { 2.3 *fgkmm, 2.3 *fgkmm, 2.3 *fgkmm, 2.3 *fgkmm, 2.3 *fgkmm,
170 17.315*fgkmm,17.315*fgkmm,17.315*fgkmm,17.315*fgkmm,17.315*fgkmm,
171 32.31*fgkmm,32.31*fgkmm,32.31*fgkmm,32.31*fgkmm,32.31*fgkmm,32.31*fgkmm,
172 47.38*fgkmm,47.38*fgkmm,47.38*fgkmm,47.38*fgkmm,47.38*fgkmm,
173 62.68*fgkmm,62.06*fgkmm,62.06*fgkmm,62.06*fgkmm};
174const Double_t AliITSv11GeometrySDD::fgkHybSMDmiddleW = 0.954*fgkmm;
175const Double_t AliITSv11GeometrySDD::fgkHybSMDmiddleL = 0.47 *fgkmm;
176const Double_t AliITSv11GeometrySDD::fgkHybSMDendW = 1.132*fgkmm;
177const Double_t AliITSv11GeometrySDD::fgkHybSMDendL = 0.925*fgkmm;
178const Double_t AliITSv11GeometrySDD::fgkHybSMDheight = 400.*fgkmu; // ??? ????!!!!!!!
179
180const Double_t AliITSv11GeometrySDD::fgkWaferThickness = 300.*fgkmu;
181const Double_t AliITSv11GeometrySDD::fgkWaferWidth = 72.5 *fgkmm;
182const Double_t AliITSv11GeometrySDD::fgkWaferLength = 87.6 *fgkmm;
183const Double_t AliITSv11GeometrySDD::fgkWaferThickSens = 299.8*fgkmu;
184const Double_t AliITSv11GeometrySDD::fgkWaferWidthSens = 70.17*fgkmm;
185const Double_t AliITSv11GeometrySDD::fgkWaferLengthSens = 74.97*fgkmm;
186
187const Double_t AliITSv11GeometrySDD::fgkDigitCablWidth = 18.4*fgkmm;
188const Double_t AliITSv11GeometrySDD::fgkDigitCablAlThick = (30+30*8./10.)*fgkmicron; // will probably change
189const Double_t AliITSv11GeometrySDD::fgkDigitCablPolyThick = (20+12)*fgkmicron; // will probably change
190
191const Double_t AliITSv11GeometrySDD::fgkWaHVcableAlThick = 30*2./10.*fgkmu; // will probably change // Al ratio is random !!!
192const Double_t AliITSv11GeometrySDD::fgkWaHVcablePolyThick = 175*fgkmu; // will probably change
193const Double_t AliITSv11GeometrySDD::fgkWaHVcableLength = 67.08*fgkmm;
194const Double_t AliITSv11GeometrySDD::fgkWaHVcableWitdh = 17.4 *fgkmm; // check !!!
195const Double_t AliITSv11GeometrySDD::fgkWaHVcableDW = 5.24*fgkmm; // check !!!
196
197const Double_t AliITSv11GeometrySDD::fgkSensorGlassLX = 5. *fgkmm;
198const Double_t AliITSv11GeometrySDD::fgkSensorGlassLZ = 5. *fgkmm;
199const Double_t AliITSv11GeometrySDD::fgkSensorGlassLY = 150. *fgkmu;
200const Double_t AliITSv11GeometrySDD::fgkGlassDXOnSensor = 26.28*fgkmm; // check !!!
201const Double_t AliITSv11GeometrySDD::fgkGlassDZOnSensor = 22.50*fgkmm; // check !!!
202
203const Double_t AliITSv11GeometrySDD::fgkTransitHVAlThick = 30*2./10.*fgkmu; // check // will probably change //Al ratio is random
204const Double_t AliITSv11GeometrySDD::fgkTransitHVPolyThick = 100*fgkmu; // check // will probably change
205const Double_t AliITSv11GeometrySDD::fgkTransitHVHeadLX = 71.46*fgkmm; // check !!!
206const Double_t AliITSv11GeometrySDD::fgkTransitHVHeadLZ = 21.3*fgkmm;
207const Double_t AliITSv11GeometrySDD::fgkTransitHVBondingLZ = 3.6*fgkmm;
208const Double_t AliITSv11GeometrySDD::fgkTransitHVtailLength = 27*fgkmm; // ???, not yet fixed ...
209const Double_t AliITSv11GeometrySDD::fgkTransitHVtailWidth = 26*fgkmm;
210const Double_t AliITSv11GeometrySDD::fgkTransitHVtailXpos = 8*fgkmm; // ???, a mesurer !!!
211const Double_t AliITSv11GeometrySDD::fgkTransitHVsideLZ = 10.34*fgkmm;
212const Double_t AliITSv11GeometrySDD::fgkTransitHVsideLeftZ = 4.11*fgkmm;
213const Double_t AliITSv11GeometrySDD::fgkTransitHVsideRightZ = 3.5*fgkmm; // ???, a mesurer !!!
214
215const Double_t AliITSv11GeometrySDD::fgkLongHVcablePolyThick= (20+30+125+30+20+30+125+30+20)*fgkmu; // check // will probably change
216const Double_t AliITSv11GeometrySDD::fgkLongHVcableAlThick = (30+30*2/10+30)*fgkmu; // check // will probably change
217const Double_t AliITSv11GeometrySDD::fgkLongHVcableSeparation = 600*fgkmicron;
c789ee28 218
c789ee28 219
b7943f00 220ClassImp(AliITSv11GeometrySDD)
c789ee28 221
b7943f00 222//________________________________________________________________________
223 AliITSv11GeometrySDD::AliITSv11GeometrySDD():
224 AliITSv11Geometry(), fMotherVol(0), fAddHybrids(kTRUE), fAddSensors(kTRUE),
225 fAddHVcables(kTRUE), fAddCables(kTRUE), fAddCoolingSyst(kTRUE),
226 fCoolingOn(kTRUE),
227 fAddOnlyLadder3min(-1), fAddOnlyLadder3max(-1),
228 fAddOnlyLadder4min(-1), fAddOnlyLadder4max(-1)
c789ee28 229{
b7943f00 230 //
231 // Standard constructor
232 //
233
234 fDigitCableLay3A = new AliITSv11GeomCableFlat[fgkLay3Ndet];
235 fDigitCableLay3B = new AliITSv11GeomCableFlat[fgkLay3Ndet];
236 fDigitCableLay4A = new AliITSv11GeomCableFlat[fgkLay4Ndet];
237 fDigitCableLay4B = new AliITSv11GeomCableFlat[fgkLay4Ndet];
238 SetParameters();
c789ee28 239};
240
241
b7943f00 242//________________________________________________________________________
243AliITSv11GeometrySDD::AliITSv11GeometrySDD(Int_t debug) :
244 AliITSv11Geometry(debug),fMotherVol(0),fAddHybrids(kTRUE),fAddSensors(kTRUE),
245 fAddHVcables(kTRUE), fAddCables(kTRUE), fAddCoolingSyst(kTRUE),
246 fCoolingOn(kTRUE),
247 fAddOnlyLadder3min(-1), fAddOnlyLadder3max(-1),
248 fAddOnlyLadder4min(-1), fAddOnlyLadder4max(-1)
c789ee28 249{
b7943f00 250 //
251 // Constructor setting debugging level
252 //
253
254 fDigitCableLay3A = new AliITSv11GeomCableFlat[fgkLay3Ndet];
255 fDigitCableLay3B = new AliITSv11GeomCableFlat[fgkLay3Ndet];
256 fDigitCableLay4A = new AliITSv11GeomCableFlat[fgkLay4Ndet];
257 fDigitCableLay4B = new AliITSv11GeomCableFlat[fgkLay4Ndet];
258 SetParameters();
c789ee28 259};
260
c789ee28 261//________________________________________________________________________
b7943f00 262AliITSv11GeometrySDD::AliITSv11GeometrySDD(const AliITSv11GeometrySDD &s) :
263 AliITSv11Geometry(s.GetDebug()),fMotherVol(s.fMotherVol),
264 fAddHybrids(s.fAddHybrids),fAddSensors(s.fAddSensors),
265 fAddHVcables(s.fAddHVcables), fAddCables(s.fAddCables),
266 fAddCoolingSyst(s.fAddCoolingSyst),fCoolingOn(s.fCoolingOn),
267 fAddOnlyLadder3min(s.fAddOnlyLadder3min),fAddOnlyLadder3max(s.fAddOnlyLadder3max),
268 fAddOnlyLadder4min(s.fAddOnlyLadder4min), fAddOnlyLadder4max(s.fAddOnlyLadder4max)
269{
270 // Copy Constructor
271 fDigitCableLay3A = new AliITSv11GeomCableFlat[fgkLay3Ndet];
272 fDigitCableLay3B = new AliITSv11GeomCableFlat[fgkLay3Ndet];
273 fDigitCableLay4A = new AliITSv11GeomCableFlat[fgkLay4Ndet];
274 fDigitCableLay4B = new AliITSv11GeomCableFlat[fgkLay4Ndet];
275 SetParameters();
276}
c789ee28 277
b7943f00 278//________________________________________________________________________
279AliITSv11GeometrySDD& AliITSv11GeometrySDD::
280operator=(const AliITSv11GeometrySDD &s) {
281 // Assignment operator
282 if(&s == this) return *this;
283 fMotherVol = s.fMotherVol;
284 fAddHybrids = s.fAddHybrids;
285 fAddSensors = s.fAddSensors;
286 fAddHVcables = s.fAddHVcables;
287 fAddCables = s.fAddCables;
288 fAddCoolingSyst = s.fAddCoolingSyst;
289 fCoolingOn = s.fCoolingOn;
290 fAddOnlyLadder3min = s.fAddOnlyLadder3min;
291 fAddOnlyLadder3max = s.fAddOnlyLadder3max;
292 fAddOnlyLadder4min = s.fAddOnlyLadder4min;
293 fAddOnlyLadder4max = s.fAddOnlyLadder4max;
294 return *this;
295}
db486a6e 296
c789ee28 297//________________________________________________________________________
b7943f00 298AliITSv11GeometrySDD::~AliITSv11GeometrySDD() {
299 // Look like a destructor
300 // Smell like a destructor
301 // And actually is the destructor
302 if (fDigitCableLay3A) delete [] fDigitCableLay3A;
303 if (fDigitCableLay3B) delete [] fDigitCableLay3B;
304 if (fDigitCableLay4A) delete [] fDigitCableLay4A;
305 if (fDigitCableLay4B) delete [] fDigitCableLay4B;
db486a6e 306};
c789ee28 307
c789ee28 308//________________________________________________________________________
b7943f00 309void AliITSv11GeometrySDD::SetParameters() {
310 //
311 // Define display colors and the non constant geometry parameters
312 //
313
c789ee28 314 fColorCarbonFiber = 4;
315 fColorRyton = 5;
316 fColorPhynox = 7;
317 fColorSilicon = 3;
b7943f00 318 fColorAl = 7;
319 fColorPolyhamide = 5;
320 fColorGlass = 2;
321 fColorSMD = 12;
322 fColorSMDweld = 17;
323
324 fPinSupport = 0;
325 fCoolPipeSupportL = 0;
326 fCoolPipeSupportR = 0;
327 fSDDsensor = 0;
328 fBaseThermalBridge = 0;
329 fHybrid = 0;
330
331 Double_t detLadderDist = 8*fgkmm;
332
333 fLay3LadderUnderSegDH = detLadderDist - (fgkWaHVcableAlThick+fgkWaHVcablePolyThick);
334 fLay4LadderUnderSegDH = detLadderDist - (fgkWaHVcableAlThick+fgkWaHVcablePolyThick);
335
336 // radius from the center to the CF ladder :
337 fLay3LaddShortRadius = (fgkLay3DetShortRadius
338 + fgkLadWaferSep+2*fgkWaferThickness
339 + detLadderDist);
340 fLay3LaddLongRadius = (fgkLay3DetLongRadius
341 + fgkLadWaferSep+2*fgkWaferThickness
342 + detLadderDist);
343 fLay4LaddShortRadius = (fgkLay4DetShortRadius
344 + fgkLadWaferSep+2*fgkWaferThickness
345 + detLadderDist);
346 fLay4LaddLongRadius = (fgkLay4DetLongRadius
347 + fgkLadWaferSep+2*fgkWaferThickness
348 + detLadderDist);
c789ee28 349
350 fLay3sensorZPos[0]= ( 35.8+72.4+75.8 )*fgkmm;
351 fLay3sensorZPos[1]= ( 35.8+72.4 )*fgkmm;
352 fLay3sensorZPos[2]= ( 35.8 )*fgkmm;
353 fLay3sensorZPos[3]= ( -37.9 )*fgkmm;
354 fLay3sensorZPos[4]= ( -37.9-74.9 )*fgkmm;
355 fLay3sensorZPos[5]= ( -37.9-74.9-71.1 )*fgkmm;
356
357 fLay4sensorZPos[0] = ( 38.5+73.2+75.4+71.6 )*fgkmm;
358 fLay4sensorZPos[1] = ( 38.5+73.2+75.4 )*fgkmm;
359 fLay4sensorZPos[2] = ( 38.5+73.2 )*fgkmm;
360 fLay4sensorZPos[3] = ( 38.5 )*fgkmm;
361 fLay4sensorZPos[4] = ( -35.6 )*fgkmm;
362 fLay4sensorZPos[5] = ( -35.6-74.8 )*fgkmm;
363 fLay4sensorZPos[6] = ( -35.6-74.8-72.4 )*fgkmm;
364 fLay4sensorZPos[7] = ( -35.6-74.8-72.4-76. )*fgkmm;
db486a6e 365};
c789ee28 366
367
368//________________________________________________________________________
b7943f00 369TGeoMedium* AliITSv11GeometrySDD::GetMedium(const char* mediumName) {
370 //
371 // Called to get a medium, checks that it exists.
372 // If not, prints an error and returns 0
373 //
c789ee28 374
b7943f00 375 TGeoMedium* medium = gGeoManager->GetMedium(mediumName);
376 if (! medium)
377 printf("Error(AliITSv11GeometrySDD)::medium %s not found !\n", mediumName);
c789ee28 378
b7943f00 379 return medium;
380};
c789ee28 381
b7943f00 382//________________________________________________________________________
383void AliITSv11GeometrySDD::CreateBasicObjects() {
384 //
385 // Create basics objets which will be assembled together
386 // in Layer3 and Layer4 functions
387 //
388
389 fPinSupport = CreatePinSupport();
390 fCoolPipeSupportL = CreateCoolPipeSupportL();
391 fCoolPipeSupportR = CreateCoolPipeSupportR();
392 fSDDsensor = CreateSDDsensor();
393 fBaseThermalBridge = CreateBaseThermalBridge();
394 fHybrid = CreateHybrid(0);
395
396 TGeoMedium *carbonFiberLadderStruct = GetMedium("ITSsddCarbonM55J");
397 TGeoMedium *polyhamideSDD = GetMedium("ITSsddKAPTON_POLYCH2");
398 TGeoMedium *alSDD = GetMedium("ITSal");
399
400 //********************************************************************
401 // pieces of the carbon fiber structure
402 //********************************************************************
403 Double_t dy = fgkLadderSegBoxDH/2;
404 Double_t triangleHeight = fgkLadderHeight - fgkLadderBeamRadius;
405 Double_t halfTheta = TMath::ATan( 0.5*fgkLadderWidth/triangleHeight );
406 Double_t alpha = TMath::Pi()*3./4. - halfTheta/2.;
407 Double_t beta = (TMath::Pi() - 2.*halfTheta)/4.;
408 Double_t dYTranslation = (fgkLadderHeight/2.
409 -0.5*fgkLadderWidth*TMath::Tan(beta)
410 -fgkLadderBeamRadius);
411 Double_t distCenterSideDown = 0.5*fgkLadderWidth/TMath::Cos(beta);
412
413 //--- the top V of the Carbon Fiber Ladder (segment)
414 TGeoArb8 *cfLaddTop1 = CreateLadderSide( fgkSegmentLength/2., halfTheta,
415 -1, fgkLadderLa, fgkLadderHa, fgkLadderl);
416 TGeoVolume *cfLaddTopVol1 = new TGeoVolume("ITSsddCFladdTopCornerVol1",
417 cfLaddTop1,carbonFiberLadderStruct);
418 TGeoArb8 *cfLaddTop2 = CreateLadderSide( fgkSegmentLength/2., halfTheta,
419 1, fgkLadderLa, fgkLadderHa, fgkLadderl);
420 TGeoVolume *cfLaddTopVol2 = new TGeoVolume("ITSsddCFladdTopCornerVol2",
421 cfLaddTop2, carbonFiberLadderStruct);
422 cfLaddTopVol1->SetLineColor(fColorCarbonFiber);
423 cfLaddTopVol2->SetLineColor(fColorCarbonFiber);
424 TGeoTranslation *trTop1 = new TGeoTranslation(0, fgkLadderHeight/2-dy, 0);
425
426 //--- the 2 side V
427 TGeoArb8 *cfLaddSide1 = CreateLadderSide( fgkSegmentLength/2., beta, -1,
428 fgkLadderLb, fgkLadderHb, fgkLadderl);
429 TGeoVolume *cfLaddSideVol1 = new TGeoVolume( "ITSsddCFladdSideCornerVol1",
430 cfLaddSide1,carbonFiberLadderStruct);
431 TGeoArb8 *cfLaddSide2 = CreateLadderSide( fgkSegmentLength/2., beta, 1,
432 fgkLadderLb, fgkLadderHb, fgkLadderl);
433 TGeoVolume *cfLaddSideVol2 = new TGeoVolume( "ITSsddCFladdSideCornerVol2",
434 cfLaddSide2,carbonFiberLadderStruct);
435 cfLaddSideVol1->SetLineColor(fColorCarbonFiber);
436 cfLaddSideVol2->SetLineColor(fColorCarbonFiber);
437 TGeoCombiTrans *ctSideR = CreateCombiTrans("", distCenterSideDown, 0,
438 alpha*TMath::RadToDeg());
439 AddTranslationToCombiTrans(ctSideR, 0, -dYTranslation-dy, 0);
440 TGeoCombiTrans *ctSideL = CreateCombiTrans("", distCenterSideDown,0,
441 -alpha*TMath::RadToDeg());
442 AddTranslationToCombiTrans(ctSideL, 0, -dYTranslation-dy, 0);
443
444 //--- The beams
445 // Beams on the sides
446 Double_t beamPhiPrime = TMath::ASin(1./TMath::Sqrt( (1+TMath::Sin(2*beta)*
447 TMath::Sin(2*beta)/(TanD(fgkBeamSidePhi)*TanD(fgkBeamSidePhi))) ));
448 //cout<<"Phi prime = "<<beamPhiPrime*TMath::RadToDeg()<<endl;
449 Double_t beamLength = TMath::Sqrt( fgkLadderHeight*fgkLadderHeight/
450 ( TMath::Sin(beamPhiPrime)*TMath::Sin(beamPhiPrime))
451 + fgkLadderWidth*fgkLadderWidth/4.)-fgkLadderLa/2-fgkLadderLb/2;
452 TGeoTubeSeg *sideBeamS = new TGeoTubeSeg(0, fgkLadderBeamRadius,beamLength/2.,
453 0, 180);
454 TGeoVolume *sideBeam = new TGeoVolume("ITSsddCFSideBeamVol", sideBeamS,
455 carbonFiberLadderStruct);
456 sideBeam->SetLineColor(fColorCarbonFiber);
457
458 //Euler rotation : about Z, then new X, then new Z
459 TGeoRotation beamRot1("", 90-2.*beta*TMath::RadToDeg(),
460 -beamPhiPrime*TMath::RadToDeg(),-90);
461 TGeoRotation beamRot2("", 90-2.*beta*TMath::RadToDeg(),
462 beamPhiPrime*TMath::RadToDeg(), -90);
463 TGeoRotation beamRot3("", 90+2.*beta*TMath::RadToDeg(),
464 beamPhiPrime*TMath::RadToDeg(), -90);
465 TGeoRotation beamRot4("", 90+2.*beta*TMath::RadToDeg(),
466 -beamPhiPrime*TMath::RadToDeg(),-90);
467
468 TGeoCombiTrans *beamTransf[8];
469 beamTransf[0] = new TGeoCombiTrans( 0.5*triangleHeight*
470 TMath::Tan(halfTheta),
471 fgkLadderBeamRadius/2. - dy,
472 -3*fgkSegmentLength/8, &beamRot1);
473 beamTransf[1] = new TGeoCombiTrans(*beamTransf[0]);
474 AddTranslationToCombiTrans(beamTransf[1], 0, 0, fgkSegmentLength/2);
475
476 beamTransf[2] = new TGeoCombiTrans(0.5*triangleHeight*
477 TMath::Tan(halfTheta),
478 fgkLadderBeamRadius/2. - dy,
479 -fgkSegmentLength/8, &beamRot2);
480 beamTransf[3] = new TGeoCombiTrans(*beamTransf[2]);
481 AddTranslationToCombiTrans(beamTransf[3], 0, 0, fgkSegmentLength/2);
482
483 beamTransf[4] = new TGeoCombiTrans(-0.5*triangleHeight*
484 TMath::Tan(halfTheta),
485 fgkLadderBeamRadius/2. - dy,
486 -3*fgkSegmentLength/8, &beamRot3);
487 beamTransf[5] = new TGeoCombiTrans(*beamTransf[4]);
488 AddTranslationToCombiTrans(beamTransf[5], 0, 0, fgkSegmentLength/2);
489
490 beamTransf[6] = new TGeoCombiTrans(-0.5*triangleHeight*
491 TMath::Tan(halfTheta),fgkLadderBeamRadius/2.-dy, -fgkSegmentLength/8,&beamRot4);
492 beamTransf[7] = new TGeoCombiTrans(-0.5*triangleHeight*
493 TMath::Tan(halfTheta),fgkLadderBeamRadius/2.-dy,3*fgkSegmentLength/8,&beamRot4);
494
495 //--- Beams of the bottom
496 TGeoTubeSeg *bottomBeam1 = new TGeoTubeSeg(0, fgkLadderBeamRadius,
497 fgkLadderWidth/2.-fgkLadderLb/3, 0, 180);
498 TGeoVolume *bottomBeam1Vol = new TGeoVolume("ITSsddBottomBeam1Vol",
499 bottomBeam1, carbonFiberLadderStruct);
500 bottomBeam1Vol->SetLineColor(fColorCarbonFiber);
501 TGeoTubeSeg *bottomBeam2 = new TGeoTubeSeg(0, fgkLadderBeamRadius,
502 fgkLadderWidth/2.-fgkLadderLb/3, 0, 90);
503 TGeoVolume *bottomBeam2Vol = new TGeoVolume("ITSsddBottomBeam2Vol",
504 bottomBeam2, carbonFiberLadderStruct);
505 bottomBeam2Vol->SetLineColor(fColorCarbonFiber);
506 TGeoTubeSeg *bottomBeam3 = new TGeoTubeSeg(0, fgkLadderBeamRadius,
507 0.5*fgkLadderWidth/SinD(fgkBottomBeamAngle)
508 - fgkLadderLb/3, 0, 180);
509 TGeoVolume *bottomBeam3Vol = new TGeoVolume("ITSsddBottomBeam3Vol",
510 bottomBeam3, carbonFiberLadderStruct);
511 bottomBeam3Vol->SetLineColor(fColorCarbonFiber);
512 //bottomBeam3Vol->SetLineColor(2);
513
514 TGeoRotation bottomBeamRot1("", 90, 90, 90);
515 TGeoRotation bottomBeamRot2("",-90, 90, -90);
516 TGeoCombiTrans *bottomBeamTransf1 = new TGeoCombiTrans
517 (0,-(fgkLadderHeight/2-fgkLadderBeamRadius)-dy,0, &bottomBeamRot1);
518 TGeoCombiTrans *bottomBeamTransf2 = new TGeoCombiTrans(0,
519 -(fgkLadderHeight/2-fgkLadderBeamRadius)-dy,
520 -fgkSegmentLength/2, &bottomBeamRot1);
521 TGeoCombiTrans *bottomBeamTransf3 = new TGeoCombiTrans(0,
522 -(fgkLadderHeight/2 - fgkLadderBeamRadius)
523 - dy, fgkSegmentLength/2, &bottomBeamRot2);
524 // be careful for beams #3: when "reading" from -z to +z and
525 // from the bottom of the ladder, it should draw a Lambda, and not a V
526 TGeoRotation bottomBeamRot4("", -90, fgkBottomBeamAngle, -90);
527 TGeoRotation bottomBeamRot5("" ,-90,-fgkBottomBeamAngle, -90);
528 TGeoCombiTrans *bottomBeamTransf4 = new TGeoCombiTrans
529 (0,-(fgkLadderHeight/2-fgkLadderBeamRadius)-dy,-fgkSegmentLength/4,&bottomBeamRot4);
530 TGeoCombiTrans *bottomBeamTransf5 = new TGeoCombiTrans
531 (0,-(fgkLadderHeight/2-fgkLadderBeamRadius)-dy,fgkSegmentLength/4, &bottomBeamRot5);
532
533 fLaddSegCommonVol[0] = cfLaddTopVol1; fLaddSegCommonTr[0] = trTop1;
534 fLaddSegCommonVol[1] = cfLaddTopVol2; fLaddSegCommonTr[1] = trTop1;
535 fLaddSegCommonVol[2] = cfLaddSideVol1; fLaddSegCommonTr[2] = ctSideR;
536 fLaddSegCommonVol[3] = cfLaddSideVol1; fLaddSegCommonTr[3] = ctSideL;
537 fLaddSegCommonVol[4] = cfLaddSideVol2; fLaddSegCommonTr[4] = ctSideR;
538 fLaddSegCommonVol[5] = cfLaddSideVol2; fLaddSegCommonTr[5] = ctSideL;
539 fLaddSegCommonVol[6] = sideBeam; fLaddSegCommonTr[6] = beamTransf[0];
540 fLaddSegCommonVol[7] = sideBeam; fLaddSegCommonTr[7] = beamTransf[1];
541 fLaddSegCommonVol[8] = sideBeam; fLaddSegCommonTr[8] = beamTransf[2];
542 fLaddSegCommonVol[9] = sideBeam; fLaddSegCommonTr[9] = beamTransf[3];
543 fLaddSegCommonVol[10]= sideBeam; fLaddSegCommonTr[10]= beamTransf[4];
544 fLaddSegCommonVol[11]= sideBeam; fLaddSegCommonTr[11]= beamTransf[5];
545 fLaddSegCommonVol[12]= sideBeam; fLaddSegCommonTr[12]= beamTransf[6];
546 fLaddSegCommonVol[13]= sideBeam; fLaddSegCommonTr[13]= beamTransf[7];
547 fLaddSegCommonVol[14]= bottomBeam1Vol; fLaddSegCommonTr[14]= bottomBeamTransf1;
548 fLaddSegCommonVol[15]= bottomBeam2Vol; fLaddSegCommonTr[15]= bottomBeamTransf2;
549 fLaddSegCommonVol[16]= bottomBeam2Vol; fLaddSegCommonTr[16]= bottomBeamTransf3;
550 fLaddSegCommonVol[17]= bottomBeam3Vol; fLaddSegCommonTr[17]= bottomBeamTransf4;
551 fLaddSegCommonVol[18]= bottomBeam3Vol; fLaddSegCommonTr[18]= bottomBeamTransf5;
c789ee28 552
b7943f00 553
554 //********************************************************************
555 // cables
556 //********************************************************************
557 char cableName[30];
558 for (Int_t i=0; i<fgkLay3Ndet; i++) {
559 sprintf(cableName, "digitCableLay3A_%i",i);
560 fDigitCableLay3A[i].SetName(cableName);
561 fDigitCableLay3A[i].SetWidth(fgkDigitCablWidth);
562 fDigitCableLay3A[i].SetThickness(fgkDigitCablPolyThick+fgkDigitCablAlThick);
563 fDigitCableLay3A[i].SetNLayers(2);
564 fDigitCableLay3A[i].SetLayer( 0, fgkDigitCablPolyThick, polyhamideSDD,
565 fColorPolyhamide);
566 fDigitCableLay3A[i].SetLayer(1, fgkDigitCablAlThick, alSDD, fColorAl);
567 sprintf(cableName, "digitCableLay3B_%i",i);
568 fDigitCableLay3B[i].SetName(cableName);
569 fDigitCableLay3B[i].SetWidth(fgkDigitCablWidth);
570 fDigitCableLay3B[i].SetThickness(fgkDigitCablPolyThick+fgkDigitCablAlThick);
571 fDigitCableLay3B[i].SetNLayers(2);
572 fDigitCableLay3B[i].SetLayer( 0, fgkDigitCablPolyThick, polyhamideSDD,
573 fColorPolyhamide);
574 fDigitCableLay3B[i].SetLayer(1, fgkDigitCablAlThick, alSDD, fColorAl);
575 };
576 for (Int_t i=0; i<fgkLay4Ndet; i++) {
577 sprintf(cableName, "digitCableLay4A_%i",i);
578 fDigitCableLay4A[i].SetName(cableName);
579 fDigitCableLay4A[i].SetWidth(fgkDigitCablWidth);
580 fDigitCableLay4A[i].SetThickness(fgkDigitCablPolyThick+fgkDigitCablAlThick);
581 fDigitCableLay4A[i].SetNLayers(2);
582 fDigitCableLay4A[i].SetLayer( 0, fgkDigitCablPolyThick, polyhamideSDD,
583 fColorPolyhamide);
584 fDigitCableLay4A[i].SetLayer(1, fgkDigitCablAlThick, alSDD, fColorAl);
585 sprintf(cableName, "digitCableLay4B_%i",i);
586 fDigitCableLay4B[i].SetName(cableName);
587 fDigitCableLay4B[i].SetWidth(fgkDigitCablWidth);
588 fDigitCableLay4B[i].SetThickness(fgkDigitCablPolyThick+fgkDigitCablAlThick);
589 fDigitCableLay4B[i].SetNLayers(2);
590 fDigitCableLay4B[i].SetLayer( 0, fgkDigitCablPolyThick, polyhamideSDD,
591 fColorPolyhamide);
592 fDigitCableLay4B[i].SetLayer(1, fgkDigitCablAlThick, alSDD, fColorAl);
593 };
594 // Well, those digit cables could also include the analog cables
595 // which have the same width and the same path, at least in the ladder.
596 // It will gain some computing ressources (less volumes) and some
597 // coding efforts ... !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
598 // The only thing to do is to change the names and put the correct total
599 // thicknesses
c789ee28 600
b7943f00 601};
c789ee28 602
c789ee28 603
b7943f00 604//________________________________________________________________________
605void AliITSv11GeometrySDD::CheckOverlaps(Double_t precision){
606 //
607 // a debugging function for checking some possible overlaps
608 //
609 if (fSDDsensor) fSDDsensor->CheckOverlaps(precision);
610 if (fHybrid) fHybrid->CheckOverlaps(precision);
c789ee28 611};
612
613
db486a6e 614//________________________________________________________________________
615TGeoCombiTrans *AliITSv11GeometrySDD::
616CreateCombiTrans(const char *name, Double_t dy, Double_t dz, Double_t dphi) {
617 //
618 // return the TGeoCombiTrans which make a translation in y and z
619 // and a rotation in phi in the global coord system
620 //
621
622 TGeoTranslation t1(dy*CosD(90.+dphi),dy*SinD(90.+dphi), dz);
623 TGeoRotation r1("",0.,0.,dphi);
624
625 TGeoCombiTrans *combiTrans1 = new TGeoCombiTrans(name);
626 combiTrans1->SetTranslation(t1);
627 combiTrans1->SetRotation(r1);
628 return combiTrans1;
629};
c789ee28 630
631
db486a6e 632//________________________________________________________________________
c789ee28 633void AliITSv11GeometrySDD::AddTranslationToCombiTrans(TGeoCombiTrans* ct,
db486a6e 634 Double_t dx,
635 Double_t dy,
b7943f00 636 Double_t dz) const{
637 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
638 const Double_t *vect = ct->GetTranslation();
639 Double_t newVect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
640 ct->SetTranslation(newVect);
db486a6e 641};
c789ee28 642
643
644//________________________________________________________________________
645void AliITSv11GeometrySDD::ShowOnePiece(TGeoVolume *moth) {
646// for code developpment and debugging purposes
647
b7943f00 648 if (! fSDDsensor) CreateBasicObjects();
649
650// Moth->AddNode(fBaseThermalBridge, 1, 0);
651 moth->AddNode(fHybrid,100,0);
652// moth->AddNode(fSDDsensor, 1, 0);
c789ee28 653
654// TGeoVolume* seg = CreateLadderSegment( 4, 0); //lay 4
b7943f00 655// moth->AddNode(seg, 1, 0);
656
657
658
659
660// TGeoBBox *box1 = new TGeoBBox("box1", 5,5,5);
661// TGeoMedium *air = GetMedium("ITSair");
662// TGeoVolume *vbox1 = new TGeoVolume("vbox1", box1, air);
663// TGeoBBox *box2 = new TGeoBBox("box2", 6,6,6);
664// TGeoVolume *vbox2 = new TGeoVolume("vbox2", box2, air);
665// TGeoBBox *box3 = new TGeoBBox("box3", 7,7,7);
666// TGeoVolume *vbox3 = new TGeoVolume("vbox3", box3, air);
667
668// vbox1->AddNode(fHybrid,100,0);
669// vbox2->AddNode(vbox1,1,0);
670// vbox3->AddNode(vbox2,1,0);
671// moth->AddNode(vbox3,1,0);
672
673
c789ee28 674
b7943f00 675// //testing cable
676// TGeoBBox *box1 = new TGeoBBox("box1", 10,10,10);
677// TGeoBBox *box2 = new TGeoBBox("box2", 10,10,10);
678// TGeoBBox *box3 = new TGeoBBox("box3", 20,10,10);
679// TGeoMedium *air = GetMedium("ITSsddAir");
680// TGeoVolume *vbox1 = new TGeoVolume("vbox1", box1, air);
681// TGeoVolume *vbox2 = new TGeoVolume("vbox2", box2, air);
682// TGeoVolume *vbox3 = new TGeoVolume("vbox3", box3, air);
c789ee28 683
b7943f00 684// TGeoTranslation *tr1 = new TGeoTranslation("merdeneg",-10,0,0);
685// TGeoTranslation *tr2 = new TGeoTranslation("merdepos",10,0,0);
c789ee28 686
b7943f00 687// AliITSv11GeomCableRound napCable(0.9);
688// //AliITSv11GeomCableFlat napCable(2,0.9);
689// napCable.SetNLayers(3);
690// napCable.SetLayer(0, 0.2, air);
691// napCable.SetLayer(1, 0.2, air);
692// napCable.SetLayer(2, 0.5, air);
693
694// napCable.SetInitialNode(vbox3);
695
696// Double_t coord1[3] = {0,-2,-2};
697// Double_t vect1[3]= {1,1,0};
698// napCable.AddCheckPoint( vbox1, 0, coord1, vect1);
699// Double_t coord2[3] = {10,0,0};
700// Double_t vect2[3]= {1,0,0};
701// napCable.AddCheckPoint( vbox1, 1, coord2, vect2);
702
703// //Double_t coord3[3] = {7,7,7};
704// Double_t coord3[3] = {7,-7,-7};
705// Double_t vect3[3]= {1,0,0};
706// napCable.AddCheckPoint( vbox3, 2, coord3, vect3);
707
708// Double_t coord4[3] = {19,7,7};
709// Double_t vect4[3]= {-1,0,2};
710// napCable.AddCheckPoint( vbox3, 3, coord4, vect4);
711
712// Double_t coord5[3] = {1,7,7};
713// Double_t vect5[3]= {1,0,0};
714// napCable.AddCheckPoint( vbox3, 4, coord5, vect5);
715
716
717// TGeoRotation *rot = new TGeoRotation("",0,0,0);
718// TGeoCombiTrans *combi = new TGeoCombiTrans(*tr1,*rot );
719// //vbox3->AddNode(vbox1,1,tr1);
720// vbox3->AddNode(vbox1,1,combi);
721// moth->AddNode(vbox3,1,0);
722
723// // napCable.CreateAndInsertCableSegment( 1, 135);
724// // napCable.CreateAndInsertCableSegment( 2, 0);
725// // napCable.CreateAndInsertCableSegment( 3, 0);
726// // napCable.CreateAndInsertCableSegment( 4, 0);
727// napCable.CreateAndInsertCableSegment( 1);
728// napCable.CreateAndInsertCableSegment( 2);
729// napCable.CreateAndInsertCableSegment( 3);
730// napCable.CreateAndInsertCableSegment( 4);
731// napCable.PrintCheckPoints();
c789ee28 732};
733
734
db486a6e 735//________________________________________________________________________
b7943f00 736void AliITSv11GeometrySDD::Layer3(TGeoVolume *moth) {
737 //
738 // Insert the layer 3 in the mother volume. This is a virtual volume
739 // containing ladders of layer 3 and the supporting rings
740 //
741
742 if (! moth) {
743 printf("Error::AliITSv11GeometrySDD: Can't insert layer3, mother is null!\n");
744 return;
745 };
746
747 TGeoMedium *airSDD = GetMedium("ITSair");
748
749 fMotherVol = moth;
750 if (! fSDDsensor) CreateBasicObjects();
751
752 TGeoVolume *lay3Ladder = CreateLadder(3);
753 TGeoVolume *lay3Detectors = CreateDetectors(3);
754 TGeoTube *virtualLayer3Shape = new TGeoTube("ITSsddLayer3Shape",
755 fgkLay3Rmin,fgkLay3Rmax,fgkLay3Length*0.5);
756 TGeoVolume *virtualLayer3 = new TGeoVolume("ITSsddLayer3",
757 virtualLayer3Shape, airSDD);
758
759 Double_t dPhi = 360./fgkLay3Nladd;
760 Double_t detectorsThick = fgkLadWaferSep + 2*fgkWaferThickness;
761 // Placing virtual ladder and detectors volumes following
762 // ladder ordering convention
763 char rotName[30];
764 Int_t iLaddMin = 0;
765 Int_t iLaddMax = fgkLay3Nladd;
766 if ((fAddOnlyLadder3min>=0)&&(fAddOnlyLadder3max<fgkLay3Nladd)) {
767 iLaddMin = fAddOnlyLadder3min;
768 iLaddMax = fAddOnlyLadder3max+1;
769 };
770
771 for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
772
773 sprintf(rotName, "ITSsddLay3Ladd%i",iLadd);
774 Double_t minRadiusLadBox = fLay3LaddShortRadius-fLay3LadderUnderSegDH;
775 if (iLadd%2 != 0)
776 minRadiusLadBox = fLay3LaddLongRadius-fLay3LadderUnderSegDH;
777 minRadiusLadBox += ((TGeoBBox*)lay3Ladder->GetShape())->GetDY();
778 TGeoCombiTrans *ctLadd = CreateCombiTrans(rotName,minRadiusLadBox,
779 0,-90+iLadd*dPhi);
780 virtualLayer3->AddNode(lay3Ladder, iLadd, ctLadd);
781 ///////////////////////////////////////////////////
782 sprintf(rotName, "ITSsddLay3DetBox%i",iLadd);
783 Double_t minRadiusDetBox = fgkLay3DetShortRadius;
784 if (iLadd%2 != 0) minRadiusDetBox = fgkLay3DetLongRadius;
785 minRadiusDetBox += detectorsThick/2;
786 TGeoCombiTrans *ctDet = CreateCombiTrans(rotName, minRadiusDetBox,
787 0,-90+iLadd*dPhi);
788 virtualLayer3->AddNode(lay3Detectors, iLadd, ctDet);
789 ///////////////////////////////////////////////////
790 }
791
792 if(GetDebug(1)) virtualLayer3->CheckOverlaps(0.01);
793 virtualLayer3->SetVisibility(kFALSE);
794 moth->AddNode(virtualLayer3, 1, 0);
db486a6e 795};
c789ee28 796
797
db486a6e 798//________________________________________________________________________
b7943f00 799void AliITSv11GeometrySDD::Layer4(TGeoVolume *moth) {
800 //
801 // Insert the layer 4 in the mother volume. This is a virtual volume
802 // containing ladders of layer 4 and the supporting rings
803 //
804
805 if (! moth) {
806 printf("Error::AliITSv11GeometrySDD: Can't insert layer4, mother is null!\n");
807 return;
808 };
809
810 fMotherVol = moth;
811
812 if (! fSDDsensor) CreateBasicObjects();
813
814 TGeoTube *virtualLayer4Shape =new TGeoTube("ITSsddLayer4Shape",
815 fgkLay4Rmin,fgkLay4Rmax,fgkLay4Length*0.5);
816 TGeoMedium *airSDD = GetMedium("ITSair");
817 TGeoVolume *virtualLayer4 = new TGeoVolume("ITSsddLayer4",
818 virtualLayer4Shape, airSDD);
819 TGeoVolume *lay4Ladder = CreateLadder(4);
820 TGeoVolume *lay4Detectors = CreateDetectors(4);
821 Double_t dPhi = 360./fgkLay4Nladd;
822 Double_t detBoxThickness = fgkLadWaferSep + 2*fgkWaferThickness;
823 // placing virtual ladder and detectors volumes following ladder
824 // ordering convention
825 char rotName[20];
826 Int_t iLaddMin = 0;
827 Int_t iLaddMax = fgkLay4Nladd;
828 if ((fAddOnlyLadder4min >= 0)&&(fAddOnlyLadder4max < fgkLay4Nladd)) {
829 iLaddMin = fAddOnlyLadder4min;
830 iLaddMax = fAddOnlyLadder4max+1;
831 }
832 for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
833 sprintf(rotName, "ITSsddLay4Ladd%i",iLadd);
834 Double_t minRadiusLadBox = fLay4LaddShortRadius-fLay4LadderUnderSegDH;
835 if (iLadd%2 != 0)
836 minRadiusLadBox = fLay4LaddLongRadius-fLay4LadderUnderSegDH;
837 minRadiusLadBox += ((TGeoBBox*)lay4Ladder->GetShape())->GetDY();
838 TGeoCombiTrans *ctLadd = CreateCombiTrans(rotName, minRadiusLadBox,
839 0, -90+iLadd*dPhi);
840 virtualLayer4->AddNode(lay4Ladder, iLadd, ctLadd);
841 sprintf(rotName, "ITSsddLay4DetBox%i",iLadd);
842 Double_t minRadiusDetBox = fgkLay4DetShortRadius;
843 if (iLadd%2 != 0)
844 minRadiusDetBox = fgkLay4DetLongRadius;
845 minRadiusDetBox += detBoxThickness/2;
846 TGeoCombiTrans *ctDet = CreateCombiTrans(rotName, minRadiusDetBox,
847 0, -90+iLadd*dPhi);
848 virtualLayer4->AddNode(lay4Detectors, iLadd, ctDet);
849 }
850
851 if(GetDebug(1)) virtualLayer4->CheckOverlaps(0.01);
852 virtualLayer4->SetVisibility(kFALSE);
853 moth->AddNode(virtualLayer4,1,0);
854};
855
856
857//________________________________________________________________________
858TGeoVolume *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) {
859 //
860 // return a box volume containing the CF ladder
861 //
862
863 Int_t nDetectors = fgkLay3Ndet;
864 Double_t ladderLength = fgkLay3LadderLength;
865 Double_t underSegDH = fLay3LadderUnderSegDH;
866 Double_t *sensorZPos = fLay3sensorZPos;
867 AliITSv11GeomCableFlat *digitCableA = fDigitCableLay3A;
868 AliITSv11GeomCableFlat *digitCableB = fDigitCableLay3B;
869
870 if (iLay==3) {}
871 else if (iLay==4) {
872 nDetectors = fgkLay4Ndet;
873 ladderLength = fgkLay4LadderLength;
874 digitCableA = fDigitCableLay4A;
875 digitCableB = fDigitCableLay4B;
876 underSegDH = fLay4LadderUnderSegDH;
877 sensorZPos = fLay4sensorZPos;
878 }
879 else {
880 printf("AliITSv11GeometrySDD::CreateLadder : error=wrong layer\n");
881 };
882 Double_t ladderBoxDH = fgkLadderHeight+fgkLadderSegBoxDH+underSegDH;
883 TGeoBBox *ladBox = new TGeoBBox("ITSsddLadBox",
884 fgkLadderWidth/2+fgkPinSuppWidth+fgkLadderSegBoxDW,
885 ladderBoxDH/2, ladderLength/2);
886 TGeoMedium *airSDD = GetMedium("ITSair");
887 TGeoVolume *virtualLadder = new TGeoVolume("ITSsddLadder",ladBox, airSDD);
888
889 // placing virtual ladder segment following detector ordering convention
890 //=======================================================================
891 char transName[30];
892
893 // adding segment this way to create cable points in the correct order ...
894 for (Int_t iSegment = nDetectors/2-1; iSegment >= 0; iSegment-- ) {
895
896 TGeoVolume *laddSegment = CreateLadderSegment(iLay, iSegment);
897 sprintf(transName, "ITSsddLay%iLaddSeg%i", iLay, iSegment);
898 Double_t segmentPos = fgkSegmentLength*(nDetectors/2-1-iSegment)
899 + fgkSegmentLength/2;
900 TGeoTranslation *segTr = new TGeoTranslation(transName, 0,
901 underSegDH/2,segmentPos);
902 ////
903 virtualLadder->AddNode(laddSegment, iSegment, segTr);
904 };
905 for (Int_t iSegment = nDetectors/2; iSegment < nDetectors; iSegment++ ) {
906
907 TGeoVolume *laddSegment = CreateLadderSegment(iLay, iSegment);
908 sprintf(transName, "ITSsddLay%iLaddSeg%i", iLay, iSegment);
909 Double_t segmentPos = fgkSegmentLength*(nDetectors/2-1-iSegment)
910 + fgkSegmentLength/2;
911 TGeoTranslation *segTr = new TGeoTranslation(transName, 0,
912 underSegDH/2,segmentPos);
913 ////
914 virtualLadder->AddNode(laddSegment, iSegment, segTr);
915 };
916
917 // putting virtual volume corresponding to the end of ladder
918 //=======================================================================
919 TGeoVolume *endLadder = CreateEndLadder( iLay );
920 Double_t endLength = (ladderLength - nDetectors*fgkSegmentLength)/2.;
921 TGeoTranslation *endTrZPos = new TGeoTranslation("ITSsddEndTrZPos",0,0,
922 fgkSegmentLength*(nDetectors/2)+endLength/2.);
923 // Euler rotation : about Z, then new X, then new Z
924 TGeoRotation *endZNegRot = new TGeoRotation("",90, 180, -90);
925 TGeoCombiTrans *endTrZNeg = new TGeoCombiTrans(0,0,
926 -fgkSegmentLength*(nDetectors/2)-endLength/2.,endZNegRot);
927 virtualLadder->AddNode(endLadder, 1, endTrZPos);
928 virtualLadder->AddNode(endLadder, 2, endTrZNeg);
929
930 // creating and inserting cable segments
931 // (check points are placed while creating segments)
932 //=======================================================================
933 if (fAddCables)
934 for (Int_t iSegment = 0; iSegment < nDetectors; iSegment++ ) {
935
936 digitCableA[iSegment].SetInitialNode(virtualLadder);
937 digitCableB[iSegment].SetInitialNode(virtualLadder);
938
939 for (Int_t iPt=1; iPt<digitCableA[iSegment].GetNCheckPoints(); iPt++ ) {
940 Double_t rotation = 0;
941 if (iPt>1) rotation = 90-fgkHybridAngle;
942 digitCableA[iSegment].CreateAndInsertCableSegment(iPt, rotation);
943 };
944
945 for (Int_t iPt=1; iPt<digitCableB[iSegment].GetNCheckPoints(); iPt++ ) {
946 Double_t rotation = 0;
947 if (iPt>1) rotation = fgkHybridAngle-90;
948 digitCableB[iSegment].CreateAndInsertCableSegment(iPt, rotation);
949 };
950 };
951
952 // HV cable
953 //=======================================================================
954 TGeoMedium *polyhamideSDD = GetMedium("ITSsddKAPTON_POLYCH2");
955 TGeoMedium *alSDD = GetMedium("ITSal");
956
957 AliITSv11GeomCableFlat cableHV[fgkLay4Ndet]; // temp !!!
958 char cableHVname[30];
959 for (Int_t iSegment = 0; iSegment<nDetectors; iSegment++) {
960 sprintf(cableHVname,"ITSsddHVcable%i", iSegment);
961 cableHV[iSegment].SetName(cableHVname);
962 cableHV[iSegment].SetThickness(fgkLongHVcablePolyThick+fgkLongHVcableAlThick);
963 cableHV[iSegment].SetWidth(fgkTransitHVtailWidth);
964 cableHV[iSegment].SetNLayers(2);
965 cableHV[iSegment].SetLayer(0, fgkLongHVcablePolyThick, polyhamideSDD,
966 fColorPolyhamide);
967 cableHV[iSegment].SetLayer(1, fgkLongHVcableAlThick, alSDD, fColorAl);
968 cableHV[iSegment].SetInitialNode(virtualLadder);
969 };
970 Double_t x1[3], x2[3], x3[3],
971 vY[3] = {0,1,0}, vZ[3] = {0,0,1}, vYZ[3]={0,1,1};
972
973 x1[0] = fgkTransitHVtailXpos;
974 x2[0] = fgkTransitHVtailXpos;
975 x3[0] = fgkTransitHVtailXpos;
976 for (Int_t iSegment = nDetectors/2-1; iSegment >= 0; iSegment-- ) {
977 Double_t cableSeparation = TMath::Abs(iSegment - (nDetectors/2-1))
978 *fgkLongHVcableSeparation;
979 x1[1] = - ladderBoxDH/2;
980 x2[1] = - ladderBoxDH/2 + underSegDH - cableSeparation
981 - (fgkLongHVcablePolyThick+fgkLongHVcableAlThick)/2;
982 x3[1] = x2[1];
983 x1[2] = sensorZPos[iSegment]+fgkTransitHVtailLength-5*fgkmm;
984 x2[2] = x1[2]+5*fgkmm;
985 x3[2] = ladderLength/2-endLength;
986 cableHV[iSegment].AddCheckPoint( virtualLadder, 0, x1, vY );
987 cableHV[iSegment].AddCheckPoint( virtualLadder, 1, x2, vYZ );
988 cableHV[iSegment].AddCheckPoint( virtualLadder, 2, x3, vZ );
989
990 cableHV[iSegment].CreateAndInsertCableSegment(1,0);
991 cableHV[iSegment].CreateAndInsertCableSegment(2,0);
992 };
993
994 vYZ[2] = -1;
995 for (Int_t iSegment = nDetectors/2; iSegment < nDetectors; iSegment++ ) {
996 Double_t cableSeparation = TMath::Abs(iSegment - (nDetectors/2-1))
997 *fgkLongHVcableSeparation;
998 x1[1] = - ladderBoxDH/2;
999 x2[1] = - ladderBoxDH/2 + underSegDH - cableSeparation
1000 - (fgkLongHVcablePolyThick+fgkLongHVcableAlThick)/2;
1001 x3[1] = x2[1];
1002 x1[2] = sensorZPos[iSegment]-fgkTransitHVtailLength+5*fgkmm;
1003 x2[2] = x1[2]-5*fgkmm;
1004 x3[2] = -ladderLength/2+endLength;
1005 cableHV[iSegment].AddCheckPoint( virtualLadder, 0, x1, vY );
1006 cableHV[iSegment].AddCheckPoint( virtualLadder, 1, x2, vYZ );
1007 cableHV[iSegment].AddCheckPoint( virtualLadder, 2, x3, vZ );
1008
1009 cableHV[iSegment].CreateAndInsertCableSegment(1,0);
1010 cableHV[iSegment].CreateAndInsertCableSegment(2,0);
1011 };
c789ee28 1012
b7943f00 1013 //**********************************
1014 if(GetDebug(1)) virtualLadder->CheckOverlaps(0.01);
1015 //virtualLadder->SetVisibility(kFALSE);
1016 return virtualLadder;
db486a6e 1017};
c789ee28 1018
1019
db486a6e 1020//________________________________________________________________________
b7943f00 1021TGeoArb8 *AliITSv11GeometrySDD::CreateLadderSide(Double_t dz, Double_t angle,
1022 Double_t xSign, Double_t L, Double_t H, Double_t l) {
db486a6e 1023 // Create one half of the V shape corner of CF ladder
1024
1025 TGeoArb8 *cfLaddSide = new TGeoArb8(dz);
c789ee28 1026 cfLaddSide->SetVertex( 0, 0, 0);
1027 cfLaddSide->SetVertex( 1, 0, -H);
1028 cfLaddSide->SetVertex( 2, xSign*(L*TMath::Sin(angle)-l*TMath::Cos(angle)),
1029 -L*TMath::Cos(angle)-l*TMath::Sin(angle));
1030 cfLaddSide->SetVertex( 3, xSign*L*TMath::Sin(angle), -L*TMath::Cos(angle));
1031 cfLaddSide->SetVertex( 4, 0, 0);
1032 cfLaddSide->SetVertex( 5, 0, -H);
1033 cfLaddSide->SetVertex( 6, xSign*(L*TMath::Sin(angle)-l*TMath::Cos(angle)),
1034 -L*TMath::Cos(angle)-l*TMath::Sin(angle));
1035 cfLaddSide->SetVertex(7, xSign*L*TMath::Sin(angle), -L*TMath::Cos(angle));
db486a6e 1036 return cfLaddSide;
1037};
c789ee28 1038
1039
db486a6e 1040//________________________________________________________________________
b7943f00 1041TGeoVolume* AliITSv11GeometrySDD::CreateHybrid(Int_t iLRSide) {
1042 //
1043 // return a box containing the front-end hybrid
1044 //
1045
1046 Double_t roundHoleX = -fgkHybridWidth/2+fgkHybRndHoleX;
1047
1048 Double_t screenTotalThick = fgkHybGlueScrnThick+fgkHybUpThick+fgkHybAlThick;
1049 Double_t lowFLTotalThick = fgkHybGlueLowThick+fgkHybUpThick+fgkHybAlThick;
1050// Double_t upFLTotalThick = fgkHybGlueUpThick +fgkHybUpThick+fgkHybAlThick;
1051 Double_t chipsCCTotThick = fgkHybUnderNiThick+fgkHybGlueAgThick
1052 +fgkHybChipThick+2*(fgkHybUpCCThick+fgkHybAlCCThick);
1053 Double_t ccUpLayerTotThick = fgkHybUpCCThick+fgkHybAlCCThick+fgkHybUpCCThick;
1054// Double_t volumeThick = (fgkHybridThBridgeThick+screenTotalThick+lowFLTotalThick
1055// + upFLTotalThick + ccUpLayerTotThick);
1056 Double_t volumeThick = (fgkHybridThBridgeThick+screenTotalThick+lowFLTotalThick
1057 +fgkHybSMDheight);
1058 Double_t lowLayerYmin = -volumeThick/2+fgkHybridThBridgeThick
1059 +screenTotalThick;
1060 Double_t flUpThick = fgkHybGlueUpThick+fgkHybUpThick;
1061
1062 //**************************************************** media :
1063 TGeoMedium *airSDD = GetMedium("ITSair");
1064 TGeoMedium *carbonFiberLadderStruct = GetMedium("ITSsddCarbonM55J");
1065 TGeoMedium *alSDD = GetMedium("ITSal");
1066 TGeoMedium *alSDD80p100 = GetMedium("ITSal"); // to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1067 TGeoMedium *alSDD50p100 = GetMedium("ITSal"); // to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1068 TGeoMedium *polyhamideSDD = GetMedium("ITSsddKAPTON_POLYCH2");
1069 TGeoMedium *niSDD = GetMedium("COPPER"); // to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1070 TGeoMedium *glueAG = GetMedium("ITSsddKAPTON_POLYCH2"); // to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1071 TGeoMedium *siliconSDD = GetMedium("ITSsddSiChip");
1072 TGeoMedium *medSMD = GetMedium("SDDX7Rcapacitors"); // TO CODE !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1073 TGeoMedium *medSMDweld = GetMedium("SDDX7Rcapacitors"); // TO CODE !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1074
1075 //**************************************************** main volume :
1076 TGeoBBox *hybridBox = new TGeoBBox("",fgkHybridWidth/2, volumeThick/2,
1077 (fgkHybridLength)/2);
1078 TGeoVolume *hybrid = new TGeoVolume("ITSsddHybridVol", hybridBox,
1079 airSDD);
1080
1081 TGeoBBox *sThermalBridge = new TGeoBBox( "", fgkHybridWidth/2,
1082 fgkHybridThBridgeThick/2,
1083 fgkHybridLength/2);
c789ee28 1084
b7943f00 1085 //**************************************************** Thermal bridge :
c789ee28 1086 TGeoVolume *vThermalBridge = new TGeoVolume("ITSsddHybridThBridge",
1087 sThermalBridge,
1088 carbonFiberLadderStruct);
1089 vThermalBridge->SetLineColor(fColorCarbonFiber);
b7943f00 1090 TGeoTranslation *thBridgeTr = new TGeoTranslation(0, -volumeThick/2
1091 +fgkHybridThBridgeThick/2, 0);
1092 hybrid->AddNode(vThermalBridge, 1, thBridgeTr);
1093
1094 //**************************************************** Screen layer :
1095 TGeoBBox *sAlScreenLayer = new TGeoBBox("sAlScreenLayer", fgkHybridWidth/2,
1096 fgkHybAlThick/2, fgkHybridLength/2);
1097 //here the upedex and glue layers are both assumed to be polyimide
1098 TGeoBBox *sUpGlueScreenLayer = new TGeoBBox("sUpGlueScreenLayer",
1099 fgkHybridWidth/2,
1100 (fgkHybUpThick+fgkHybGlueScrnThick)/2,
1101 fgkHybridLength/2);
1102 TGeoTube *sRoundHole = new TGeoTube("sRoundHole", 0, fgkHybRndHoleRad,
1103 (screenTotalThick+lowFLTotalThick)/2);
1104
1105 TGeoTranslation *upGlueScreenTr = new TGeoTranslation("upGlueScreenTr",0,
1106 -volumeThick/2+fgkHybridThBridgeThick+(fgkHybUpThick+fgkHybGlueScrnThick)/2,0);
1107
1108 TGeoTranslation *alScreenTr = new TGeoTranslation("AlScreenTr", 0,
1109 -volumeThick/2+fgkHybridThBridgeThick+fgkHybUpThick+fgkHybGlueScrnThick
1110 +fgkHybAlThick/2, 0);
1111
1112 TGeoTranslation hybHolePos1Tr(roundHoleX,
1113 -volumeThick/2+fgkHybridThBridgeThick+(screenTotalThick+lowFLTotalThick)/2,
1114 -fgkHybridLength/2+fgkHybRndHoleZ);
1115 TGeoTranslation hybHolePos2Tr(roundHoleX,
1116 -volumeThick/2+fgkHybridThBridgeThick+(screenTotalThick+lowFLTotalThick)/2,
1117 fgkHybridLength/2-fgkHybRndHoleZ);
1118 TGeoRotation rotHole("", 0, 90, 0);
1119 TGeoCombiTrans *hybHolePos1 = new TGeoCombiTrans(hybHolePos1Tr, rotHole);
1120 hybHolePos1->SetName("hybHolePos1");
1121 TGeoCombiTrans *hybHolePos2 = new TGeoCombiTrans(hybHolePos2Tr, rotHole);
1122 hybHolePos2->SetName("hybHolePos2");
1123
1124 upGlueScreenTr->RegisterYourself();
1125 alScreenTr->RegisterYourself();
1126 hybHolePos1->RegisterYourself();
1127 hybHolePos2->RegisterYourself();
1128
1129 TGeoCompositeShape *sScreenAl = new TGeoCompositeShape(
1130 "sAlScreenLayer:AlScreenTr-(sRoundHole:hybHolePos1"
1131 "+sRoundHole:hybHolePos2)");
1132 TGeoVolume *vScreenAl = new TGeoVolume("vScreenAl",sScreenAl, alSDD);
1133 vScreenAl->SetLineColor(fColorAl);
1134 TGeoCompositeShape *sScreenUpGlue = new TGeoCompositeShape(
1135 "sUpGlueScreenLayer:upGlueScreenTr-(sRoundHole:hybHolePos1"
1136 "+sRoundHole:hybHolePos2)");
1137 TGeoVolume *vScreenUpGlue = new TGeoVolume("vScreenUpGlue",
1138 sScreenUpGlue,polyhamideSDD);
1139 vScreenUpGlue->SetLineColor(fColorPolyhamide);
1140
1141 hybrid->AddNode(vScreenUpGlue, 1, 0);
1142 hybrid->AddNode(vScreenAl, 1, 0);
1143
1144 //**************************************************** FL low layer :
1145 Double_t sideWidth1 = fgkHybFLlowChipZ1 - fgkHybFLlowHoleDZ/2;
1146 Double_t sideWidth2 = fgkHybridLength - fgkHybFLlowChipZ4 - fgkHybFLlowHoleDZ/2;
1147
1148 //here the upedex and glue layers are both assumed to be polyimide
1149 TGeoBBox *sUpGlueBar1 = new TGeoBBox("sUpGlueBar1", fgkHybridWidth/2,
1150 (fgkHybGlueLowThick+fgkHybUpThick)/2,
1151 sideWidth1/2);
1152 TGeoBBox *sAlBar1 = new TGeoBBox("sAlBar1", fgkHybridWidth/2,
1153 fgkHybAlThick/2, sideWidth1/2);
1154
1155 TGeoTranslation *upGlueBarTr1 = new TGeoTranslation("upGlueBarTr1", 0,
1156 lowLayerYmin+(fgkHybGlueLowThick+fgkHybUpThick)/2,
1157 -(fgkHybridLength-sideWidth1)/2);
1158 TGeoTranslation *alBarTr1 = new TGeoTranslation("alBarTr1", 0,
1159 lowLayerYmin+fgkHybGlueLowThick+fgkHybUpThick+fgkHybAlThick/2,
1160 -(fgkHybridLength-sideWidth1)/2);
1161 upGlueBarTr1->RegisterYourself();
1162 alBarTr1->RegisterYourself();
1163
1164 TGeoCompositeShape *sLowUpGlueBar1 = new TGeoCompositeShape(
1165 "sUpGlueBar1:upGlueBarTr1-sRoundHole:hybHolePos1");
1166 TGeoCompositeShape *sLowAlBar1 = new TGeoCompositeShape(
1167 "sAlBar1:alBarTr1-sRoundHole:hybHolePos1");
1168 TGeoVolume *vLowUpGlueBar1 = new TGeoVolume("vLowUpGlueBar1",
1169 sLowUpGlueBar1, polyhamideSDD);
1170 TGeoVolume *vLowAlBar1 = new TGeoVolume("vLowAlBar1",
1171 sLowAlBar1, alSDD);
1172 vLowUpGlueBar1->SetLineColor(fColorPolyhamide);
1173 vLowAlBar1->SetLineColor(fColorAl);
1174 hybrid->AddNode(vLowUpGlueBar1,1,0);
1175 hybrid->AddNode(vLowAlBar1,1,0);
1176
1177 //---
1178 //here the upedex and glue layers are both assumed to be polyimide
1179 TGeoBBox *sUpGlueBar2 = new TGeoBBox("sUpGlueBar2", fgkHybridWidth/2,
1180 (fgkHybGlueLowThick+fgkHybUpThick)/2,
1181 sideWidth2/2);
1182 TGeoBBox *sAlBar2 = new TGeoBBox("sAlBar2", fgkHybridWidth/2,
1183 fgkHybAlThick/2, sideWidth2/2);
1184
1185 TGeoTranslation *upGlueBarTr2 = new TGeoTranslation("upGlueBarTr2", 0,
1186 lowLayerYmin+(fgkHybGlueLowThick+fgkHybUpThick)/2,
1187 (fgkHybridLength-sideWidth2)/2);
1188 TGeoTranslation *alBarTr2 = new TGeoTranslation("alBarTr2", 0,
1189 lowLayerYmin+fgkHybGlueLowThick+fgkHybUpThick+fgkHybAlThick/2,
1190 (fgkHybridLength-sideWidth2)/2);
1191 upGlueBarTr2->RegisterYourself();
1192 alBarTr2->RegisterYourself();
1193
1194 TGeoCompositeShape *sLowUpGlueBar2 = new TGeoCompositeShape(
1195 "sUpGlueBar2:upGlueBarTr2-sRoundHole:hybHolePos2");
1196 TGeoCompositeShape *sLowAlBar2 = new TGeoCompositeShape(
1197 "sAlBar2:alBarTr2-sRoundHole:hybHolePos2");
1198 TGeoVolume *vLowUpGlueBar2 = new TGeoVolume("vLowUpGlueBar2",sLowUpGlueBar2,
1199 polyhamideSDD);
1200 TGeoVolume *vLowAlBar2 = new TGeoVolume("vLowAlBar2",sLowAlBar2,
1201 alSDD);
1202 vLowUpGlueBar2->SetLineColor(fColorPolyhamide);
1203 vLowAlBar2->SetLineColor(fColorAl);
1204 hybrid->AddNode(vLowUpGlueBar2, 1, 0);
1205 hybrid->AddNode(vLowAlBar2, 1, 0);
1206
1207 if(GetDebug(3)){ // Remove compiler warning.
1208 sAlScreenLayer->InspectShape();
1209 sUpGlueScreenLayer->InspectShape();
1210 sRoundHole->InspectShape();
1211 sUpGlueBar1->InspectShape();
1212 sUpGlueBar2->InspectShape();
1213 sAlBar1->InspectShape();
1214 sAlBar2->InspectShape();
1215 };
1216 //---
1217 //using class AliITSv11GeomCableFlat to add 2-layer segments ...
1218 Double_t piece1width = fgkHybFLlowPasX-fgkHybFLlowHolePasDX/2;
1219 AliITSv11GeomCableFlat lowFLpiece("lowFLpiece1",piece1width,
1220 lowFLTotalThick);
1221 lowFLpiece.SetNLayers(2);
1222 lowFLpiece.SetLayer(0, fgkHybGlueLowThick+fgkHybUpThick, polyhamideSDD,
1223 fColorPolyhamide);
1224 lowFLpiece.SetLayer(1, fgkHybAlThick, alSDD80p100, fColorAl);
1225 // alSDD at 80% : mostly to take into account strips of piece 3
1226
1227 Double_t x1[3] = { -fgkHybridWidth/2 + piece1width/2,
1228 lowLayerYmin + lowFLTotalThick/2,
1229 -fgkHybridLength/2 + sideWidth1 };
1230 Double_t x2[3] ={ x1[0], x1[1], fgkHybridLength/2 - sideWidth2 };
1231 Double_t vZ[3] = {0,0,1};
1232 lowFLpiece.AddCheckPoint( hybrid, 0, x2, vZ );
1233 lowFLpiece.AddCheckPoint( hybrid, 1, x1, vZ );
1234 lowFLpiece.SetInitialNode(hybrid);
1235 lowFLpiece.CreateAndInsertCableSegment(1);
1236 lowFLpiece.ResetPoints();
1237
1238 Double_t piece2width = fgkHybFLlowAmbX-fgkHybFLlowPasX
1239 -fgkHybFLlowHolePasDX/2-fgkHybFLlowHoleAmbDX/2;
1240
1241 lowFLpiece.SetWidth(piece2width);
1242 lowFLpiece.SetName("lowFLpiece2");
1243 x1[0] = piece2width/2+fgkHybFLlowPasX+fgkHybFLlowHolePasDX/2-fgkHybridWidth/2;
1244 x2[0] = x1[0];
1245 lowFLpiece.AddCheckPoint( hybrid, 0, x2, vZ );
1246 lowFLpiece.AddCheckPoint( hybrid, 1, x1, vZ );
1247 lowFLpiece.CreateAndInsertCableSegment(1);
1248 lowFLpiece.ResetPoints();
1249
1250 Double_t piece3width = fgkHybridWidth - fgkHybFLlowAmbX
1251 - fgkHybFLlowHoleAmbDX/2;
1252
1253 lowFLpiece.SetWidth(piece3width);
1254 lowFLpiece.SetName("lowFLpiece3");
1255 x1[0] = fgkHybridWidth/2-piece3width/2;
1256 x2[0] = x1[0];
1257 lowFLpiece.AddCheckPoint( hybrid, 0, x2, vZ );
1258 lowFLpiece.AddCheckPoint( hybrid, 1, x1, vZ );
1259 lowFLpiece.CreateAndInsertCableSegment(1);
1260
1261 Double_t zChips[4] = {fgkHybFLlowChipZ1,fgkHybFLlowChipZ2,
1262 fgkHybFLlowChipZ3,fgkHybFLlowChipZ4};
1263 Double_t vX[3] = {1,0,0};
1264 for (Int_t i=0; i<3; i++) {
1265 char ch[20];
1266 sprintf(ch, "lowFLpieceA%i", i+4);
1267 lowFLpiece.SetName(ch);
1268 lowFLpiece.SetWidth(zChips[i+1]-zChips[i]-fgkHybFLlowHoleDZ);
1269
1270 lowFLpiece.SetLayer(1, fgkHybAlThick, alSDD, fColorAl);
1271 x1[0] = -fgkHybridWidth/2 + piece1width;
1272 x2[0] = x1[0] + fgkHybFLlowHolePasDX;
1273 Double_t zPiece = (zChips[i+1]+zChips[i])/2 - fgkHybridLength/2;
1274 x1[2] = zPiece; x2[2] = zPiece;
1275 lowFLpiece.AddCheckPoint( hybrid, 0, x2, vX );
1276 lowFLpiece.AddCheckPoint( hybrid, 1, x1, vX );
1277 lowFLpiece.CreateAndInsertCableSegment(1,90);
1278 lowFLpiece.ResetPoints();
1279
1280 sprintf(ch, "lowFLpieceB%i", i+4);
1281 lowFLpiece.SetName(ch);
1282 x1[0] = fgkHybridWidth/2 - piece3width;
1283 x2[0] = x1[0] - fgkHybFLlowHoleAmbDX;
1284 lowFLpiece.AddCheckPoint( hybrid, 0, x1, vX );
1285 lowFLpiece.AddCheckPoint( hybrid, 1, x2, vX );
1286 lowFLpiece.CreateAndInsertCableSegment(1,90);
1287 };
1288
1289 //**************************************************** chips+CC:
1290 AliITSv11GeomCableFlat chip("", fgkHybChipsDZ, chipsCCTotThick);
1291 chip.SetInitialNode(hybrid);
1292 chip.SetNLayers(5);
1293 chip.SetLayer(0, fgkHybUnderNiThick, niSDD, 2);
1294 chip.SetLayer(1, fgkHybGlueAgThick, glueAG, 4);
1295 chip.SetLayer(2, fgkHybChipThick, siliconSDD, fColorSilicon);
1296 chip.SetLayer(3, fgkHybUpCCThick+fgkHybUpCCThick, polyhamideSDD,
1297 fColorPolyhamide);
1298 chip.SetLayer(4, fgkHybAlCCThick+fgkHybAlCCThick, alSDD80p100, fColorAl);
1299 // Here the tho CC (low+up) are merged
1300 // In fact, the last layer has a smaller surface of Al -> I put 80%
1301
1302 x1[1] = lowLayerYmin + chipsCCTotThick/2;
1303 x2[1] = x1[1];
1304 char ch[20];
1305
1306 for (Int_t i=0; i<4; i++) {
1307 sprintf(ch, "pascalCC%i", i);
1308 chip.SetName(ch);
1309 x1[0] = fgkHybFLlowPasX - fgkHybridWidth/2 - fgkHybPascalDX/2;
1310 x2[0] = x1[0] + fgkHybPascalDX;
1311 x1[2] = zChips[i] - fgkHybridLength/2;
1312 x2[2] = x1[2];
1313 chip.AddCheckPoint( hybrid, 0, x1, vX );
1314 chip.AddCheckPoint( hybrid, 1, x2, vX );
1315 chip.CreateAndInsertCableSegment(1,-90);
1316 chip.ResetPoints();
1317
1318 sprintf(ch, "ambraCC%i", i);
1319 chip.SetName(ch);
1320 x1[0] = fgkHybFLlowAmbX - fgkHybridWidth/2 - fgkHybAmbraDX/2;
1321 x2[0] = x1[0] + fgkHybAmbraDX;
1322 chip.AddCheckPoint( hybrid, 0, x1, vX );
1323 chip.AddCheckPoint( hybrid, 1, x2, vX );
1324 chip.CreateAndInsertCableSegment(1,-90);
1325 chip.ResetPoints();
1326 };
c789ee28 1327
b7943f00 1328 //**************************************************** CC outside chips:
1329 // je crois qu'il n'y a pas de 2ieme couche d'alu ici ...
1330 for (Int_t i = 0; i<4; i++) {
1331 char ch[20];
1332 sprintf(ch, "ccLayerA%i", i);
1333
1334 AliITSv11GeomCableFlat ccLayer1(ch, 6.6*fgkmm, ccUpLayerTotThick);
1335 ccLayer1.SetInitialNode(hybrid);
1336 ccLayer1.SetNLayers(2);
1337 ccLayer1.SetLayer(0, 2*fgkHybUpCCThick, polyhamideSDD, fColorPolyhamide);
1338 ccLayer1.SetLayer(1, fgkHybAlCCThick, alSDD50p100, fColorAl);
1339 // Al at ~50%
1340
1341 x1[0] = -fgkHybridWidth/2;
1342 x2[0] = fgkHybFLlowPasX - fgkHybridWidth/2 - fgkHybPascalDX/2;
1343 x1[1] = lowLayerYmin + fgkHybUnderNiThick + fgkHybGlueAgThick
1344 + fgkHybChipThick + ccUpLayerTotThick/2;
1345 x2[1] = x1[1];
1346 x1[2] = zChips[i] - fgkHybridLength/2;
1347 x2[2] = x1[2];
1348 ccLayer1.AddCheckPoint( hybrid, 0, x1, vX );
1349 ccLayer1.AddCheckPoint( hybrid, 1, x2, vX );
1350 ccLayer1.CreateAndInsertCableSegment(1,-90);
1351
1352 sprintf(ch, "ccLayerB%i", i);
1353 AliITSv11GeomCableFlat ccLayer2(ch, fgkHybChipsDZ, ccUpLayerTotThick);
1354 ccLayer2.SetInitialNode(hybrid);
1355 ccLayer2.SetNLayers(2);
1356 ccLayer2.SetLayer(0, 2*fgkHybUpCCThick, polyhamideSDD, fColorPolyhamide);
1357 ccLayer2.SetLayer(1, fgkHybAlCCThick, alSDD50p100, fColorAl);
1358 // Al at ~50%
1359
1360 x1[0] = -fgkHybridWidth/2 + fgkHybFLlowPasX + fgkHybPascalDX/2;
1361 x2[0] = -fgkHybridWidth/2 + fgkHybFLlowAmbX - fgkHybAmbraDX/2;
1362 ccLayer2.AddCheckPoint( hybrid, 0, x1, vX );
1363 ccLayer2.AddCheckPoint( hybrid, 1, x2, vX );
1364 ccLayer2.CreateAndInsertCableSegment(1,-90);
1365 ccLayer2.ResetPoints();
1366 sprintf(ch, "ccLayerC%i", i);
1367 ccLayer2.SetName(ch);
1368 x1[0] = -fgkHybridWidth/2 + fgkHybFLlowAmbX + fgkHybAmbraDX/2;
1369 x2[0] = fgkHybridWidth/2 - fgkHybFLUpperWidth + 3*fgkmm;
1370 x1[1] = lowLayerYmin + lowFLTotalThick + flUpThick + fgkHybAlThick
1371 + ccUpLayerTotThick/2;
1372 x2[1] = x1[1];
1373
1374 ccLayer2.AddCheckPoint( hybrid, 0, x1, vX );
1375 ccLayer2.AddCheckPoint( hybrid, 1, x2, vX );
1376 ccLayer2.CreateAndInsertCableSegment(1,-90);
1377 };
c789ee28 1378
b7943f00 1379 //**************************************************** FL UP:
1380 // (last Al layer will be a special triangular shape)
1381 TGeoBBox *sFLupPolyhamide = new TGeoBBox("sFLupPolyhamide",
1382 fgkHybFLUpperWidth/2, flUpThick/2,
1383 fgkHybFLUpperLength/2);
1384 TGeoVolume *vFLupPolyhamide = new TGeoVolume("vFLupPolyhamide",
1385 sFLupPolyhamide, polyhamideSDD);
1386 vFLupPolyhamide->SetLineColor(fColorPolyhamide);
1387 TGeoTranslation *trFLupPolyhamide =
1388 new TGeoTranslation(fgkHybridWidth/2-fgkHybFLUpperWidth/2,
1389 lowLayerYmin+lowFLTotalThick+flUpThick/2,0);
1390
1391 hybrid->AddNode(vFLupPolyhamide, 1, trFLupPolyhamide);
1392
1393 TGeoArb8 *aluStrip = new TGeoArb8(fgkHybAlThick/2);
1394 aluStrip->SetVertex( 0,-fgkHybFLUpperAlDZ/2, fgkHybFLUpperWidth);
1395 aluStrip->SetVertex( 1, fgkHybFLUpperAlDZ/2, fgkHybFLUpperWidth);
1396 aluStrip->SetVertex( 2, fgkHybFLUpperAlDZ/2, fgkHybFLUpperWidth-fgkHybFLUpperAldx);
1397 aluStrip->SetVertex( 3,-fgkHybFLUpperAlDZ/2, 0);
1398 aluStrip->SetVertex( 4,-fgkHybFLUpperAlDZ/2, fgkHybFLUpperWidth);
1399 aluStrip->SetVertex( 5, fgkHybFLUpperAlDZ/2, fgkHybFLUpperWidth);
1400 aluStrip->SetVertex( 6, fgkHybFLUpperAlDZ/2, fgkHybFLUpperWidth-fgkHybFLUpperAldx);
1401 aluStrip->SetVertex( 7,-fgkHybFLUpperAlDZ/2, 0);
1402 TGeoVolume *vAluStrip = new TGeoVolume("vAluStrip",aluStrip, alSDD50p100);
1403 // Al at ~50%
1404
1405 vAluStrip->SetLineColor(fColorAl);
1406 TGeoRotation rotAluStrip("rotAluStrip",0, -90, 90);
1407 Double_t yRotAluStrip = lowLayerYmin+lowFLTotalThick
1408 +flUpThick+fgkHybAlThick/2;
1409 TGeoCombiTrans *aluStripTr1 = new TGeoCombiTrans(
1410 fgkHybridWidth/2,yRotAluStrip,
1411 fgkHybridLength/2-fgkHybFLlowChipZ1+1*fgkmm, &rotAluStrip);
1412 TGeoCombiTrans *aluStripTr2 = new TGeoCombiTrans(*aluStripTr1);
1413 AddTranslationToCombiTrans(aluStripTr2,0,0,
1414 fgkHybFLlowChipZ1-fgkHybFLlowChipZ2);
1415 TGeoCombiTrans *aluStripTr3 = new TGeoCombiTrans(*aluStripTr2);
1416 AddTranslationToCombiTrans(aluStripTr3,0,0,
1417 fgkHybFLlowChipZ2-fgkHybFLlowChipZ3);
1418 TGeoCombiTrans *aluStripTr4 = new TGeoCombiTrans(*aluStripTr3);
1419 AddTranslationToCombiTrans(aluStripTr4,0,0,
1420 fgkHybFLlowChipZ3-fgkHybFLlowChipZ4);
1421
1422 hybrid->AddNode(vAluStrip, 1, aluStripTr1);
1423 hybrid->AddNode(vAluStrip, 2, aluStripTr2);
1424 hybrid->AddNode(vAluStrip, 3, aluStripTr3);
1425 hybrid->AddNode(vAluStrip, 4, aluStripTr4);
1426
1427 //**************************************************** SMD:
1428 TGeoBBox *hybSMD = new TGeoBBox("ITSsddSMDshape",
1429 fgkHybSMDmiddleL/2+fgkHybSMDendL,
1430 fgkHybSMDheight/2,fgkHybSMDendW/2);
1431 TGeoVolume *vHybSMD = new TGeoVolume("ITSsddSMD",hybSMD,airSDD);
1432
1433 TGeoBBox *hybSMDmiddle = new TGeoBBox("ITSsddSMDmiddleShape",
1434 fgkHybSMDmiddleL/2,fgkHybSMDheight/2,
1435 fgkHybSMDmiddleW/2);
1436 TGeoVolume *vHybSMDmiddle = new TGeoVolume("ITSsddSMDmiddle",
1437 hybSMDmiddle,medSMD);
1438 vHybSMDmiddle->SetLineColor(fColorSMD);
1439 TGeoBBox *hybSMDend = new TGeoBBox("ITSsddSMDendShape",
1440 fgkHybSMDendL/2,fgkHybSMDheight/2,fgkHybSMDendW/2);
1441 TGeoVolume *vHybSMDend = new TGeoVolume("ITSsddSMDend",
1442 hybSMDend,medSMDweld);
1443 vHybSMDend->SetLineColor(fColorSMDweld);
1444 TGeoTranslation *vHybSMDendTr1 = new TGeoTranslation("",
1445 (fgkHybSMDmiddleL+fgkHybSMDendL)/2,0,0);
1446 TGeoTranslation *vHybSMDendTr2 = new TGeoTranslation("",
1447 -(fgkHybSMDmiddleL+fgkHybSMDendL)/2,0,0);
1448 vHybSMD->AddNode(vHybSMDmiddle,1,0);
1449 vHybSMD->AddNode(vHybSMDend,1,vHybSMDendTr1);
1450 vHybSMD->AddNode(vHybSMDend,2,vHybSMDendTr2);
1451 for (Int_t i=0; i<fgkNHybSMD; i++) {
1452 TGeoTranslation *vHybSMDtr = new TGeoTranslation("",
1453 -fgkHybridWidth/2+fgkHybSMDposX[i],
1454 lowLayerYmin+lowFLTotalThick+fgkHybSMDheight/2,
1455 -fgkHybridLength/2+fgkHybSMDposZ[i]);
1456 hybrid->AddNode(vHybSMD, i+1, vHybSMDtr);
1457 };
1458
1459
1460 if (iLRSide == 0) {
1461 };
1462
1463 if(GetDebug(1)) hybrid->CheckOverlaps(0.01);
1464 hybrid->SetVisibility(kFALSE);
1465 return hybrid;
db486a6e 1466};
c789ee28 1467
1468
db486a6e 1469//________________________________________________________________________
c789ee28 1470TGeoVolume* AliITSv11GeometrySDD::CreateLadderSegment(Int_t iLay, Int_t iSeg) {
b7943f00 1471 //
1472 // Return a box volume containing a segment of a ladder.
1473 //
1474
1475 TGeoMedium *airSDD = GetMedium("ITSair");
1476 TGeoMedium *phynoxSDD = GetMedium("ITSal"); // phynoxSDD To code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1477 TGeoMedium *coolerMediumSDD = GetMedium("WATER");
1478
1479 Double_t tDY = fgkLadderSegBoxDH/2; //space left on top of the ladder
1480 Double_t segmentLength = fgkSegmentLength;
1481 Double_t spaceBetweenCables = 500*fgkmicron;
1482
1483 //*****************************************
1484 // Set parameters according to (iLay,iSeg):
1485 //*****************************************
1486 Int_t nDetectors = fgkLay3Ndet;
1487 Double_t coolPipeSuppH = fgkLay3CoolPipeSuppH;
1488 Double_t sensorCenterZPos = fLay3sensorZPos[iSeg]-
1489 (fgkSegmentLength*fgkLay3Ndet/2. -
1490 fgkSegmentLength/2-(iSeg)*fgkSegmentLength);
1491 // sensorCenterZPos = z in segment local coord syst.
1492
1493 AliITSv11GeomCableFlat *digitCableA = fDigitCableLay3A;
1494 AliITSv11GeomCableFlat *digitCableB = fDigitCableLay3B;
1495
1496 if (iLay==3) {
1497 } else if (iLay==4) {
1498 nDetectors = fgkLay4Ndet;
1499 coolPipeSuppH = fgkLay4CoolPipeSuppH;
1500 sensorCenterZPos = fLay4sensorZPos[iSeg]-
1501 (fgkSegmentLength*fgkLay4Ndet/2. -
1502 fgkSegmentLength/2-(iSeg)*fgkSegmentLength);
1503 digitCableA = fDigitCableLay4A;
1504 digitCableB = fDigitCableLay4B;
1505 } else
1506 printf("AliITSv11GeometrySDD::CreateLadderSegment Wrong layer index !");
1507
1508
1509 Double_t cableSideSign = -1;
1510 if (iSeg<nDetectors/2) cableSideSign = 1;
1511 Double_t spaceForCables = spaceBetweenCables*
1512 (nDetectors-TMath::Abs(nDetectors-2*iSeg-1)-1)/2
1513 +0.1*fgkmicron;
1514 // gives [0-1-2-2-1-0]*spaceBetweenCables
1515 // or [0-1-2-3-3-2-1-0]*spaceBetweenCables
1516 Int_t iUpdateCableMin;
1517 Int_t iUpdateCableMax;
1518 if (cableSideSign==-1) {
1519 iUpdateCableMin = nDetectors/2;
1520 iUpdateCableMax = iSeg-1;
1521 } else {
1522 iUpdateCableMin = iSeg+1;
1523 iUpdateCableMax = nDetectors/2-1;
1524 };
1525
1526 if(GetDebug(1)){
1527 cout << "Segment ("<< iLay <<',' << iSeg
1528 << ") : sensor z shift in local segment coord.="
1529 << sensorCenterZPos << endl;
1530 };
1531
1532 //****************************
1533 // The segment volume
1534 //****************************
1535 TGeoBBox *segBox = new TGeoBBox("ITSsddSegBox",
1536 fgkLadderWidth/2+fgkPinSuppWidth+fgkLadderSegBoxDW,
1537 fgkLadderHeight/2+fgkLadderSegBoxDH/2,
1538 segmentLength/2);
1539
1540 TGeoVolume *virtualSeg = new TGeoVolume("ITSsddSegment",
1541 segBox, airSDD);
1542
1543 //******************************
1544 // Carbon fiber structure :
1545 //******************************
1546
1547 virtualSeg->AddNode(fLaddSegCommonVol[0], 1, fLaddSegCommonTr[0]);
1548 Int_t volumeIndex = 1;
1549 for (Int_t i = 1; i<fgkNladdSegCommonVol;i++ ) {
1550 if (fLaddSegCommonVol[i]==fLaddSegCommonVol[i-1])
1551 volumeIndex++;
1552 else
1553 volumeIndex = 1;
1554 virtualSeg->AddNode(fLaddSegCommonVol[i], volumeIndex,
1555 fLaddSegCommonTr[i]);
1556 };
1557
1558 //**********************************
1559 // Pine support of the sensors :
1560 //**********************************
1561 TGeoRotation rotPS1("",0,-90,90);
1562 TGeoRotation rotPS2("",0,-90,-90);
1563 TGeoCombiTrans *transPS1 = new TGeoCombiTrans( fgkPinDYOnSensor,
1564 - fgkLadderHeight/2.-tDY
1565 + fgkPinSuppHeight/2.,
1566 sensorCenterZPos+fgkPinDXminOnSensor,&rotPS1);
1567 TGeoCombiTrans *transPS2 = new TGeoCombiTrans(*transPS1);
1568 AddTranslationToCombiTrans(transPS2, 0, 0, fgkPinPinDDXOnSensor);
1569 TGeoCombiTrans *transPS3 = new TGeoCombiTrans(*transPS1);
1570 AddTranslationToCombiTrans(transPS3, 0, 0, -2*fgkPinDXminOnSensor);
1571 TGeoCombiTrans *transPS4 = new TGeoCombiTrans(*transPS3);
1572 AddTranslationToCombiTrans(transPS4, 0, 0, -fgkPinPinDDXOnSensor);
1573
1574 TGeoCombiTrans *transPS5 = new TGeoCombiTrans( -fgkPinDYOnSensor,
1575 - fgkLadderHeight/2. - tDY
1576 + fgkPinSuppHeight/2.,
1577 sensorCenterZPos+fgkPinDXminOnSensor,&rotPS2);
1578 TGeoCombiTrans *transPS6 = new TGeoCombiTrans(*transPS5);
1579 AddTranslationToCombiTrans(transPS6, 0, 0, fgkPinPinDDXOnSensor);
1580 TGeoCombiTrans *transPS7 = new TGeoCombiTrans(*transPS5);
1581 AddTranslationToCombiTrans(transPS7, 0, 0, -2*fgkPinDXminOnSensor);
1582 TGeoCombiTrans *transPS8 = new TGeoCombiTrans(*transPS7);
1583 AddTranslationToCombiTrans(transPS8, 0, 0, -fgkPinPinDDXOnSensor);
1584
1585 virtualSeg->AddNode(fPinSupport, 1, transPS1);
1586 virtualSeg->AddNode(fPinSupport, 2, transPS2);
1587 virtualSeg->AddNode(fPinSupport, 3, transPS3);
1588 virtualSeg->AddNode(fPinSupport, 4, transPS4);
1589 virtualSeg->AddNode(fPinSupport, 5, transPS5);
1590 virtualSeg->AddNode(fPinSupport, 6, transPS6);
1591 virtualSeg->AddNode(fPinSupport, 7, transPS7);
1592 virtualSeg->AddNode(fPinSupport, 8, transPS8);
1593
1594 //******************************
1595 // Cooling pipe supports :
1596 //******************************
1597 Double_t triangleHeight = fgkLadderHeight - fgkLadderBeamRadius;
1598 Double_t halfTheta = TMath::ATan( 0.5*fgkLadderWidth/triangleHeight );
1599 Double_t triangleCPaxeDist = fgkCoolPipeSuppAxeDist-fgkCoolPipeSuppWidthExt-
1600 fgkCoolPipeSuppWidthIn+fgkLadderBeamRadius;
1601
1602 Double_t coolPipeSuppL = TMath::Tan(halfTheta)*
1603 (triangleHeight+triangleCPaxeDist/
1604 TMath::Sin(halfTheta)-coolPipeSuppH);
1605 if (fAddCoolingSyst) {
1606 TGeoRotation rotCPS2("", -halfTheta*TMath::RadToDeg(), -90, 90);
1607 TGeoRotation rotCPS1("", halfTheta*TMath::RadToDeg(), -90, -90);
1608 TGeoCombiTrans *transCPS1 = new TGeoCombiTrans(coolPipeSuppL,
1609 -fgkLadderHeight/2.-TMath::Abs(tDY)
1610 +coolPipeSuppH+fgkLadderBeamRadius,
1611 -segmentLength/2., &rotCPS1);
1612 TGeoCombiTrans *transCPS3 = new TGeoCombiTrans(*transCPS1);
1613 AddTranslationToCombiTrans(transCPS3, 0, 0, segmentLength);
1614
1615 TGeoCombiTrans *transCPS2 = new TGeoCombiTrans(-coolPipeSuppL,
1616 -fgkLadderHeight/2.-tDY
1617 +coolPipeSuppH+fgkLadderBeamRadius,
1618 segmentLength/2., &rotCPS2);
1619 TGeoCombiTrans *transCPS4 = new TGeoCombiTrans(*transCPS2);
1620 AddTranslationToCombiTrans(transCPS4, 0, 0, -segmentLength);
1621
1622 virtualSeg->AddNode(fCoolPipeSupportL, 1, transCPS1);
1623 virtualSeg->AddNode(fCoolPipeSupportL, 2, transCPS2);
1624 virtualSeg->AddNode(fCoolPipeSupportR, 1, transCPS3);
1625 virtualSeg->AddNode(fCoolPipeSupportR, 2, transCPS4);
1626 };
1627
1628 //************************
1629 // Cooling pipes :
1630 //************************
1631 TGeoTranslation *pipeTr1 = new TGeoTranslation(coolPipeSuppL,
1632 -fgkLadderHeight/2. - tDY +
1633 fgkLadderBeamRadius+coolPipeSuppH, 0);
1634 TGeoTranslation *pipeTr2 = new TGeoTranslation(-coolPipeSuppL,
1635 -fgkLadderHeight/2.- tDY +
1636 fgkLadderBeamRadius+coolPipeSuppH, 0);
1637
1638 if (fAddCoolingSyst) {
1639 TGeoTube *coolingPipeShape = new TGeoTube( fgkCoolPipeInnerDiam/2,
1640 fgkCoolPipeOuterDiam/2,
1641 segmentLength/2);
1642 TGeoTube *coolerShape = new TGeoTube( 0, fgkCoolPipeInnerDiam/2,
1643 segmentLength/2);
1644
1645 TGeoVolume *coolingPipe = new TGeoVolume("ITSsddCoolingPipe",
1646 coolingPipeShape, phynoxSDD );
1647 coolingPipe->SetLineColor(fColorPhynox);
1648 TGeoVolume *cooler = new TGeoVolume("ITSsddCoolingLiquid",coolerShape,
1649 coolerMediumSDD );
1650
1651
1652 virtualSeg->AddNode(coolingPipe, 1, pipeTr1);
1653 virtualSeg->AddNode(coolingPipe, 2, pipeTr2);
1654 if (fCoolingOn) {
1655 virtualSeg->AddNode(cooler, 1, pipeTr1);
1656 virtualSeg->AddNode(cooler, 2, pipeTr2);
1657 };
1658 };
c789ee28 1659
b7943f00 1660 //**********************************
1661 // Bases of hybrid thermal bridges
1662 //**********************************
1663 Double_t shiftHyb = 1.05; // shift between thermal Bridge base and thermal bridge
1664 // approx !!! not clear on 0752/14-A
1665 if (fAddCoolingSyst) {
1666 TGeoRotation rotHybrid1("", 0, 0, -90 - fgkHybridAngle);
1667 TGeoRotation rotHybrid2("", 0 ,180, 90 - fgkHybridAngle);
1668 TGeoCombiTrans *baseTr1 = new TGeoCombiTrans(*pipeTr2, rotHybrid1);
1669 TGeoCombiTrans *baseTr2 = new TGeoCombiTrans(*pipeTr1, rotHybrid2);
1670
1671 virtualSeg->AddNode(fBaseThermalBridge, 1, baseTr1);
1672 virtualSeg->AddNode(fBaseThermalBridge, 2, baseTr2);
1673 };
1674
1675 //*************************
1676 // the 2 hybrids :
1677 //*************************
1678 Double_t hybDy = ((TGeoBBox*)fHybrid->GetShape())->GetDY();
1679 Double_t distAxeToHybridCenter = fgkBTBaxisAtoBase+hybDy;
1680
1681 Double_t hybrVolX = ( distAxeToHybridCenter*CosD(fgkHybridAngle)
1682 - shiftHyb*SinD(fgkHybridAngle) );
1683 Double_t hybrVolY = ( distAxeToHybridCenter*SinD(fgkHybridAngle)
1684 + shiftHyb*CosD(fgkHybridAngle) );
1685 if (fAddHybrids) {
1686 TGeoRotation rotHybrid3("", 0, 0, 90. - fgkHybridAngle);
1687 TGeoRotation rotHybrid4("", 0 ,180, -90. - fgkHybridAngle);
1688 TGeoCombiTrans *hybTr1 = new TGeoCombiTrans(*pipeTr2, rotHybrid3);
1689 TGeoCombiTrans *hybTr2 = new TGeoCombiTrans(*pipeTr1, rotHybrid4);
1690 AddTranslationToCombiTrans( hybTr1, -hybrVolX, hybrVolY, 0);
1691 AddTranslationToCombiTrans( hybTr2, hybrVolX, hybrVolY, 0);
1692
1693 virtualSeg->AddNode(fHybrid, 1, hybTr1);
1694 virtualSeg->AddNode(fHybrid, 2, hybTr2);
1695 };
1696
1697 //***********
1698 // cables
1699 //***********
1700 if (fAddCables) {
1701 // Starting from this segment
1702 Double_t hybDz = ((TGeoBBox*)fHybrid->GetShape())->GetDZ();
1703 Double_t hybDx = ((TGeoBBox*)fHybrid->GetShape())->GetDX();
1704 Double_t posDigitCableAlongHyb = shiftHyb+ hybDx
1705 - digitCableA->GetWidth()/2;
1706 Double_t distAxeToDigitCableCenter = distAxeToHybridCenter+hybDy
1707 - digitCableA->GetThickness()/2;
1708
1709 Double_t digitCableX = ( coolPipeSuppL
1710 + distAxeToDigitCableCenter*CosD(fgkHybridAngle)
1711 - posDigitCableAlongHyb*SinD(fgkHybridAngle) );
1712 Double_t digitCableY = ( - fgkLadderHeight/2.-TMath::Abs(tDY)
1713 + fgkLadderBeamRadius+coolPipeSuppH
1714 + distAxeToDigitCableCenter*SinD(fgkHybridAngle)
1715 + posDigitCableAlongHyb*CosD(fgkHybridAngle) );
1716
1717
1718 Double_t digitCableCenterA0[3]={ -cableSideSign*digitCableX,
1719 digitCableY, cableSideSign*hybDz };
1720 Double_t digitCableCenterA1[3] = {
1721 -cableSideSign*(digitCableX+spaceForCables*CosD(fgkHybridAngle)),
1722 digitCableY+spaceForCables*SinD(fgkHybridAngle),
1723 cableSideSign*segmentLength/2 };
1724
1725 Double_t digitCableCenterB0[3]={ cableSideSign*digitCableX,
1726 digitCableY,cableSideSign*hybDz};
1727 Double_t digitCableCenterB1[3]={
1728 cableSideSign*(digitCableX+spaceForCables*CosD(fgkHybridAngle)),
1729 digitCableY+spaceForCables*SinD(fgkHybridAngle),
1730 cableSideSign*segmentLength/2 };
1731
1732 Double_t vZ[3] = {0,0,1};
1733 digitCableA[iSeg].AddCheckPoint( virtualSeg, 0, digitCableCenterA0, vZ);
1734 digitCableA[iSeg].AddCheckPoint( virtualSeg, 1, digitCableCenterA1, vZ);
1735 digitCableB[iSeg].AddCheckPoint( virtualSeg, 0, digitCableCenterB0, vZ);
1736 digitCableB[iSeg].AddCheckPoint( virtualSeg, 1, digitCableCenterB1, vZ);
1737
1738 // Updating the other cables
1739 for (Int_t iCable=iUpdateCableMin; iCable<=iUpdateCableMax; iCable++) {
1740
1741 Int_t iPoint = TMath::Abs(iCable-iSeg)+1;
1742 Double_t coord[3];
1743 digitCableA[iCable].GetPoint( 1, coord);
1744 digitCableA[iCable].AddCheckPoint( virtualSeg, iPoint, coord, vZ);
1745 digitCableB[iCable].GetPoint( 1, coord);
1746 digitCableB[iCable].AddCheckPoint( virtualSeg, iPoint, coord, vZ);
1747 };
1748 };
1749
1750 //**********************************
1751 if(GetDebug(1)) virtualSeg->CheckOverlaps(0.01);
1752 //virtualSeg->SetVisibility(kFALSE);
1753 return virtualSeg;
db486a6e 1754};
db486a6e 1755
c789ee28 1756
1757//________________________________________________________________________
1758TGeoVolume* AliITSv11GeometrySDD::CreatePinSupport() {
1759//
1760// Create a pine support
1761// axis of rotation is the cone axis, center in its middle
1762//
b7943f00 1763 TGeoCone *cone = new TGeoCone("ITSsddPinSuppCone",fgkPinSuppHeight/2.,
1764 0,fgkPinSuppRmax,0,fgkPinSuppRmax-
1765 fgkPinSuppHeight*TanD(fgkPinSuppConeAngle) );
1766 TGeoBBox *tong = new TGeoBBox("ITSsddPinSuppTong",fgkPinSuppRmax,
1767 fgkPinSuppLength/2.,fgkPinSuppThickness/2.);
1768 TGeoTube *hole = new TGeoTube("ITSsddPinSuppHole",0,fgkPinR,
1769 fgkPinSuppHeight/2.);
c789ee28 1770 if(GetDebug(3)){// Remove compiler warning.
db486a6e 1771 cone->InspectShape();
1772 tong->InspectShape();
1773 hole->InspectShape();
c789ee28 1774 };
db486a6e 1775
1776 TGeoTranslation *tongTrans = new TGeoTranslation("ITSsddPinSuppTongTr",0,
b7943f00 1777 fgkPinSuppLength/2.,-fgkPinSuppHeight/2.+fgkPinSuppThickness/2.);
db486a6e 1778 tongTrans->RegisterYourself();
1779 TGeoCompositeShape *pinSupportShape = new TGeoCompositeShape(
b7943f00 1780 "ITSsddPinSupportShape","(ITSsddPinSuppCone+"
db486a6e 1781 "ITSsddPinSuppTong:ITSsddPinSuppTongTr)-ITSsddPinSuppHole");
1782
b7943f00 1783
1784 TGeoMedium *rytonSDD = GetMedium("ITSsddCarbonM55J"); //medium = ryton ? To code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1785 TGeoVolume *pinSupport = new TGeoVolume("ITSsddPinSupport",pinSupportShape,
db486a6e 1786 rytonSDD);
c789ee28 1787 pinSupport->SetLineColor(fColorRyton);
db486a6e 1788 return pinSupport;
c789ee28 1789 // include the pin itself !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
db486a6e 1790};
c789ee28 1791
b7943f00 1792
db486a6e 1793//________________________________________________________________________
c789ee28 1794TGeoVolume* AliITSv11GeometrySDD::CreateCoolPipeSupportL() {
1795//
1796// Create half of the cooling pipe support (ALR-0752/3)
1797//
1798
b7943f00 1799 Double_t diffX = fgkCoolPipeSuppHeight*TanD(fgkCoolPipeSuppAngle);
c789ee28 1800
b7943f00 1801 TGeoArb8 *side1 = new TGeoArb8(fgkCoolPipeSuppHeight/2.);
1802 side1->SetVertex( 0, 0, -fgkCoolPipeSuppWidthExt/2.);
1803 side1->SetVertex( 1, fgkCoolPipeSuppMaxLength/2.-diffX,
1804 -fgkCoolPipeSuppWidthExt/2.);
1805 side1->SetVertex( 2, fgkCoolPipeSuppMaxLength/2.-diffX,
1806 fgkCoolPipeSuppWidthExt/2.);
1807 side1->SetVertex( 3, 0, fgkCoolPipeSuppWidthExt/2.);
1808 side1->SetVertex( 4, 0, -fgkCoolPipeSuppWidthExt/2.);
1809 side1->SetVertex( 5, fgkCoolPipeSuppMaxLength/2.,
1810 -fgkCoolPipeSuppWidthExt/2.);
1811 side1->SetVertex( 6, fgkCoolPipeSuppMaxLength/2.,
1812 fgkCoolPipeSuppWidthExt/2.);
1813 side1->SetVertex( 7, 0, fgkCoolPipeSuppWidthExt/2.);
c789ee28 1814 side1->SetName("ITSsddCPSside1");
1815
1816 TGeoTranslation *side1Tr = new TGeoTranslation("ITSsddCPStr1",0,
b7943f00 1817 - fgkCoolPipeSuppAxeDist
1818 + fgkCoolPipeSuppWidthExt/2., 0);
c789ee28 1819 side1Tr->RegisterYourself();
1820 TGeoTranslation *side2Tr = new TGeoTranslation("ITSsddCPStr2",0,
b7943f00 1821 - fgkCoolPipeSuppAxeDist
1822 + fgkCoolPipeSuppWidthExt*3/2.
1823 + fgkCoolPipeSuppWidthIn,0);
c789ee28 1824 side2Tr->RegisterYourself();
1825
1826 TGeoBBox *middle = new TGeoBBox("ITSsddCPSmiddle",
b7943f00 1827 (fgkCoolPipeSuppMaxLength/2.-fgkCoolPipeSuppSlitL)/2.,
1828 fgkCoolPipeSuppWidthIn/2., fgkCoolPipeSuppHeight/2.);
c789ee28 1829 TGeoTranslation *middleTr =
1830 new TGeoTranslation("ITSsddCPStr3",
b7943f00 1831 (fgkCoolPipeSuppMaxLength/2.-fgkCoolPipeSuppSlitL)/2.,
1832 -fgkCoolPipeSuppAxeDist+fgkCoolPipeSuppWidthExt
1833 +fgkCoolPipeSuppWidthIn/2., 0);
c789ee28 1834 middleTr->RegisterYourself();
1835
1836 TGeoBBox *axeBox = new TGeoBBox("ITSsddCPSaxeBox",
b7943f00 1837 fgkCoolPipeSuppTongW/4.,
1838 (fgkCoolPipeSuppFulWidth
1839 - 2*fgkCoolPipeSuppWidthExt
1840 - fgkCoolPipeSuppWidthIn)/2,
1841 fgkCoolPipeSuppHeight/2.);
c789ee28 1842
1843 TGeoTranslation *axeBoxTr = new TGeoTranslation("ITSsddCPSAxBoxTr",
b7943f00 1844 fgkCoolPipeSuppTongW/4.,
1845 - fgkCoolPipeSuppAxeDist
1846 + fgkCoolPipeSuppFulWidth
c789ee28 1847 - axeBox->GetDY(), 0);
1848 axeBoxTr->RegisterYourself();
1849
b7943f00 1850 TGeoTube *axe = new TGeoTube("ITSsddCPSaxe",0,fgkCoolPipeSuppHoleDiam/2.,
1851 fgkCoolPipeSuppTongW/4.);
1852 TGeoRotation axeRot("ITSsddCPSaxeRot",90,90,0);
c789ee28 1853
1854 TGeoCombiTrans *axeTrans = new TGeoCombiTrans("ITSsddCPSaxeTr",
b7943f00 1855 fgkCoolPipeSuppTongW/4.,0,0,&axeRot);
c789ee28 1856 axeTrans->RegisterYourself();
1857
1858 if(GetDebug(3)){
1859 middle->InspectShape();
1860 axe->InspectShape();
1861 };
1862
b7943f00 1863 TGeoMedium *rytonSDD = GetMedium("ITSsddCarbonM55J"); //medium = ryton ? !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
c789ee28 1864
1865 TGeoCompositeShape *coolPipeSuppShape = new TGeoCompositeShape(
1866 "ITSsddCoolPipeSuppShapeL",
1867 "ITSsddCPSmiddle:ITSsddCPStr3"
1868 "+ITSsddCPSside1:ITSsddCPStr1"
1869 "+ITSsddCPSside1:ITSsddCPStr2"
1870 "+ITSsddCPSaxeBox:ITSsddCPSAxBoxTr"
1871 "-ITSsddCPSaxe:ITSsddCPSaxeTr");
1872 TGeoVolume *coolPipeSupp = new TGeoVolume("ITSsddCoolPipeSupportL",
1873 coolPipeSuppShape, rytonSDD);
1874
1875 coolPipeSupp->SetLineColor(fColorRyton);
1876 return coolPipeSupp;
1877};
1878
1879//________________________________________________________________________
1880TGeoVolume* AliITSv11GeometrySDD::CreateCoolPipeSupportR() {
1881//
1882//Create half of the cooling pipe support (ALR-0752/3)
1883//
1884
b7943f00 1885 Double_t diffX = fgkCoolPipeSuppHeight*TanD(fgkCoolPipeSuppAngle);
c789ee28 1886
b7943f00 1887 TGeoArb8 *side1 = new TGeoArb8(fgkCoolPipeSuppHeight/2.);
1888 side1->SetVertex( 0, 0, -fgkCoolPipeSuppWidthExt/2.);
1889 side1->SetVertex( 1, -(fgkCoolPipeSuppMaxLength/2.-diffX),
1890 -fgkCoolPipeSuppWidthExt/2.);
1891 side1->SetVertex( 2, -(fgkCoolPipeSuppMaxLength/2.-diffX),
1892 fgkCoolPipeSuppWidthExt/2.);
1893 side1->SetVertex( 3, 0, fgkCoolPipeSuppWidthExt/2.);
1894 side1->SetVertex( 4, 0, -fgkCoolPipeSuppWidthExt/2.);
1895 side1->SetVertex( 5, -fgkCoolPipeSuppMaxLength/2.,
1896 -fgkCoolPipeSuppWidthExt/2.);
1897 side1->SetVertex( 6, -fgkCoolPipeSuppMaxLength/2.,
1898 fgkCoolPipeSuppWidthExt/2.);
1899 side1->SetVertex( 7, 0, fgkCoolPipeSuppWidthExt/2.);
c789ee28 1900 side1->SetName("ITSsddCPSside1R");
1901
1902 TGeoTranslation *side1Tr = new TGeoTranslation("ITSsddCPStr1R",0,
b7943f00 1903 - fgkCoolPipeSuppAxeDist
1904 + fgkCoolPipeSuppWidthExt/2., 0);
c789ee28 1905 side1Tr->RegisterYourself();
1906 TGeoTranslation *side2Tr = new TGeoTranslation("ITSsddCPStr2R",0,
b7943f00 1907 - fgkCoolPipeSuppAxeDist
1908 + fgkCoolPipeSuppWidthExt*3/2.
1909 + fgkCoolPipeSuppWidthIn, 0);
c789ee28 1910 side2Tr->RegisterYourself();
1911
1912 TGeoBBox *middle = new TGeoBBox("ITSsddCPSmiddleR",
b7943f00 1913 (fgkCoolPipeSuppMaxLength/2.
1914 - fgkCoolPipeSuppSlitL)/2.,
1915 fgkCoolPipeSuppWidthIn/2.,
1916 fgkCoolPipeSuppHeight/2.);
c789ee28 1917 TGeoTranslation *middleTr =
1918 new TGeoTranslation("ITSsddCPStr3R",
b7943f00 1919 -( fgkCoolPipeSuppMaxLength/2.
1920 -fgkCoolPipeSuppSlitL)/2.,
1921 -fgkCoolPipeSuppAxeDist + fgkCoolPipeSuppWidthExt
1922 + fgkCoolPipeSuppWidthIn/2.,0);
c789ee28 1923 middleTr->RegisterYourself();
1924
1925 TGeoBBox *axeBox = new TGeoBBox("ITSsddCPSaxeBoxR",
b7943f00 1926 fgkCoolPipeSuppTongW/4.,
1927 (fgkCoolPipeSuppFulWidth
1928 - 2*fgkCoolPipeSuppWidthExt
1929 - fgkCoolPipeSuppWidthIn)/2,
1930 fgkCoolPipeSuppHeight/2.);
c789ee28 1931
1932 TGeoTranslation *axeBoxTr = new TGeoTranslation("ITSsddCPSAxBoxTrR",
b7943f00 1933 - fgkCoolPipeSuppTongW/4.,
1934 - fgkCoolPipeSuppAxeDist
1935 + fgkCoolPipeSuppFulWidth
c789ee28 1936 - axeBox->GetDY(),0);
1937 axeBoxTr->RegisterYourself();
1938
b7943f00 1939 TGeoTube *axe = new TGeoTube("ITSsddCPSaxeR",0,fgkCoolPipeSuppHoleDiam/2.,
1940 fgkCoolPipeSuppTongW/4.);
1941 TGeoRotation axeRot("ITSsddCPSaxeRotR",90,90,0);
c789ee28 1942 TGeoCombiTrans *axeTrans = new TGeoCombiTrans("ITSsddCPSaxeTrR",
b7943f00 1943 -fgkCoolPipeSuppTongW/4.,0,0,&axeRot);
c789ee28 1944 axeTrans->RegisterYourself();
1945
1946 if(GetDebug(3)){
1947 middle->InspectShape();
1948 axe->InspectShape();
1949 };
1950
1951 TGeoCompositeShape *coolPipeSuppShape = new TGeoCompositeShape(
1952 "ITSsddCoolPipeSuppShapeR",
1953 "ITSsddCPSmiddleR:ITSsddCPStr3R"
1954 "+ITSsddCPSside1R:ITSsddCPStr1R"
1955 "+ITSsddCPSside1R:ITSsddCPStr2R"
1956 "+ITSsddCPSaxeBoxR:ITSsddCPSAxBoxTrR"
1957 "-ITSsddCPSaxeR:ITSsddCPSaxeTrR");
b7943f00 1958
1959 TGeoMedium *rytonSDD = GetMedium("ITSsddCarbonM55J"); //medium = ryton ? To code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
c789ee28 1960 TGeoVolume *coolPipeSupp = new TGeoVolume( "ITSsddCoolPipeSupportR",
1961 coolPipeSuppShape, rytonSDD);
1962 coolPipeSupp->SetLineColor(fColorRyton);
1963
1964 return coolPipeSupp;
1965};
1966
1967//________________________________________________________________________
1968TGeoVolume* AliITSv11GeometrySDD::CreateBaseThermalBridge() {
1969// ALR 0752/8
1970
b7943f00 1971 Double_t dy = fgkBTBaxisAtoBase - fgkRadiusBminBTB - fgkBTBthick;
c789ee28 1972
b7943f00 1973 Double_t base1width = fgkBTBwidth - fgkBTBaxisAtoBottom - fgkRadiusBminBTB
1974 - (fgkRadiusAminBTB+fgkBTBthick);
c789ee28 1975 TGeoBBox *base1 = new TGeoBBox( "ITSsddBTBbase1", base1width/2.,
b7943f00 1976 fgkBTBthick/2., fgkBTBlength/2.);
c789ee28 1977 TGeoTranslation *base1Tr = new TGeoTranslation("ITSsddBTBtr1",
b7943f00 1978 fgkBTBaxisAtoBottom-fgkBTBwidth+base1width/2.,
1979 -(fgkBTBaxisAtoBase-fgkBTBthick/2.), 0);
c789ee28 1980 base1Tr->RegisterYourself();
1981
b7943f00 1982 Double_t base2width = fgkBTBaxisAtoBottom - fgkRadiusAminBTB - fgkBTBthick
1983 - fgkRadiusBminBTB;
c789ee28 1984 TGeoBBox *base2 = new TGeoBBox( "ITSsddBTBbase2", base2width/2.,
b7943f00 1985 fgkBTBthick/2., fgkBTBlength/2.);
c789ee28 1986 TGeoTranslation *base2Tr = new TGeoTranslation("ITSsddBTBtr2",
b7943f00 1987 fgkBTBaxisAtoBottom - base2width/2.,
1988 -(fgkBTBaxisAtoBase-fgkBTBthick/2.), 0);
c789ee28 1989 base2Tr->RegisterYourself();
1990
1991 TGeoBBox *side = new TGeoBBox( "ITSsddBTBside",
b7943f00 1992 fgkBTBthick/2., dy/2., fgkBTBlength/2.);
c789ee28 1993 TGeoTranslation *sideTr1 = new TGeoTranslation("ITSsddBTBsideTr1",
b7943f00 1994 -fgkRadiusAminBTB-fgkBTBthick/2., -dy/2., 0);
c789ee28 1995 TGeoTranslation *sideTr2 = new TGeoTranslation("ITSsddBTBsideTr2",
b7943f00 1996 fgkRadiusAminBTB+fgkBTBthick/2., -dy/2., 0);
c789ee28 1997 sideTr1->RegisterYourself();
1998 sideTr2->RegisterYourself();
1999
b7943f00 2000 TGeoBBox *hole = new TGeoBBox( "ITSsddBTBhole", fgkBTBHolewidth/2.,
2001 fgkBTBthick/2., fgkBTBHoleLength/2.);
c789ee28 2002 TGeoTranslation *holeTr1 = new TGeoTranslation("ITSsddBTBholeTr1",
b7943f00 2003 - fgkBTBHoleRefX + fgkBTBHolewidth/2.,
2004 - (fgkBTBaxisAtoBase-fgkBTBthick/2.),
2005 fgkBTBHoleRefY+(fgkBTBHoleLength-fgkBTBlength)/2.);
c789ee28 2006 TGeoTranslation *holeTr2 = new TGeoTranslation("ITSsddBTBholeTr2",
b7943f00 2007 - fgkBTBHoleRefX + fgkBTBHolewidth/2.,
2008 - (fgkBTBaxisAtoBase-fgkBTBthick/2.),
2009 - fgkBTBHoleRefY-(fgkBTBHoleLength-fgkBTBlength)/2.);
c789ee28 2010 holeTr1->RegisterYourself();
2011 holeTr2->RegisterYourself();
2012
b7943f00 2013 Double_t radiusAmaxBTB = fgkRadiusAminBTB + fgkBTBthick;
c789ee28 2014 TGeoTubeSeg *mainAxis = new TGeoTubeSeg( "ITSsddBTBmainAxis",
b7943f00 2015 fgkRadiusAminBTB, radiusAmaxBTB,
2016 fgkBTBlength/2., 0., 180.);
c789ee28 2017 TGeoTubeSeg *round1 = new TGeoTubeSeg( "ITSsddBTBround1",
b7943f00 2018 fgkRadiusBminBTB, fgkRadiusBminBTB+fgkBTBthick,
2019 fgkBTBlength/2., 270., 360.);
c789ee28 2020 TGeoTranslation *roundTr1 = new TGeoTranslation("ITSsddBTBround1Tr",
b7943f00 2021 -(fgkRadiusAminBTB+fgkBTBthick+fgkRadiusBminBTB),
c789ee28 2022 -dy, 0);
2023 roundTr1->RegisterYourself();
2024
2025 TGeoTubeSeg *round2 = new TGeoTubeSeg( "ITSsddBTBround2",
b7943f00 2026 fgkRadiusBminBTB, fgkRadiusBminBTB+fgkBTBthick,
2027 fgkBTBlength/2., 180., 270.);
c789ee28 2028 TGeoTranslation *roundTr2 = new TGeoTranslation("ITSsddBTBround2Tr",
b7943f00 2029 (fgkRadiusAminBTB+fgkBTBthick+fgkRadiusBminBTB),
c789ee28 2030 -dy, 0);
2031 roundTr2->RegisterYourself();
2032
2033 TGeoCompositeShape *sBaseThermalBridge = new TGeoCompositeShape(
2034 "ITSsddBaseThermalBridgeShape",
2035 "ITSsddBTBbase1:ITSsddBTBtr1"
2036 "+ ITSsddBTBbase2:ITSsddBTBtr2"
2037 "+ ITSsddBTBround1:ITSsddBTBround1Tr"
2038 "+ ITSsddBTBround2:ITSsddBTBround2Tr"
2039 "+ ITSsddBTBside:ITSsddBTBsideTr1"
2040 "+ ITSsddBTBside:ITSsddBTBsideTr2"
2041 "- ITSsddBTBhole:ITSsddBTBholeTr1"
2042 "- ITSsddBTBhole:ITSsddBTBholeTr2"
2043 "+ ITSsddBTBmainAxis");
2044
2045 if(GetDebug(3)){// Remove compiler warning.
2046 base1->InspectShape();
2047 base2->InspectShape();
2048 side->InspectShape();
2049 hole->InspectShape();
2050 mainAxis->InspectShape();
2051 round1->InspectShape();
2052 round2->InspectShape();
2053 };
2054
b7943f00 2055 TGeoMedium *carbonFiberLadderStruct = GetMedium("ITSsddCarbonM55J");
c789ee28 2056 TGeoVolume *vBaseThermalBridge = new TGeoVolume( "ITSsddBaseThermalBridge",
2057 sBaseThermalBridge,
2058 carbonFiberLadderStruct);
2059
2060 vBaseThermalBridge->SetLineColor(fColorCarbonFiber);
2061 return vBaseThermalBridge;
2062};
2063
2064
c789ee28 2065//________________________________________________________________________
b7943f00 2066TGeoVolume* AliITSv11GeometrySDD::CreateEndLadder(Int_t iLay) {
2067 //
2068 // Return a box volume containing a end of a CF ladder.
2069 //
2070
2071 TGeoMedium *airSDD = GetMedium("ITSair");
2072 TGeoMedium *carbonFiberLadderStruct = GetMedium("ITSsddCarbonM55J");
2073
2074 Double_t length = (fgkLay3LadderLength-fgkLay3Ndet*fgkSegmentLength)/2.;
2075 Double_t coolPipeSuppH = fgkLay3CoolPipeSuppH;
2076 Double_t underSegDH = fLay3LadderUnderSegDH;
2077 if (iLay==3) {
2078 } else if (iLay==4) {
2079 length = (fgkLay4LadderLength-fgkLay4Ndet*fgkSegmentLength)/2.;
2080 coolPipeSuppH = fgkLay4CoolPipeSuppH;
2081 underSegDH = fLay4LadderUnderSegDH;
2082 } else {
2083 printf("error in AliITSv11GeometrySDD::CreateEndLadder: Wrong layer");
2084 return 0;
2085 };
c789ee28 2086
b7943f00 2087 Double_t tDY = (- fgkLadderSegBoxDH/2 //space left on top of the ladder
2088 + underSegDH/2); //space under ladder segment
2089 // here tDY is not the same as for the segment because the end ladder
2090 // does not have a space under it, inside the general ladder volume.
2091 Double_t segmentLength = fgkSegmentLength;
2092 Double_t topCornerLength = fgkSegmentLength/2.-fgkLay4LaddTopCornerEnd;
2093
2094 TGeoBBox *endBox = new TGeoBBox("ITSsddEndLaddBox",
2095 (fgkLadderWidth)/2,
2096 fgkLadderHeight/2+fgkLadderSegBoxDH/2+underSegDH/2,
2097 length/2);
2098 TGeoVolume *virtualEnd = new TGeoVolume("ITSsddEnd",endBox, airSDD);
2099
2100 //**********************************
2101 // coding real matter :
2102 //**********************************
2103 Double_t triangleHeight = fgkLadderHeight - fgkLadderBeamRadius;
2104 Double_t halfTheta = TMath::ATan( 0.5*fgkLadderWidth/triangleHeight );
2105 Double_t beta = (TMath::Pi()-2.*halfTheta)/4.;
2106 Double_t alpha = TMath::Pi()*3./4. - halfTheta/2.;
2107
2108 //--- The 3 V shape corners of the Carbon Fiber Ladder
2109 //--- the top V
2110 TGeoArb8 *cfLaddTop1 = CreateLadderSide(topCornerLength/2., halfTheta, -1,
2111 fgkLadderLa, fgkLadderHa, fgkLadderl);
2112 TGeoVolume *cfLaddTopVol1 = new TGeoVolume("ITSsddCFladdTopCornerVol1",
2113 cfLaddTop1,carbonFiberLadderStruct);
2114 cfLaddTopVol1->SetLineColor(fColorCarbonFiber);
2115 TGeoArb8 *cfLaddTop2 = CreateLadderSide( topCornerLength/2., halfTheta, 1,
2116 fgkLadderLa, fgkLadderHa, fgkLadderl);
2117 TGeoVolume *cfLaddTopVol2 = new TGeoVolume("ITSsddCFladdTopCornerV2",
2118 cfLaddTop2,carbonFiberLadderStruct);
2119 cfLaddTopVol2->SetLineColor(fColorCarbonFiber);
2120 TGeoTranslation *trTop1 = new TGeoTranslation(0, fgkLadderHeight/2+tDY,
2121 -(length-topCornerLength)/2.);
2122 virtualEnd->AddNode(cfLaddTopVol1, 1, trTop1);
2123 virtualEnd->AddNode(cfLaddTopVol2, 1, trTop1);
2124
2125 //--- the 2 side V
2126 TGeoArb8 *cfLaddSide1 = CreateLadderSide( length/2., beta, -1,
2127 fgkLadderLb, fgkLadderHb, fgkLadderl);
2128 TGeoVolume *cfLaddSideVol1 = new TGeoVolume("ITSsddCFladdSideCornerV1",
2129 cfLaddSide1,carbonFiberLadderStruct);
2130 cfLaddSideVol1->SetLineColor(fColorCarbonFiber);
2131 TGeoArb8 *cfLaddSide2 = CreateLadderSide( length/2., beta, 1,
2132 fgkLadderLb, fgkLadderHb, fgkLadderl);
2133 TGeoVolume *cfLaddSideVol2 = new TGeoVolume("ITSsddCFladdSideCornerV2",
2134 cfLaddSide2,carbonFiberLadderStruct);
2135 cfLaddSideVol2->SetLineColor(fColorCarbonFiber);
2136 Double_t dYTranslation = ( fgkLadderHeight/2. - 0.5*fgkLadderWidth*
2137 TMath::Tan(beta) - fgkLadderBeamRadius );
2138
2139 // because center of the triangle doesn't correspond to virtual vol. center
2140 Double_t distCenterSideDown = 0.5*fgkLadderWidth/TMath::Cos(beta);
2141 TGeoCombiTrans *ctSideR = CreateCombiTrans("", distCenterSideDown, 0,
2142 alpha*TMath::RadToDeg());
2143 AddTranslationToCombiTrans(ctSideR, 0, -dYTranslation+tDY, 0);
2144 TGeoCombiTrans *ctSideL = CreateCombiTrans("", distCenterSideDown, 0,
2145 -alpha*TMath::RadToDeg());
2146 AddTranslationToCombiTrans(ctSideL, 0, -dYTranslation+tDY, 0);
2147 virtualEnd->AddNode(cfLaddSideVol1, 1, ctSideR);
2148 virtualEnd->AddNode(cfLaddSideVol2, 1, ctSideR);
2149 virtualEnd->AddNode(cfLaddSideVol1, 2, ctSideL);
2150 virtualEnd->AddNode(cfLaddSideVol2, 2, ctSideL);
2151
2152 //--- The beams
2153 // Beams on the sides
2154 Double_t beamPhiPrime = TMath::ASin(1./TMath::Sqrt( (1+TMath::Sin(2*beta)*
2155 TMath::Sin(2*beta)/(TanD(fgkBeamSidePhi)*TanD(fgkBeamSidePhi))) ));
2156
2157 //Euler rotation : about Z, then new X, then new Z
2158 TGeoRotation beamRot1("", 90-2.*beta*TMath::RadToDeg(),
2159 -beamPhiPrime*TMath::RadToDeg(), -90);
2160 TGeoRotation beamRot2("", 90-2.*beta*TMath::RadToDeg(),
2161 beamPhiPrime*TMath::RadToDeg(), -90);
2162 TGeoRotation beamRot3("", 90+2.*beta*TMath::RadToDeg(),
2163 beamPhiPrime*TMath::RadToDeg(), -90);
2164 TGeoRotation beamRot4("", 90+2.*beta*TMath::RadToDeg(),
2165 -beamPhiPrime*TMath::RadToDeg(), -90);
2166 TGeoCombiTrans *beamTransf1 = new TGeoCombiTrans(0.5*triangleHeight*
2167 TMath::Tan(halfTheta),
2168 fgkLadderBeamRadius/2. + tDY,
2169 -length/2 + segmentLength/8, &beamRot1);
2170 TGeoCombiTrans *beamTransf3 = new TGeoCombiTrans( 0.5*triangleHeight*
2171 TMath::Tan(halfTheta),
2172 fgkLadderBeamRadius/2.+tDY,
2173 -length/2 + 3*segmentLength/8, &beamRot2);
2174 TGeoCombiTrans *beamTransf5 = new TGeoCombiTrans(-0.5*triangleHeight*
2175 TMath::Tan(halfTheta),
2176 fgkLadderBeamRadius/2.+tDY,
2177 -length/2 + segmentLength/8, &beamRot3);
2178 TGeoCombiTrans *beamTransf7 = new TGeoCombiTrans(-0.5*triangleHeight*
2179 TMath::Tan(halfTheta),
2180 fgkLadderBeamRadius/2. + tDY,
2181 -length/2+3*segmentLength/8, &beamRot4);
2182
2183 virtualEnd->AddNode(fLaddSegCommonVol[6], 1, beamTransf1);
2184 virtualEnd->AddNode(fLaddSegCommonVol[6], 2, beamTransf3);
2185 virtualEnd->AddNode(fLaddSegCommonVol[6], 3, beamTransf5);
2186 virtualEnd->AddNode(fLaddSegCommonVol[6], 4, beamTransf7);
2187
2188 //--- Beams of the bottom
2189 TGeoTubeSeg *bottomBeam1 = new TGeoTubeSeg(0, fgkLadderBeamRadius,
2190 fgkLadderWidth/2.-fgkLadderLb/3, 0, 180);
2191 TGeoVolume *bottomBeam1Vol = new TGeoVolume("ITSsddBottomBeam1Vol",
2192 bottomBeam1, carbonFiberLadderStruct);
2193 bottomBeam1Vol->SetLineColor(fColorCarbonFiber);
2194
2195 TGeoRotation bottomBeamRot1("",90, 90, 90);
2196 TGeoCombiTrans *bottomBeamTransf1 = new TGeoCombiTrans(0,
2197 -(fgkLadderHeight/2-fgkLadderBeamRadius)+tDY,
2198 -length/2+fgkSegmentLength/2, &bottomBeamRot1);
2199 virtualEnd->AddNode(bottomBeam1Vol, 1, bottomBeamTransf1);
2200 TGeoTubeSeg *bottomBeam2 = new TGeoTubeSeg(0, fgkLadderBeamRadius,
2201 fgkLadderWidth/2.-fgkLadderLb/3, 0, 90);
2202 TGeoVolume *bottomBeam2Vol = new TGeoVolume("ITSsddBottomBeam2Vol",
2203 bottomBeam2, carbonFiberLadderStruct);
2204 bottomBeam2Vol->SetLineColor(fColorCarbonFiber);
2205 TGeoCombiTrans *bottomBeamTransf2 = new TGeoCombiTrans(0,
2206 -(fgkLadderHeight/2-fgkLadderBeamRadius)+tDY,-length/2,&bottomBeamRot1);
2207 virtualEnd->AddNode(bottomBeam2Vol, 1, bottomBeamTransf2);
2208
2209 //**********************************
2210 //the cooling pipe supports
2211 Double_t triangleCPaxeDist = fgkCoolPipeSuppAxeDist-fgkCoolPipeSuppWidthExt-
2212 fgkCoolPipeSuppWidthIn+fgkLadderBeamRadius;
2213
2214 Double_t coolPipeSuppL = TMath::Tan(halfTheta)*
2215 (triangleHeight+triangleCPaxeDist/
2216 TMath::Sin(halfTheta) - coolPipeSuppH);
2217
2218 if (fAddCoolingSyst) {
2219 TGeoRotation rotCPS2("",-halfTheta*TMath::RadToDeg(),-90, 90);
2220 TGeoRotation rotCPS1("", halfTheta*TMath::RadToDeg(),-90,-90);
2221 TGeoCombiTrans *transCPS1 = new TGeoCombiTrans(coolPipeSuppL,
2222 -fgkLadderHeight/2.-TMath::Abs(tDY)+
2223 coolPipeSuppH+fgkLadderBeamRadius,
2224 -length/2., &rotCPS1);
2225 TGeoCombiTrans *transCPS4 = new TGeoCombiTrans(-coolPipeSuppL,
2226 -fgkLadderHeight/2.-TMath::Abs(tDY)+
2227 coolPipeSuppH+fgkLadderBeamRadius,
2228 -length/2., &rotCPS2);
2229
2230 virtualEnd->AddNode(fCoolPipeSupportL, 1, transCPS1);
2231 virtualEnd->AddNode(fCoolPipeSupportR, 1, transCPS4);
2232 };
2233
2234 //**********************************
2235 if(GetDebug(1)) virtualEnd->CheckOverlaps(0.01);
2236 //virtualEnd->SetVisibility(kFALSE);
2237 return virtualEnd;
db486a6e 2238};
c789ee28 2239
2240
db486a6e 2241//________________________________________________________________________
2242TGeoVolume* AliITSv11GeometrySDD::CreateSDDsensor() {
b7943f00 2243 //
2244 // return a box containing the SDD sensor
2245 //
2246
2247 TGeoMedium *airSDD = GetMedium("ITSair");
2248 TGeoMedium *siliconSDD = GetMedium("ITSsddSi");
2249 TGeoMedium *alSDD = GetMedium("ITSal");
2250 TGeoMedium *polyhamideSDD = GetMedium("ITSsddKAPTON_POLYCH2");
2251 TGeoMedium *glassSDD = GetMedium("ITSsddSi"); // To code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2252
2253
2254 Double_t rWraping = fgkWaferThickness/2+fgkWaHVcableAlThick+fgkWaHVcablePolyThick;
2255 Double_t witdhCableBox = (fgkWaHVcableWitdh - TMath::Pi()*rWraping)/2;
2256
2257 Double_t sensoxBoxLength = ( fgkWaferLength +
2258 2*(rWraping+witdhCableBox-fgkWaHVcableDW) );
2259 // Makes life easier to include the space for the WA HV cable on both sides
2260 Double_t sensoxBoxThick = fgkWaferThickness +
2261 2*(fgkWaHVcableAlThick+fgkWaHVcablePolyThick);
2262
2263 TGeoBBox *box = new TGeoBBox("ITSsddSensorBox",
2264 fgkWaferWidth/2, sensoxBoxThick/2, sensoxBoxLength/2);
2265 TGeoVolume *virtualSensor = new TGeoVolume("ITSsddSensor",box,airSDD);
2266
2267 //****************************
2268 // silicon wafer
2269 //****************************
2270 if (fAddSensors) {
c789ee28 2271 TGeoBBox *waferShape = new TGeoBBox("ITSsddWaferShape",
b7943f00 2272 fgkWaferWidth/2, fgkWaferThickness/2, fgkWaferLength/2);
2273 TGeoVolume *wafer = new TGeoVolume("ITSsddWafer", waferShape, siliconSDD);
2274 wafer->SetLineColor(fColorSilicon);
2275 TGeoBBox *sensBox = new TGeoBBox("ITSsddSensorSensBox",
2276 fgkWaferWidthSens/2,fgkWaferThickSens/2,fgkWaferLengthSens/2);
2277 TGeoVolume *sensVol=new TGeoVolume(fgSDDsensitiveVolName,sensBox,siliconSDD);
2278 sensVol->SetLineColor(fColorSilicon);
2279
2280 wafer->AddNode(sensVol, 1, 0);
2281 virtualSensor->AddNode(wafer, 1, 0);
2282 };
2283
2284 //****************************
2285 // glass
2286 //****************************
2287 TGeoBBox *glass = new TGeoBBox("ITSsddGlassBox", fgkSensorGlassLX/2,
2288 fgkSensorGlassLY/2, fgkSensorGlassLZ/2);
2289 TGeoVolume *vGlass = new TGeoVolume("ITSsddGlass",glass, glassSDD);
2290 vGlass->SetLineColor(fColorGlass);
2291 TGeoTranslation *glassTr1 = new TGeoTranslation("",fgkGlassDXOnSensor,
2292 fgkWaferThickness/2+fgkSensorGlassLY/2,
2293 fgkGlassDZOnSensor);
2294 TGeoTranslation *glassTr2 = new TGeoTranslation("",-fgkGlassDXOnSensor,
2295 fgkWaferThickness/2+fgkSensorGlassLY/2,
2296 fgkGlassDZOnSensor);
2297 TGeoTranslation *glassTr3 = new TGeoTranslation("",fgkGlassDXOnSensor,
2298 fgkWaferThickness/2+fgkSensorGlassLY/2,
2299 -fgkGlassDZOnSensor);
2300 TGeoTranslation *glassTr4 = new TGeoTranslation("",-fgkGlassDXOnSensor,
2301 fgkWaferThickness/2+fgkSensorGlassLY/2,
2302 -fgkGlassDZOnSensor);
2303 virtualSensor->AddNode(vGlass, 1, glassTr1);
2304 virtualSensor->AddNode(vGlass, 2, glassTr2);
2305 virtualSensor->AddNode(vGlass, 3, glassTr3);
2306 virtualSensor->AddNode(vGlass, 4, glassTr4);
2307
2308 //****************************
2309 // Wrap-around cable
2310 //****************************
2311 if (fAddHVcables) {
2312 AliITSv11GeomCableFlat waHVCable("ITSsddWaHVCableU",witdhCableBox,
2313 fgkWaHVcableAlThick+fgkWaHVcablePolyThick);
2314 waHVCable.SetNLayers(2);
2315 waHVCable.SetLayer(0, fgkWaHVcablePolyThick,polyhamideSDD,fColorPolyhamide);
2316 waHVCable.SetLayer(1, fgkWaHVcableAlThick, alSDD, fColorAl);
2317 waHVCable.SetInitialNode(virtualSensor);
2318
2319 Double_t x1[3], x2[3], vX[3] = {1,0,0};
2320 x1[0] = -fgkWaHVcableLength/2;
2321 x2[0] = -x1[0];
2322 x1[1] = (fgkWaferThickness + waHVCable.GetThickness())/2;
2323 x2[1] = x1[1];
2324 x1[2] = fgkWaferLength/2+waHVCable.GetWidth()/2-fgkWaHVcableDW;
2325 x2[2] = x1[2];
2326
2327 waHVCable.AddCheckPoint(virtualSensor, 0, x1, vX);
2328 waHVCable.AddCheckPoint(virtualSensor, 1, x2, vX);
2329 waHVCable.CreateAndInsertCableSegment(1,-90);
2330 x1[1] = -x1[1];
2331 x2[1] = x1[1];
2332 waHVCable.SetName("ITSsddWaHVCableD");
2333 waHVCable.ResetPoints();
2334 waHVCable.AddCheckPoint(virtualSensor, 0, x1, vX);
2335 waHVCable.AddCheckPoint(virtualSensor, 1, x2, vX);
2336 waHVCable.CreateAndInsertCableSegment(1, 90);
2337
2338 AliITSv11GeomCableRound waHVCableFold("ITSsddWaHVCableFold",
2339 rWraping);
2340 waHVCableFold.SetPhi(180,360);
2341 waHVCableFold.SetNLayers(2);
2342 waHVCableFold.SetLayer(0, fgkWaferThickness/2+fgkWaHVcablePolyThick,
2343 polyhamideSDD, fColorPolyhamide);
2344 waHVCableFold.SetLayer(1, fgkWaHVcableAlThick, alSDD, fColorAl);
2345 waHVCableFold.SetInitialNode(virtualSensor);
2346 x1[1] = 0;
2347 x2[1] = 0;
2348 x1[2] = fgkWaferLength/2-fgkWaHVcableDW+witdhCableBox;
2349 x2[2] = x1[2];
2350 waHVCableFold.AddCheckPoint(virtualSensor, 0, x1, vX);
2351 waHVCableFold.AddCheckPoint(virtualSensor, 1, x2, vX);
2352 waHVCableFold.CreateAndInsertCableSegment(1);
2353
2354 //****************************
2355 // transition cable
2356 //****************************
2357 Double_t headRadius = (fgkTransitHVHeadLX*fgkTransitHVHeadLX/4.+
2358 fgkTransitHVHeadLZ*fgkTransitHVHeadLZ)
2359 /(2.*fgkTransitHVHeadLZ);
2360 Double_t theta = TMath::ATan2(fgkTransitHVHeadLX/2,
2361 headRadius-fgkTransitHVHeadLZ)
2362 *TMath::RadToDeg();
2363
2364 TGeoTubeSeg *headPoly = new TGeoTubeSeg(0,headRadius,
2365 fgkTransitHVPolyThick/2,
2366 90-theta,90+theta);
2367 headPoly->SetName("headPoly");
2368 TGeoTranslation *headPolyTr = new TGeoTranslation(0,0,
2369 -fgkTransitHVPolyThick/2);
2370 headPolyTr->SetName("headPolyTr");
2371 headPolyTr->RegisterYourself();
2372
2373 TGeoTubeSeg *headAl = new TGeoTubeSeg(0,headRadius,
2374 fgkTransitHVAlThick/2,
2375 90-theta,90+theta);
2376 headAl->SetName("headAl");
2377 TGeoTranslation *headAlTr = new TGeoTranslation(0,0,
2378 -fgkTransitHVPolyThick
2379 -fgkTransitHVAlThick/2);
2380 headAlTr->SetName("headAlTr");
2381 headAlTr->RegisterYourself();
2382
2383 TGeoBBox *cache = new TGeoBBox(fgkTransitHVHeadLX/2,
2384 (headRadius-fgkTransitHVHeadLZ)/2,
2385 (fgkTransitHVPolyThick+fgkTransitHVAlThick)/2);
2386 cache->SetName("cache");
2387
2388 TGeoTranslation *headCacheTr = new TGeoTranslation(0,
2389 (headRadius-fgkTransitHVHeadLZ)/2,
2390 -(fgkTransitHVPolyThick
2391 +fgkTransitHVAlThick)/2);
2392 headCacheTr->SetName("cacheTr");
2393 headCacheTr->RegisterYourself();
2394
2395 TGeoCompositeShape *headPolyComp = new TGeoCompositeShape(
2396 "headPoly:headPolyTr-cache:cacheTr");
2397 TGeoVolume *vHeadPolyComp = new TGeoVolume(
2398 "ITSsddHVtransitHeadPoly",headPolyComp, polyhamideSDD);
2399 vHeadPolyComp->SetLineColor(fColorPolyhamide);
2400 TGeoCompositeShape *headAlComp = new TGeoCompositeShape(
2401 "headAl:headAlTr-cache:cacheTr");
2402 TGeoVolume *vHeadAlComp = new TGeoVolume(
2403 "ITSsddHVtransitHeadAl",headAlComp, alSDD);
2404 vHeadAlComp->SetLineColor(fColorAl);
2405
2406
2407 TGeoRotation rotHead("",0,90,0);
2408 TGeoCombiTrans *rotHeadTr = new TGeoCombiTrans(0,fgkWaferThickness/2,
2409 -headRadius+fgkTransitHVHeadLZ+fgkTransitHVBondingLZ/2,
2410 &rotHead);
2411 virtualSensor->AddNode(vHeadPolyComp,1,rotHeadTr);
2412 virtualSensor->AddNode(vHeadAlComp,1,rotHeadTr);
2413
2414 //---
2415 AliITSv11GeomCableFlat transitHVCable("ITSsddHVtransitCenter",
2416 fgkTransitHVBondingLZ,
2417 fgkTransitHVPolyThick+fgkTransitHVAlThick);
2418 transitHVCable.SetNLayers(2);
2419 transitHVCable.SetLayer(0, fgkTransitHVPolyThick,polyhamideSDD,
2420 fColorPolyhamide);
2421 transitHVCable.SetLayer(1, fgkTransitHVAlThick, alSDD, fColorAl);
2422 transitHVCable.SetInitialNode(virtualSensor);
2423
2424 x1[0] = -fgkTransitHVHeadLX/2;
2425 x2[0] = -x1[0];
2426 x1[1] = (fgkWaferThickness+fgkTransitHVPolyThick+fgkTransitHVAlThick)/2;
2427 x2[1] = x1[1];
2428 x1[2] = 0;
2429 x2[2] = 0;
2430 transitHVCable.AddCheckPoint(virtualSensor, 0, x1, vX);
2431 transitHVCable.AddCheckPoint(virtualSensor, 1, x2, vX);
2432 transitHVCable.CreateAndInsertCableSegment(1,-90);
2433 transitHVCable.ResetPoints();
2434 transitHVCable.SetName("ITSsddHVtransitTail");
2435 transitHVCable.SetWidth(fgkTransitHVtailWidth);
2436 x1[0] = fgkTransitHVtailXpos;
2437 x2[0] = fgkTransitHVtailXpos;
2438 x1[2] = -fgkTransitHVBondingLZ/2;
2439 x2[2] = -fgkTransitHVBondingLZ/2-fgkTransitHVtailLength;
2440 Double_t vZ[3] = {0,0,1};
2441 transitHVCable.AddCheckPoint(virtualSensor, 0, x1, vZ);
2442 transitHVCable.AddCheckPoint(virtualSensor, 1, x2, vZ);
2443 transitHVCable.CreateAndInsertCableSegment(1,0);
2444
2445 //---
2446 TGeoArb8 *sideLeft = new TGeoArb8( fgkTransitHVPolyThick/2 );
2447 sideLeft->SetVertex(0, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,0);
2448 sideLeft->SetVertex(1, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,
2449 fgkTransitHVsideLZ);
2450 sideLeft->SetVertex(2, fgkTransitHVHeadLX/2, fgkTransitHVsideLeftZ);
2451 sideLeft->SetVertex(3, fgkTransitHVHeadLX/2, 0);
2452 sideLeft->SetVertex(4, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,0);
2453 sideLeft->SetVertex(5, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,
2454 fgkTransitHVsideLZ);
2455 sideLeft->SetVertex(6, fgkTransitHVHeadLX/2, fgkTransitHVsideLeftZ);
2456 sideLeft->SetVertex(7, fgkTransitHVHeadLX/2, 0);
2457
2458 TGeoArb8 *sideLeftAl = new TGeoArb8( fgkTransitHVAlThick/2 );
2459 sideLeftAl->SetVertex(0, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,0);
2460 sideLeftAl->SetVertex(1, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,
2461 fgkTransitHVsideLZ);
2462 sideLeftAl->SetVertex(2, fgkTransitHVHeadLX/2, fgkTransitHVsideLeftZ);
2463 sideLeftAl->SetVertex(3, fgkTransitHVHeadLX/2, 0);
2464 sideLeftAl->SetVertex(4, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,0);
2465 sideLeftAl->SetVertex(5, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,
2466 fgkTransitHVsideLZ);
2467 sideLeftAl->SetVertex(6, fgkTransitHVHeadLX/2, fgkTransitHVsideLeftZ);
2468 sideLeftAl->SetVertex(7, fgkTransitHVHeadLX/2, 0);
2469
2470 TGeoArb8 *sideRight = new TGeoArb8( fgkTransitHVPolyThick/2 );
2471 sideRight->SetVertex(0, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,0);
2472 sideRight->SetVertex(1, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,
2473 fgkTransitHVsideLZ);
2474 sideRight->SetVertex(2, -fgkTransitHVHeadLX/2, fgkTransitHVsideRightZ);
2475 sideRight->SetVertex(3, -fgkTransitHVHeadLX/2, 0);
2476 sideRight->SetVertex(4, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,0);
2477 sideRight->SetVertex(5, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,
2478 fgkTransitHVsideLZ);
2479 sideRight->SetVertex(6, -fgkTransitHVHeadLX/2, fgkTransitHVsideRightZ);
2480 sideRight->SetVertex(7, -fgkTransitHVHeadLX/2, 0);
2481
2482 TGeoRotation rotSide("",0,-90,0);
2483 TGeoCombiTrans *sideRightTr = new TGeoCombiTrans(0,
2484 (fgkWaferThickness+fgkTransitHVPolyThick)/2,
2485 -fgkTransitHVBondingLZ/2,&rotSide);
2486 TGeoCombiTrans *sideLeftTr = new TGeoCombiTrans(0,
2487 (fgkWaferThickness+fgkTransitHVPolyThick)/2,
2488 -fgkTransitHVBondingLZ/2, &rotSide);
2489 TGeoCombiTrans *sideLeftAlTr = new TGeoCombiTrans(0,
2490 fgkTransitHVPolyThick+(fgkWaferThickness+fgkTransitHVAlThick)/2,
2491 -fgkTransitHVBondingLZ/2, &rotSide);
2492
2493 TGeoVolume *vSideLeft = new TGeoVolume("ITSsddHVtransitSideLeft",
2494 sideLeft,polyhamideSDD);
2495 vSideLeft->SetLineColor(fColorPolyhamide);
2496 TGeoVolume *vSideLeftAl = new TGeoVolume("ITSsddHVtransitSideLeftAl",
2497 sideLeftAl,alSDD);
2498 vSideLeftAl->SetLineColor(fColorAl);
2499 TGeoVolume *vSideRight = new TGeoVolume("ITSsddHVtransitSideRight",
2500 sideRight,polyhamideSDD);
2501 vSideRight->SetLineColor(fColorPolyhamide);
2502
2503 virtualSensor->AddNode(vSideLeft, 1, sideLeftTr);
2504 virtualSensor->AddNode(vSideLeftAl, 1, sideLeftAlTr);
2505 virtualSensor->AddNode(vSideRight, 1, sideRightTr);
2506 };
db486a6e 2507
b7943f00 2508 //****************************
2509 if(GetDebug(1)) virtualSensor->CheckOverlaps(0.01);
2510 virtualSensor->SetVisibility(kFALSE);
2511 return virtualSensor;
db486a6e 2512};
c789ee28 2513
2514
db486a6e 2515//________________________________________________________________________
b7943f00 2516TGeoVolume *AliITSv11GeometrySDD::CreateDetectors(Int_t iLay) {
2517 //
2518 // return a box volume containing the detectors
2519 //
2520
2521 TGeoMedium *airSDD = GetMedium("ITSair");
c789ee28 2522
b7943f00 2523 Int_t nDetectors = fgkLay3Ndet;
2524 Double_t ladderLength = fgkLay3LadderLength;
2525 Double_t *sensorZPos = fLay3sensorZPos;
2526
2527 if (iLay==3) {}
2528 else if (iLay==4) {
2529 nDetectors = fgkLay4Ndet;
2530 ladderLength = fgkLay4LadderLength;
2531 sensorZPos = fLay4sensorZPos;
2532 } else {
2533 printf("AliITSv11GeometrySDD::CreateLay3Detectors: Error : Wrong layer");
2534 };
2535
2536 char name[30];
2537 Double_t volThickness = ( fgkLadWaferSep + 2*fgkWaferThickness +
2538 2*(fgkWaHVcableAlThick+fgkWaHVcablePolyThick));
2539
2540 sprintf(name,"ITSsddDetBox%i",iLay);
2541 TGeoBBox *detBox = new TGeoBBox(name, fgkWaferWidth/2, volThickness/2,
2542 ladderLength*((nDetectors-0.5)/nDetectors)/2);
2543 TGeoVolume *virtualDet = new TGeoVolume("ITSsddLadd",detBox, airSDD);
2544
2545 for (Int_t i=0; i<nDetectors; i++) {
2546 Double_t localZ = sensorZPos[i];
2547 Double_t localY = fgkLadWaferSep/2+fgkWaferThickness/2;
2548 if (iLay==3) if (i%2!=0) localY = -localY;
2549 if (iLay==4) if (i%2==0) localY = -localY;
2550 sprintf(name, "ITSsddLay%iSensorPos%i",iLay, i);
2551 Double_t rotationY = 180;
2552 if (i >= nDetectors/2) rotationY = 0;
2553 TGeoRotation rotSensor("",0, rotationY, 0);
2554 TGeoCombiTrans *sensorPos = new TGeoCombiTrans(0,localY,
2555 localZ,&rotSensor);
2556 sensorPos->SetName(name);
2557 virtualDet->AddNode(fSDDsensor, i, sensorPos);
db486a6e 2558 }
b7943f00 2559
2560 if(GetDebug(1)) virtualDet->CheckOverlaps(0.01);
2561 //virtualDet->SetVisibility(kFALSE);
db486a6e 2562 return virtualDet;
2563};
c789ee28 2564
2565
b7943f00 2566
db486a6e 2567//________________________________________________________________________
b7943f00 2568Int_t AliITSv11GeometrySDD::ExportSensorGeometry(AliITSgeom *geom, Int_t iLaySDD,
2569 Int_t startMod) {
2570 //
2571 // export the geometry in a AliITSgeom object
2572 //
2573
2574 if (! geom) {
2575 printf("error:Try to fill null (AliITSgeom *) object");
2576 return kFALSE;
2577 };
2578 if (! fMotherVol) {
2579 printf("error:Try to set sensor geometry while geometry is not defined\n");
2580 return kFALSE;
2581 };
c789ee28 2582
b7943f00 2583 Int_t firstSDDmod = startMod;
2584 const Float_t kDxyz[3] = {fgkWaferWidthSens, fgkWaferThickSens, fgkWaferLengthSens};
2585
2586 if(!(geom->IsShapeDefined(kSDD)))
2587 geom->ReSetShape(kSDD, new AliITSgeomSDD256(3, kDxyz));
2588
2589 char layerName[30];
2590 char ladderName[30];
2591 char sensorName[30];
2592 char senstivName[30];
2593 const Int_t kNLay = 2;
2594 const Int_t kNLadd[2] = {fgkLay3Nladd, fgkLay4Nladd};
2595 const Int_t kNDet[2] = {fgkLay3Ndet, fgkLay4Ndet};
2596
2597 if (GetDebug(1))
2598 printf("AliITSv11GeometrySDD::SetSensorGeometry(), nodes found :\n");
2599
2600 for (Int_t iLay=0; iLay<kNLay; iLay++) {
2601 /////////////////////////////////////////
2602 sprintf(layerName, "ITSsddLayer%i_1",iLay+3);
2603 TGeoNode *layNode = fMotherVol->GetNode(layerName);
2604 if (layNode) {
2605 if (GetDebug(1)) printf("%s\n",layNode->GetName());
2606 TGeoVolume *layVolume = layNode->GetVolume();
2607 TGeoHMatrix layMatrix(*layNode->GetMatrix());
2608
2609 for (Int_t iLadd=0; iLadd<kNLadd[iLay]; iLadd++) {
2610 /////////////////////////////////////////
2611 sprintf(ladderName, "ITSsddLadd_%i", iLadd);
2612 TGeoNode *laddNode = layVolume->GetNode(ladderName);
2613 if (laddNode) {
2614 if (GetDebug(1)) printf("| %s\n",laddNode->GetName());
2615 TGeoVolume *laddVolume = laddNode->GetVolume();
2616 TGeoHMatrix laddMatrix(layMatrix);
2617 laddMatrix.Multiply(laddNode->GetMatrix());
2618
2619 for (Int_t iDet=0; iDet<kNDet[iLay]; iDet++) {
2620 /////////////////////////////////////////
2621 sprintf(sensorName, "ITSsddSensor_%i",iDet);
2622 TGeoNode *detNode = laddVolume->GetNode(sensorName);
2623 if (detNode) {
2624 if (GetDebug(1)) printf("| | %s\n",detNode->GetName());
2625 TGeoVolume *detVolume = detNode->GetVolume();
2626 TGeoHMatrix detMatrix(laddMatrix);
2627 detMatrix.Multiply(detNode->GetMatrix());
2628
2629 TGeoNode *wafNode = detVolume->GetNode("ITSsddWafer_1");
2630 if (wafNode) {
2631 TGeoVolume *wafVolume = wafNode->GetVolume();
2632 TGeoHMatrix wafMatrix(detMatrix);
2633 detMatrix.Multiply(wafNode->GetMatrix());
2634 //--------------------------------------------------------
2635 sprintf(senstivName, "%s%s", fgSDDsensitiveVolName,"_1");
2636 TGeoNode *sensitivNode = wafVolume->GetNode(senstivName);
2637 if (sensitivNode) {
2638 TGeoHMatrix sensMatrix(wafMatrix);
2639 sensMatrix.Multiply(sensitivNode->GetMatrix());
2640
2641 Double_t *trans = sensMatrix.GetTranslation();
2642 Double_t *r = sensMatrix.GetRotationMatrix();
2643 Double_t rot[10] = {r[0],r[1],r[2],
2644 r[3],r[4],r[5],
2645 r[6],r[7],r[8], 0.0};
2646 //rot[9]=0.0 => not a unity matrix
2647 geom->CreatMatrix(startMod,iLay+iLaySDD,iLadd+1,iDet+1,
2648 kSDD,trans,rot);
2649 // iLadd+1, iDet+1 because ladd. and det. start at +1
2650 // elsewhere
2651 startMod++;
2652 } else
2653 printf("Error (ExportSensorGeometry) %s not found !\n",
2654 senstivName);
2655 } else
2656 printf("Error (ExportSensorGeometry) %s not found !\n",
2657 "ITSsddWafer_1");
2658 } else
2659 printf("Error (ExportSensorGeometry) %s not found !\n",
2660 sensorName);
2661 };
2662 } else
2663 printf("Error (ExportSensorGeometry) %s not found !\n",
2664 ladderName);
2665 };
2666 } else
2667 printf("Error (ExportSensorGeometry) %s not found !\n",
2668 layerName);
2669 };
c789ee28 2670
b7943f00 2671 return (startMod-firstSDDmod);
db486a6e 2672};
c789ee28 2673
2674
b7943f00 2675Int_t AliITSv11GeometrySDD::
2676GetCurrentLayLaddDet(Int_t &lay, Int_t &ladd, Int_t&det) const {
2677 //
2678 // Function which gives the layer, ladder and det.
2679 // index of the current volume. To be used in
2680 // AliITS::StepManager()
2681 //
c789ee28 2682
b7943f00 2683 if (gGeoManager->GetLevel()<3) return kFALSE;
2684 // Get the det index :
2685 TGeoNode *node = gGeoManager->GetMother(2);
2686 if (!node) return kFALSE;
2687 det = node->GetNumber()+1;
c789ee28 2688
b7943f00 2689 // Get the ladder index :
2690 node = gGeoManager->GetMother(3);
2691 if (!node) return kFALSE;
2692 ladd = node->GetNumber()+1;
2693
2694 // Get the layer index :
2695 if (node->GetNdaughters()==fgkLay3Ndet)
2696 lay = 1;
2697 else lay = 2;
2698
2699 return kTRUE;
db486a6e 2700};