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