| db486a6e |
1 | /************************************************************************** |
| 59da35b6 |
2 | * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. * |
| db486a6e |
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 | **************************************************************************/ |
| 592651e2 |
15 | // |
| db486a6e |
16 | // This class Defines the Geometry for the ITS services and support cones |
| d0048cec |
17 | // outside of the central volume (except for the Central support |
| 54c9a3d9 |
18 | // cylinders). Other classes define the rest of the ITS, specifically the |
| 19 | // SSD support cone, the SSD Support central cylinder, the SDD support cone, |
| 20 | // the SDD support central cylinder, the SPD Thermal Shield, The supports |
| db486a6e |
21 | // and cable trays on both the RB26 (muon dump) and RB24 sides, and all of |
| 592651e2 |
22 | // the cabling from the ladders/stave ends out past the TPC. |
| 23 | // |
| 54c9a3d9 |
24 | // Here is the calling sequence associated with this file |
| 25 | // SPDSector(TGeoVolume *moth,TGeoManager *mgr) |
| 26 | // -----CarbonFiberSector(TGeoVolume *moth,Double_t &xAAtubeCenter0, |
| 27 | // Double_t &yAAtubeCenter0,TGeoManager *mgr) |
| 28 | // -----2* SPDsectorShape(Int_t n,const Double_t *xc,const Double_t *yc, |
| 29 | // | const Double_t *r,const Double_t *ths, |
| 30 | // | const Double_t *the,Int_t npr,Int_t &m, |
| 31 | // | Double_t **xp,Double_t **yp) |
| 32 | // -----StavesInSector(TGeoVolume *moth,TGeoManager *mgr) |
| 33 | // -----3* CreaeStave(Int_t layer,TArrayD &sizes,Bool_t addClips, |
| 34 | // | TGeoManager *mgr) |
| 35 | // | -----2* CreateHalfStave(Boot_t isRight,Int_t layer, |
| 36 | // | Int_t idxCentral,Int_t idxSide, |
| 37 | // | TArrayD &sizes,Bool_t addClips, |
| 38 | // | TGeoManager *mgr) |
| 39 | // | -----CreateGrondingFoil(Bool_t isRight,TArrayD &sizes, |
| 40 | // | | TGeoManager *mgr) |
| 41 | // | | -----4* CreateGroundingFoilSingle(Int_t type, |
| 42 | // | | TArrayD &sizes, |
| 43 | // | | TGeoManger *mgr) |
| 44 | // | |----CreateLadder(Int_t layer, TArrayD &sizes, |
| 45 | // | | TGeoManager *mgr) |
| 46 | // | |----CreateMCM(Bool_t isRight,TArrayD &sizes, |
| 47 | // | | TGeoManger *mgr) |
| 48 | // | |----CreatePixelBus(Bool_t isRight,TArrayD &sizes, |
| 49 | // | | TGeoManager *mgr) |
| 50 | // | -----CreateClip(TArrayD &sizes,TGeoManager *mgr) |
| 51 | // |----GetSectorMountingPoints(Int_t index,Double_t &x0, |
| 52 | // | Double_t &y0,Double_t &x1, |
| 53 | // | Double_t y1) |
| 54 | // -----3* ParallelPosition(Double_t dist1,Double_t dist2, |
| 55 | // Double_t phi,Double_t &x,Double_t &y) |
| 56 | // |
| 57 | // Obsoleate or presently unused routines are: setAddStave(Bool_t *mask), |
| 58 | // CreatePixelBusAndExtensions(...) which calles CreateExtender(...). |
| db486a6e |
59 | |
| 543b7370 |
60 | /* $Id$ */ |
| 592651e2 |
61 | |
| 4098f5dd |
62 | |
| db486a6e |
63 | // General Root includes |
| 64 | #include <Riostream.h> |
| 65 | #include <TMath.h> |
| 66 | #include <TLatex.h> |
| 67 | #include <TCanvas.h> |
| 68 | #include <TPolyLine.h> |
| 297369a1 |
69 | #include <TPolyMarker.h> |
| bc3498f4 |
70 | |
| db486a6e |
71 | // Root Geometry includes |
| f7a1cc68 |
72 | #include <TGeoCompositeShape.h> |
| db486a6e |
73 | #include <TGeoEltu.h> |
| f7a1cc68 |
74 | #include <TGeoGlobalMagField.h> |
| a53658c6 |
75 | #include <TGeoMaterial.h> |
| f7a1cc68 |
76 | #include <TGeoMatrix.h> |
| a53658c6 |
77 | #include <TGeoMedium.h> |
| f7a1cc68 |
78 | #include <TGeoTube.h> // contains TGeoTubeSeg |
| 79 | #include <TGeoVolume.h> |
| 80 | #include <TGeoXtru.h> |
| bc3498f4 |
81 | |
| 592651e2 |
82 | // AliRoot includes |
| bc3498f4 |
83 | #include "AliLog.h" |
| a53658c6 |
84 | #include "AliMagF.h" |
| 85 | #include "AliRun.h" |
| bc3498f4 |
86 | |
| 592651e2 |
87 | // Declaration file |
| db486a6e |
88 | #include "AliITSv11GeometrySPD.h" |
| 89 | |
| 54c9a3d9 |
90 | // Constant definistions |
| d0048cec |
91 | const Double_t AliITSv11GeometrySPD::fgkGapLadder = |
| 54c9a3d9 |
92 | AliITSv11Geometry::fgkmicron*75.; // 75 microns |
| d0048cec |
93 | const Double_t AliITSv11GeometrySPD::fgkGapHalfStave = |
| 54c9a3d9 |
94 | AliITSv11Geometry::fgkmicron*120.; // 120 microns |
| 7855ea93 |
95 | |
| db486a6e |
96 | ClassImp(AliITSv11GeometrySPD) |
| 54c9a3d9 |
97 | //______________________________________________________________________ |
| 98 | AliITSv11GeometrySPD::AliITSv11GeometrySPD(/*Double_t gap*/): |
| 99 | AliITSv11Geometry(),// Default constructor of base class |
| 100 | fAddStave(), // [DEBUG] must be TRUE for all staves which will be |
| 101 | // mounted in the sector (used to check overlaps) |
| 102 | fSPDsectorX0(0), // X of first edge of sector plane for stave |
| 103 | fSPDsectorY0(0), // Y of first edge of sector plane for stave |
| 104 | fSPDsectorX1(0), // X of second edge of sector plane for stave |
| 105 | fSPDsectorY1(0), // Y of second edge of sector plane for stave |
| d0048cec |
106 | fTubeEndSector() // coordinate of cooling tube ends |
| 54c9a3d9 |
107 | { |
| 108 | // |
| 109 | // Default constructor. |
| d0048cec |
110 | // This does not initialize anything and is provided just for |
| 54c9a3d9 |
111 | // completeness. It is recommended to use the other one. |
| 112 | // The alignment gap is specified as argument (default = 0.0075 cm). |
| 113 | // Inputs: |
| 114 | // none. |
| 115 | // Outputs: |
| 116 | // none. |
| 117 | // Return: |
| 118 | // A default constructed AliITSv11GeometrySPD class. |
| 119 | // |
| 120 | Int_t i = 0,j=0,k=0; |
| db486a6e |
121 | |
| 54c9a3d9 |
122 | for (i = 0; i < 6; i++) fAddStave[i] = kTRUE; |
| 123 | for(k=0;k<10;k++)for(i=0;i<6;i++)for(j=0;j<3;j++){ |
| 124 | this->fTubeEndSector[k][0][i][j] = 0.0; |
| 125 | this->fTubeEndSector[k][1][i][j] = 0.0; |
| 126 | } // end for i,j |
| 127 | } |
| 128 | //______________________________________________________________________ |
| 129 | AliITSv11GeometrySPD::AliITSv11GeometrySPD(Int_t debug/*, Double_t gap*/): |
| 130 | AliITSv11Geometry(debug),// Default constructor of base class |
| 131 | fAddStave(), // [DEBUG] must be TRUE for all staves which will be |
| 132 | // mounted in the sector (used to check overlaps) |
| 133 | fSPDsectorX0(0), // X of first edge of sector plane for stave |
| 134 | fSPDsectorY0(0), // Y of first edge of sector plane for stave |
| 135 | fSPDsectorX1(0), // X of second edge of sector plane for stave |
| 136 | fSPDsectorY1(0), // Y of second edge of sector plane for stave |
| d0048cec |
137 | fTubeEndSector() // coordinate of cooling tube ends |
| 54c9a3d9 |
138 | { |
| 139 | // |
| 140 | // Constructor with debug setting argument |
| 141 | // This is the constructor which is recommended to be used. |
| 142 | // It sets a debug level, and initializes the name of the object. |
| 143 | // The alignment gap is specified as argument (default = 0.0075 cm). |
| 144 | // Inputs: |
| 145 | // Int_t debug Debug level, 0= no debug output. |
| 146 | // Outputs: |
| 147 | // none. |
| 148 | // Return: |
| 149 | // A default constructed AliITSv11GeometrySPD class. |
| 150 | // |
| 151 | Int_t i = 0,j=0,k=0; |
| db486a6e |
152 | |
| 54c9a3d9 |
153 | for (i = 0; i < 6; i++) fAddStave[i] = kTRUE; |
| 154 | for(k=0;k<10;k++)for(i=0;i<6;i++)for(j=0;j<3;j++){ |
| 155 | this->fTubeEndSector[k][0][i][j] = 0.0; |
| 156 | this->fTubeEndSector[k][1][i][j] = 0.0; |
| 157 | } // end for i,j |
| 158 | } |
| 159 | //______________________________________________________________________ |
| 160 | AliITSv11GeometrySPD::AliITSv11GeometrySPD(const AliITSv11GeometrySPD &s): |
| 161 | AliITSv11Geometry(s),// Base Class Copy constructor |
| 162 | fAddStave(), // [DEBUG] must be TRUE for all staves which will be |
| 163 | // mounted in the sector (used to check overlaps) |
| 164 | fSPDsectorX0(s.fSPDsectorX0), // X of first edge of sector plane for stave |
| 165 | fSPDsectorY0(s.fSPDsectorY0), // Y of first edge of sector plane for stave |
| 166 | fSPDsectorX1(s.fSPDsectorX1), // X of second edge of sector plane for stave |
| 167 | fSPDsectorY1(s.fSPDsectorY1) // Y of second edge of sector plane for stave |
| bc3498f4 |
168 | { |
| 54c9a3d9 |
169 | // |
| 170 | // Copy Constructor |
| 171 | // Inputs: |
| 172 | // AliITSv11GeometrySPD &s source class |
| 173 | // Outputs: |
| 174 | // none. |
| 175 | // Return: |
| 176 | // A copy of a AliITSv11GeometrySPD class. |
| 177 | // |
| 178 | Int_t i=0,j=0,k=0; |
| 179 | |
| 180 | for (i = 0; i < 6; i++) this->fAddStave[i] = s.fAddStave[i]; |
| 181 | for(k=0;k<10;k++)for(i=0;i<6;i++)for(j=0;j<3;j++){ |
| 182 | this->fTubeEndSector[k][0][i][j] = s.fTubeEndSector[k][0][i][j]; |
| 183 | this->fTubeEndSector[k][1][i][j] = s.fTubeEndSector[k][1][i][j]; |
| 184 | } // end for i,j |
| bc3498f4 |
185 | } |
| 54c9a3d9 |
186 | //______________________________________________________________________ |
| d0048cec |
187 | AliITSv11GeometrySPD& AliITSv11GeometrySPD::operator=(const |
| 54c9a3d9 |
188 | AliITSv11GeometrySPD &s) |
| bc3498f4 |
189 | { |
| 54c9a3d9 |
190 | // |
| 191 | // = operator |
| 192 | // Inputs: |
| 193 | // AliITSv11GeometrySPD &s source class |
| 194 | // Outputs: |
| 195 | // none. |
| 196 | // Return: |
| 197 | // A copy of a AliITSv11GeometrySPD class. |
| 198 | // |
| 199 | Int_t i=0,j=0,k=0; |
| 200 | |
| 201 | if(this==&s) return *this; |
| 202 | for (i = 0; i < 6; i++) this->fAddStave[i] = s.fAddStave[i]; |
| 203 | this->fSPDsectorX0=s.fSPDsectorX0; |
| 204 | this->fSPDsectorY0=s.fSPDsectorY0; |
| 205 | this->fSPDsectorX1=s.fSPDsectorX1; |
| 206 | this->fSPDsectorY1=s.fSPDsectorY1; |
| 207 | for(k=0;k<10;k++)for(i=0;i<6;i++)for(j=0;j<3;j++){ |
| 208 | this->fTubeEndSector[k][0][i][j] = s.fTubeEndSector[k][0][i][j]; |
| 209 | this->fTubeEndSector[k][1][i][j] = s.fTubeEndSector[k][1][i][j]; |
| 210 | } // end for i,j |
| 211 | return *this; |
| bc3498f4 |
212 | } |
| 54c9a3d9 |
213 | //______________________________________________________________________ |
| 214 | TGeoMedium* AliITSv11GeometrySPD::GetMedium(const char* mediumName, |
| 215 | TGeoManager *mgr) const |
| bc3498f4 |
216 | { |
| 54c9a3d9 |
217 | // |
| d0048cec |
218 | // This function is used to recovery any medium |
| 219 | // used to build the geometry volumes. |
| 220 | // If the required medium does not exists, |
| 54c9a3d9 |
221 | // a NULL pointer is returned, and an error message is written. |
| 222 | // |
| 223 | Char_t itsMediumName[30]; |
| 224 | |
| 225 | sprintf(itsMediumName, "ITS_%s", mediumName); |
| 226 | TGeoMedium* medium = mgr->GetMedium(itsMediumName); |
| 227 | if (!medium) AliError(Form("Medium <%s> not found", mediumName)); |
| 228 | |
| 229 | return medium; |
| bc3498f4 |
230 | } |
| 54c9a3d9 |
231 | //______________________________________________________________________ |
| 232 | Int_t AliITSv11GeometrySPD::CreateSPDCentralMaterials(Int_t &medOffset, |
| 233 | Int_t &matOffset) const |
| 592651e2 |
234 | { |
| 54c9a3d9 |
235 | // |
| 236 | // Define the specific materials used for the ITS SPD central detectors. |
| 237 | // --- |
| d0048cec |
238 | // NOTE: These are the same old names. |
| 54c9a3d9 |
239 | // By the ALICE naming conventions, they start with "ITS SPD ...." |
| 240 | // Data taken from ** AliITSvPPRasymmFMD::CreateMaterials() **. |
| 241 | // --- |
| 242 | // Arguments [the ones passed by reference contain output values]: |
| 243 | // - medOffset --> (by ref) starting number of the list of media |
| 244 | // - matOffset --> (by ref) starting number of the list of Materials |
| 245 | // --- |
| 246 | // Inputs: |
| 247 | // Int_t &medOffset Starting number of the list of media |
| 248 | // Int_t &matOffset Starting number of the list of materials |
| 249 | // Outputs: |
| 250 | // Int_t &medOffset Ending number of the list of media |
| 251 | // Int_t &matOffset Ending number of the list of materials |
| 252 | // Return: |
| 253 | // The last material indexused +1. (= next avaiable material index) |
| 254 | // |
| 255 | const Double_t ktmaxfd = 0.1 * fgkDegree; // Degree |
| 256 | const Double_t kstemax = 1.0 * fgkcm; // cm |
| 257 | const Double_t kdeemax = 0.1;//Fraction of particle's energy 0<deemax<=1 |
| 258 | const Double_t kepsil = 1.0E-4; // |
| 259 | const Double_t kstmin = 0.0 * fgkcm; // cm "Default value used" |
| 260 | const Double_t ktmaxfdAir = 0.1 * fgkDegree; // Degree |
| 261 | const Double_t kstemaxAir = 1.0000E+00 * fgkcm; // cm |
| 262 | const Double_t kdeemaxAir = 0.1;//Fraction of particle's energy 0<deemax<=1 |
| 263 | const Double_t kepsilAir = 1.0E-4;// |
| 264 | const Double_t kstminAir = 0.0 * fgkcm; // cm "Default value used" |
| 265 | const Double_t ktmaxfdSi = 0.1 * fgkDegree; // .10000E+01; // Degree |
| 266 | const Double_t kstemaxSi = 0.0075 * fgkcm; // .10000E+01; // cm |
| 267 | const Double_t kdeemaxSi = 0.1;//Fraction of particle's energy 0<deemax<=1 |
| 268 | const Double_t kepsilSi = 1.0E-4;// |
| 269 | const Double_t kstminSi = 0.0 * fgkcm; // cm "Default value used" |
| 270 | // |
| 271 | Int_t matindex = matOffset; |
| 272 | Int_t medindex = medOffset; |
| 273 | TGeoMaterial *mat; |
| 274 | TGeoMixture *mix; |
| 275 | TGeoMedium *med; |
| 276 | // |
| f7a1cc68 |
277 | Int_t ifield = (((AliMagF*)TGeoGlobalMagField::Instance()->GetField())->Integ()); |
| 278 | Double_t fieldm = (((AliMagF*)TGeoGlobalMagField::Instance()->GetField())->Max()); |
| 54c9a3d9 |
279 | Double_t params[8] = {8 * 0.0}; |
| 280 | |
| 281 | params[1] = (Double_t) ifield; |
| 282 | params[2] = fieldm; |
| 283 | params[3] = ktmaxfdSi; |
| 284 | params[4] = kstemaxSi; |
| 285 | params[5] = kdeemaxSi; |
| 286 | params[6] = kepsilSi; |
| 287 | params[7] = kstminSi; |
| 288 | |
| 289 | // Definition of materials and mediums. |
| 290 | // Last argument in material definition is its pressure, |
| 291 | // which is initialized to ZERO. |
| 292 | // For better readability, it is simply set to zero. |
| 293 | // Then the writing "0.0 * fgkPascal" is replaced by "0." |
| 294 | // (Alberto) |
| d0048cec |
295 | |
| 54c9a3d9 |
296 | // silicon definition for ITS (overall) |
| 297 | mat = new TGeoMaterial("ITS_SI", 28.086, 14.0, 2.33 * fgkgcm3, |
| 298 | TGeoMaterial::kMatStateSolid, 25.0*fgkCelsius, 0.); |
| 299 | mat->SetIndex(matindex); |
| 300 | med = new TGeoMedium("SI", medindex++, mat, params); |
| d0048cec |
301 | |
| 54c9a3d9 |
302 | // silicon for ladder chips |
| 303 | mat = new TGeoMaterial("SPD SI CHIP", 28.086, 14.0, 2.33 * fgkgcm3, |
| 304 | TGeoMaterial::kMatStateSolid, 25.0*fgkCelsius, 0.); |
| 305 | mat->SetIndex(matindex); |
| 306 | med = new TGeoMedium("SPD SI CHIP", medindex++, mat, params); |
| d0048cec |
307 | |
| 54c9a3d9 |
308 | // silicon for pixel bus |
| 309 | mat = new TGeoMaterial("SPD SI BUS", 28.086, 14.0, 2.33 * fgkgcm3, |
| 310 | TGeoMaterial::kMatStateSolid, 25.0*fgkCelsius, 0.); |
| 311 | mat->SetIndex(matindex); |
| 312 | med = new TGeoMedium("SPD SI BUS", medindex++, mat, params); |
| d0048cec |
313 | |
| 54c9a3d9 |
314 | // carbon fiber material is defined as a mix of C-O-N-H |
| 315 | // defined in terms of fractional weights according to 'C (M55J)' |
| 316 | // it is used for the support and clips |
| 317 | mix = new TGeoMixture("C (M55J)", 4, 1.9866 * fgkgcm3); |
| 318 | mix->SetIndex(matindex); |
| 319 | mix->DefineElement(0, 12.01070, 6.0, 0.908508078);// C by fractional weight |
| 320 | mix->DefineElement(1, 14.00670, 7.0, 0.010387573);// N by fractional weight |
| 321 | mix->DefineElement(2, 15.99940, 8.0, 0.055957585);// O by fractional weight |
| 322 | mix->DefineElement(3, 1.00794, 1.0, 0.025146765);// H by fractional weight |
| 323 | mix->SetPressure(0.0 * fgkPascal); |
| 324 | mix->SetTemperature(25.0 * fgkCelsius); |
| 325 | mix->SetState(TGeoMaterial::kMatStateSolid); |
| 326 | params[3] = ktmaxfd; |
| 327 | params[4] = kstemax; |
| 328 | params[5] = kdeemax; |
| 329 | params[6] = kepsil; |
| 330 | params[7] = kstmin; |
| 331 | med = new TGeoMedium("ITSspdCarbonFiber", medindex++, mix, params); |
| 332 | |
| d0048cec |
333 | // air defined as a mixture of C-N-O-Ar: |
| 54c9a3d9 |
334 | // it is used to fill all containers |
| 335 | mix = new TGeoMixture("Air", 4, 1.20479E-3 * fgkgcm3); |
| 336 | mix->SetIndex(matindex); |
| 337 | mix->DefineElement(0, 12.0107, 6.0, 0.000124); // C by fractional weight |
| 338 | mix->DefineElement(1, 14.0067, 7.0, 0.755267); // N by fractional weight |
| 339 | mix->DefineElement(2, 15.9994, 8.0, 0.231781); // O by fractional weight |
| 340 | mix->DefineElement(3, 39.9480, 18.0, 0.012827); // Ar by fractional weight |
| 341 | mix->SetPressure(101325.0 * fgkPascal); // = 1 atmosphere |
| 342 | mix->SetTemperature(25.0 * fgkCelsius); |
| 343 | mix->SetState(TGeoMaterial::kMatStateGas); |
| 344 | params[3] = ktmaxfdAir; |
| 345 | params[4] = kstemaxAir; |
| 346 | params[5] = kdeemaxAir; |
| 347 | params[6] = kepsilAir; |
| 348 | params[7] = kstminAir; |
| 349 | med = new TGeoMedium("ITSspdAir", medindex++, mix, params); |
| 350 | |
| 351 | // inox stainless steel, defined as a mixture |
| 352 | // used for all metallic parts |
| 353 | mix = new TGeoMixture("INOX", 9, 8.03 * fgkgcm3); |
| 354 | mix->SetIndex(matindex); |
| 355 | mix->DefineElement(0, 12.0107, 6., .0003); // C by fractional weight |
| 356 | mix->DefineElement(1, 54.9380, 25., .02); // Fe by fractional weight |
| 357 | mix->DefineElement(2, 28.0855, 14., .01); // Na by fractional weight |
| 358 | mix->DefineElement(3, 30.9738, 15., .00045); // P by fractional weight |
| 359 | mix->DefineElement(4, 32.066 , 16., .0003); // S by fractional weight |
| 360 | mix->DefineElement(5, 58.6928, 28., .12); // Ni by fractional weight |
| 361 | mix->DefineElement(6, 55.9961, 24., .17); // by fractional weight |
| 362 | mix->DefineElement(7, 95.84 , 42., .025); // by fractional weight |
| 363 | mix->DefineElement(8, 55.845 , 26., .654); // by fractional weight |
| 364 | mix->SetPressure(0.0 * fgkPascal); |
| 365 | mix->SetTemperature(25.0 * fgkCelsius); |
| 366 | mix->SetState(TGeoMaterial::kMatStateSolid); |
| 367 | params[3] = ktmaxfdAir; |
| 368 | params[4] = kstemaxAir; |
| 369 | params[5] = kdeemaxAir; |
| 370 | params[6] = kepsilAir; |
| 371 | params[7] = kstminAir; |
| 372 | med = new TGeoMedium("ITSspdStainlessSteel", medindex++, mix, params); |
| 373 | |
| 374 | // freon gas which fills the cooling system (C+F) |
| 375 | mix = new TGeoMixture("Freon", 2, 1.63 * fgkgcm3); |
| 376 | mix->SetIndex(matindex); |
| 377 | mix->DefineElement(0, 12.0107 , 6.0, 4); // C by fractional weight |
| 378 | mix->DefineElement(1, 18.9984032, 9.0, 10); // F by fractional weight |
| 379 | mix->SetPressure(101325.0 * fgkPascal); // = 1 atmosphere |
| 380 | mix->SetTemperature(25.0 * fgkCelsius); |
| 381 | mix->SetState(TGeoMaterial::kMatStateLiquid); |
| 382 | params[3] = ktmaxfdAir; |
| 383 | params[4] = kstemaxAir; |
| 384 | params[5] = kdeemaxAir; |
| 385 | params[6] = kepsilAir; |
| 386 | params[7] = kstminAir; |
| 387 | med = new TGeoMedium("ITSspdCoolingFluid", medindex++, mix, params); |
| 388 | |
| 389 | // return the next index to be used in case of adding new materials |
| 390 | medOffset = medindex; |
| 391 | matOffset = matindex; |
| 392 | return matOffset; |
| a53658c6 |
393 | } |
| 54c9a3d9 |
394 | //______________________________________________________________________ |
| bc3498f4 |
395 | void AliITSv11GeometrySPD::InitSPDCentral(Int_t offset, TVirtualMC *vmc) const |
| 396 | { |
| 54c9a3d9 |
397 | // |
| 398 | // Do all SPD Central detector initializations (e.g.: transport cuts). |
| 399 | // --- |
| d0048cec |
400 | // Here follow some GEANT3 physics switches, which are interesting |
| 54c9a3d9 |
401 | // for these settings to be defined: |
| 402 | // - "MULTS" (MULtiple Scattering): |
| 403 | // the variable IMULS controls this process. See [PHYS320/325/328] |
| 404 | // 0 - No multiple scattering. |
| 405 | // 1 - (DEFAULT) Multiple scattering according to Moliere theory. |
| 406 | // 2 - Same as 1. Kept for backward compatibility. |
| 407 | // 3 - Pure Gaussian scattering according to the Rossi formula. |
| 408 | // - "DRAY" (Delta RAY production) |
| 409 | // The variable IDRAY controls this process. See [PHYS430] |
| 410 | // 0 - No delta rays production. |
| 411 | // 1 - (DEFAULT) Delta rays production with generation of. |
| 412 | // 2 - Delta rays production without generation of. |
| 413 | // - "LOSS" (continuous energy loss) |
| 414 | // The variable ILOSS controls this process. |
| 415 | // 0 - No continuous energy loss, IDRAY is set to 0. |
| d0048cec |
416 | // 1 - Continuous energy loss with generation of delta rays above |
| 417 | // DCUTE (common/GCUTS/) and restricted Landau fluctuations |
| 54c9a3d9 |
418 | // below DCUTE. |
| d0048cec |
419 | // 2 - (DEFAULT) Continuous energy loss without generation of |
| 420 | // delta rays |
| 54c9a3d9 |
421 | // and full Landau-Vavilov-Gauss fluctuations. |
| 422 | // In this case the variable IDRAY is forced to 0 to avoid |
| 423 | // double counting of fluctuations. |
| 424 | // 3 - Same as 1, kept for backward compatibility. |
| 425 | // 4 - Energy loss without fluctuation. |
| 426 | // The value obtained from the tables is used directly. |
| 427 | // --- |
| 428 | // Arguments: |
| 429 | // Int_t offset --> the material/medium index offset |
| 430 | // TVirtualMC *vmc --> pointer to the virtual Monte Carlo default gMC |
| 431 | // |
| 432 | |
| 433 | Int_t i, n = 4; |
| d0048cec |
434 | |
| 54c9a3d9 |
435 | for(i=0;i<n;i++) { |
| 436 | vmc->Gstpar(i+offset, "CUTGAM", 30.0 * fgkKeV); |
| 437 | vmc->Gstpar(i+offset, "CUTELE", 30.0 * fgkKeV); |
| 438 | vmc->Gstpar(i+offset, "CUTNEU", 30.0 * fgkKeV); |
| 439 | vmc->Gstpar(i+offset, "CUTHAD", 30.0 * fgkKeV); |
| 440 | vmc->Gstpar(i+offset, "CUTMUO", 30.0 * fgkKeV); |
| 441 | vmc->Gstpar(i+offset, "BCUTE", 30.0 * fgkKeV); |
| 442 | vmc->Gstpar(i+offset, "BCUTM", 30.0 * fgkKeV); |
| 443 | vmc->Gstpar(i+offset, "DCUTE", 30.0 * fgkKeV); |
| 444 | vmc->Gstpar(i+offset, "DCUTM", 30.0 * fgkKeV); |
| 445 | //vmc->Gstpar(i+offset, "PPCUTM", ); |
| 446 | //vmc->Gstpar(i+offset, "PAIR", ); |
| 447 | //vmc->Gstpar(i+offset, "COMPT", ); |
| 448 | //vmc->Gstpar(i+offset, "PHOT", ); |
| 449 | //vmc->Gstpar(i+offset, "PFIS", ); |
| 450 | vmc->Gstpar(i+offset, "DRAY", 1); |
| 451 | //vmc->Gstpar(i+offset, "ANNI", ); |
| 452 | //vmc->Gstpar(i+offset, "BREM", ); |
| 453 | //vmc->Gstpar(i+offset, "HADR", ); |
| 454 | //vmc->Gstpar(i+offset, "MUNU", ); |
| 455 | //vmc->Gstpar(i+offset, "DCAY", ); |
| 456 | vmc->Gstpar(i+offset, "LOSS", 1); |
| 457 | //vmc->Gstpar(i+offset, "MULS", ); |
| 458 | //vmc->Gstpar(i+offset, "GHCOR1", ); |
| 459 | //vmc->Gstpar(i+offset, "BIRK1", ); |
| 460 | //vmc->Gstpar(i+offset, "BRIK2", ); |
| 461 | //vmc->Gstpar(i+offset, "BRIK3", ); |
| 462 | //vmc->Gstpar(i+offset, "LABS", ); |
| 463 | //vmc->Gstpar(i+offset, "SYNC", ); |
| 464 | //vmc->Gstpar(i+offset, "STRA", ); |
| 465 | } |
| a53658c6 |
466 | } |
| 54c9a3d9 |
467 | //______________________________________________________________________ |
| bc3498f4 |
468 | void AliITSv11GeometrySPD::SPDSector(TGeoVolume *moth, TGeoManager *mgr) |
| 469 | { |
| 54c9a3d9 |
470 | // |
| d0048cec |
471 | // Creates a single SPD carbon fiber sector and places it |
| 54c9a3d9 |
472 | // in a container volume passed as first argument ('moth'). |
| 473 | // Second argument points to the TGeoManager which coordinates |
| 474 | // the overall volume creation. |
| d0048cec |
475 | // The position of the sector is based on distance of |
| 476 | // closest point of SPD stave to beam pipe |
| 54c9a3d9 |
477 | // (figures all-sections-modules.ps) of 7.22mm at section A-A. |
| 478 | // |
| 479 | |
| 480 | // Begin_Html |
| 481 | /* |
| 482 | <img src="http://alice.pd.infn.it/latestdr/Geometric-Revision/assembly.ps" |
| 483 | title="SPD Sector drawing with all cross sections defined"> |
| d0048cec |
484 | <p>The SPD Sector definition. In |
| 54c9a3d9 |
485 | <a href="http://alice.pd.infn.it/latestdr/Geometric-Revision/assembly.hpgl">HPGL</a> format. |
| 486 | <img src="http://alice.pd.infn.it/latestdr/Geometric-Revision/assembly-10-modules.ps" |
| 487 | titile="SPD All Sectors end view with thermal sheald"> |
| 488 | <p>The SPD all sector end view with thermal sheald. |
| 489 | <img src="http://alice.pd.infn.it/latestdr/Geometric-Revision/assembly.ps" |
| 490 | title="SPD side view cross section"> |
| 491 | <p>SPD side view cross section with condes and thermal shealds. |
| 492 | <img src="http://alice.pd.infn.it/latestdr/Geometric-Revision/SECTION-A_A.jpg" |
| 493 | title="Cross section A-A"><p>Cross section A-A. |
| 494 | <img src="http://alice.pd.infn.it/latestdr/Geometric-Revision/SECTION-B_B.jpg" |
| 495 | title="Cross updated section A-A"><p>Cross updated section A-A. |
| 496 | <img src="http://physics.mps.ohio-state.edu/~nilsen/ITSfigures/Sezione_layerAA.pdf" |
| 497 | title="Cross section B-B"><p>Cross section B-B. |
| 498 | <img src="http://alice.pd.infn.it/latestdr/Geometric-Revision/SECTION-C_C.jpg" |
| 499 | title-"Cross section C-C"><p>Cross section C-C. |
| 500 | <img src="http://alice.pd.infn.it/latestdr/Geometric-Revision/SECTION-D_D.jpg" |
| 501 | title="Cross section D-D"><p>Cross section D-D. |
| 502 | <img src="http://alice.pd.infn.it/latestdr/Geometric-Revision/SECTION-E_E.jpg" |
| 503 | title="Cross section E-E"><p>Cross section E-E. |
| 504 | <img src="http://alice.pd.infn.it/latestdr/Geometric-Revision/SECTION-F_F.jpg" |
| 505 | title="Cross section F-F"><p>Cross section F-F. |
| 506 | <img src="http://alice.pd.infn.it/latestdr/Geometric-Revision/SECTION-G_G.jpg" |
| 507 | title="Cross section G-G"><p>Cross section G-G. |
| 508 | */ |
| 509 | // End_Html |
| 510 | |
| 511 | // Inputs: |
| 512 | // TGeoVolume *moth Pointer to mother volume where this object |
| 513 | // is to be placed in |
| 514 | // TGeoManager *mgr Pointer to the TGeoManager used, defaule is |
| 515 | // gGeoManager. |
| 516 | // Outputs: |
| 517 | // none. |
| 518 | // Return: |
| 519 | // none. |
| 520 | // Updated values for kSPDclossesStaveAA, kBeamPipeRadius, and |
| d0048cec |
521 | // staveThicknessAA are taken from |
| 54c9a3d9 |
522 | // http://physics.mps.ohio-state.edu/~nilsen/ITSfigures/Sezione_layerAA.pdf |
| 523 | // |
| 3ffa185f |
524 | const Double_t kSPDclossesStaveAA = 7.25* fgkmm; |
| 54c9a3d9 |
525 | const Double_t kSectorStartingAngle = -72.0 * fgkDegree; |
| 3ffa185f |
526 | const Int_t kNSectorsTotal = 10; |
| 527 | const Double_t kSectorRelativeAngle = 36.0 * fgkDegree; // = 360.0 / 10 |
| 528 | const Double_t kBeamPipeRadius = 0.5 * 59.6 * fgkmm; // diam. = 59.6 mm |
| 529 | //const Double_t staveThicknessAA = 0.9 *fgkmm; // nominal thickness |
| 530 | const Double_t staveThicknessAA = 1.02 * fgkmm; // get from stave geometry. |
| d0048cec |
531 | |
| 3ffa185f |
532 | Int_t i, j, k; |
| 54c9a3d9 |
533 | Double_t angle, radiusSector, xAAtubeCenter0, yAAtubeCenter0; |
| 3ffa185f |
534 | TGeoCombiTrans *secRot = new TGeoCombiTrans(), *comrot; |
| 54c9a3d9 |
535 | TGeoVolume *vCarbonFiberSector; |
| 536 | TGeoMedium *medSPDcf; |
| 537 | |
| d0048cec |
538 | // Define an assembly and fill it with the support of |
| 54c9a3d9 |
539 | // a single carbon fiber sector and staves in it |
| 540 | medSPDcf = GetMedium("SPD C (M55J)$", mgr); |
| 541 | vCarbonFiberSector = new TGeoVolumeAssembly("ITSSPDCarbonFiberSectorV"); |
| 542 | vCarbonFiberSector->SetMedium(medSPDcf); |
| 3ffa185f |
543 | CarbonFiberSector(vCarbonFiberSector, xAAtubeCenter0, yAAtubeCenter0, mgr); |
| 54c9a3d9 |
544 | |
| 545 | // Compute the radial shift out of the sectors |
| 3ffa185f |
546 | radiusSector = kBeamPipeRadius + kSPDclossesStaveAA + staveThicknessAA; |
| 547 | radiusSector = GetSPDSectorTranslation(fSPDsectorX0.At(1), fSPDsectorY0.At(1), |
| 548 | fSPDsectorX1.At(1), fSPDsectorY1.At(1), radiusSector); |
| 549 | //radiusSector *= radiusSector; // squaring; |
| 550 | //radiusSector -= xAAtubeCenter0 * xAAtubeCenter0; |
| 551 | //radiusSector = -yAAtubeCenter0 + TMath::Sqrt(radiusSector); |
| d0048cec |
552 | |
| 3ffa185f |
553 | AliDebug(1, Form("SPDSector : radiusSector=%f\n",radiusSector)); |
| 554 | i = 1; |
| 555 | AliDebug(1, Form("i= %d x0=%f y0=%f x1=%f y1=%f\n", i, |
| 556 | fSPDsectorX0.At(i), fSPDsectorY0.At(i), |
| 557 | fSPDsectorX1.At(i),fSPDsectorY1.At(i))); |
| d0048cec |
558 | |
| 54c9a3d9 |
559 | // add 10 single sectors, by replicating the virtual sector defined above |
| 560 | // and placing at different angles |
| 561 | Double_t shiftX, shiftY, tub[2][6][3]; |
| 3ffa185f |
562 | for(i=0;i<2;i++)for(j=0;j<6;j++)for(k=0;k<3;k++) tub[i][j][k] = fTubeEndSector[0][i][j][k]; |
| 54c9a3d9 |
563 | angle = kSectorStartingAngle; |
| 564 | secRot->RotateZ(angle); |
| 565 | TGeoVolumeAssembly *vcenteral = new TGeoVolumeAssembly("ITSSPD"); |
| 3ffa185f |
566 | moth->AddNode(vcenteral, 1, 0); |
| 567 | for(i = 0; i < kNSectorsTotal; i++) { |
| 54c9a3d9 |
568 | shiftX = -radiusSector * TMath::Sin(angle/fgkRadian); |
| 569 | shiftY = radiusSector * TMath::Cos(angle/fgkRadian); |
| d0048cec |
570 | //cout << "ANGLE = " << angle << endl; |
| 3ffa185f |
571 | shiftX += 0.1094 * TMath::Cos((angle + 196.)/fgkRadian); |
| 572 | shiftY += 0.1094 * TMath::Sin((angle + 196.)/fgkRadian); |
| 573 | //shiftX -= 0.105; |
| 574 | //shiftY -= 0.031; |
| 575 | //shiftX -= 0.11 * TMath::Cos(angle/fgkRadian); // add by Alberto |
| 576 | //shiftY -= 0.11 * TMath::Sin(angle/fgkRadian); // don't ask me where that 0.11 comes from! |
| 54c9a3d9 |
577 | secRot->SetDx(shiftX); |
| 578 | secRot->SetDy(shiftY); |
| 579 | comrot = new TGeoCombiTrans(*secRot); |
| 580 | vcenteral->AddNode(vCarbonFiberSector,i+1,comrot); |
| 581 | for(j=0;j<2;j++)for(k=0;k<6;k++) // Transform Tube ends for each sector |
| 582 | comrot->LocalToMaster(tub[j][k],fTubeEndSector[i][j][k]); |
| 583 | if(GetDebug(5)) { |
| 584 | AliInfo(Form("i=%d angle=%g angle[rad]=%g radiusSector=%g " |
| 585 | "x=%g y=%g \n",i, angle, angle/fgkRadian, |
| 586 | radiusSector, shiftX, shiftY)); |
| 587 | } // end if GetDebug(5) |
| 588 | angle += kSectorRelativeAngle; |
| 589 | secRot->RotateZ(kSectorRelativeAngle); |
| 590 | } // end for i |
| 591 | if(GetDebug(3)) moth->PrintNodes(); |
| 592 | delete secRot; |
| d0048cec |
593 | |
| 7f69c251 |
594 | CreateCones(moth); |
| a53658c6 |
595 | } |
| 54c9a3d9 |
596 | //______________________________________________________________________ |
| 597 | void AliITSv11GeometrySPD::CarbonFiberSector(TGeoVolume *moth, |
| 598 | Double_t &xAAtubeCenter0, Double_t &yAAtubeCenter0, TGeoManager *mgr) |
| bc3498f4 |
599 | { |
| 54c9a3d9 |
600 | // |
| 601 | // Define the detail SPD Carbon fiber support Sector geometry. |
| 602 | // Based on the drawings: |
| 603 | /* |
| 604 | http:///QA-construzione-profilo-modulo.ps |
| 605 | */ |
| 606 | // - ALICE-Pixel "Costruzione Profilo Modulo" (march 25 2004) |
| 607 | // - ALICE-SUPPORTO "Costruzione Profilo Modulo" |
| 608 | // --- |
| 609 | // Define outside radii as negative, where "outside" means that the |
| 610 | // center of the arc is outside of the object (feb 16 2004). |
| 611 | // --- |
| 612 | // Arguments [the one passed by ref contain output values]: |
| 613 | // Inputs: |
| 614 | // TGeoVolume *moth the voulme which will contain this object |
| 615 | // TGeoManager *mgr TGeo builder defauls is gGeoManager |
| 616 | // Outputs: |
| 617 | // Double_t &xAAtubeCenter0 (by ref) x location of the outer surface |
| 618 | // of the cooling tube center for tube 0. |
| 619 | // Double_t &yAAtubeCenter0 (by ref) y location of the outer surface |
| 620 | // of the cooling tube center for tube 0. |
| 621 | // Return: |
| 622 | // none. |
| 623 | // --- |
| 624 | // Int the two variables passed by reference values will be stored |
| 625 | // which will then be used to correctly locate this sector. |
| 626 | // The information used for this is the distance between the |
| 627 | // center of the #0 detector and the beam pipe. |
| 628 | // Measurements are taken at cross section A-A. |
| 629 | // |
| d0048cec |
630 | |
| 54c9a3d9 |
631 | //TGeoMedium *medSPDfs = 0;//SPD support cone inserto stesalite 4411w |
| 632 | //TGeoMedium *medSPDfo = 0;//SPD support cone foam, Rohacell 50A. |
| 633 | //TGeoMedium *medSPDal = 0;//SPD support cone SDD mounting bracket Al |
| 634 | TGeoMedium *medSPDcf = GetMedium("SPD C (M55J)$", mgr); |
| 635 | TGeoMedium *medSPDss = GetMedium("INOX$", mgr); |
| 636 | TGeoMedium *medSPDair = GetMedium("AIR$", mgr); |
| 637 | TGeoMedium *medSPDcoolfl = GetMedium("Freon$", mgr); //ITSspdCoolingFluid |
| 638 | // |
| 639 | const Double_t ksecDz = 0.5 * 500.0 * fgkmm; |
| 640 | //const Double_t ksecLen = 30.0 * fgkmm; |
| 641 | const Double_t ksecCthick = 0.2 * fgkmm; |
| 642 | const Double_t ksecDipLength = 3.2 * fgkmm; |
| 643 | const Double_t ksecDipRadii = 0.4 * fgkmm; |
| 644 | //const Double_t ksecCoolingTubeExtraDepth = 0.86 * fgkmm; |
| 645 | // |
| 646 | // The following positions ('ksecX#' and 'ksecY#') and radii ('ksecR#') |
| 647 | // are the centers and radii of curvature of all the rounded corners |
| 648 | // between the straight borders of the SPD sector shape. |
| 649 | // To draw this SPD sector, the following steps are followed: |
| 650 | // 1) the (ksecX, ksecY) points are plotted |
| 651 | // and circles of the specified radii are drawn around them. |
| 652 | // 2) each pair of consecutive circles is connected by a line |
| d0048cec |
653 | // tangent to them, in accordance with the radii being "internal" |
| 654 | // or "external" with respect to the closed shape which describes |
| 54c9a3d9 |
655 | // the sector itself. |
| d0048cec |
656 | // The resulting connected shape is the section |
| 54c9a3d9 |
657 | // of the SPD sector surface in the transverse plane (XY). |
| 658 | // |
| 659 | const Double_t ksecX0 = -10.725 * fgkmm; |
| 660 | const Double_t ksecY0 = -14.853 * fgkmm; |
| 661 | const Double_t ksecR0 = -0.8 * fgkmm; // external |
| 662 | const Double_t ksecX1 = -13.187 * fgkmm; |
| 663 | const Double_t ksecY1 = -19.964 * fgkmm; |
| 3ffa185f |
664 | const Double_t ksecR1 = +0.6 * fgkmm; // internal // (modif. by Alberto) |
| 665 | //const Double_t ksecR1 = +0.8 * fgkmm; // internal // (modif. by Alberto) |
| 666 | |
| 54c9a3d9 |
667 | // const Double_t ksecDip0 = 5.9 * fgkmm; |
| 668 | // |
| 3ffa185f |
669 | //const Double_t ksecX2 = -3.883 * fgkmm; |
| 670 | const Double_t ksecX2 = -3.833 * fgkmm; // (corr. by Alberto) |
| 54c9a3d9 |
671 | const Double_t ksecY2 = -17.805 * fgkmm; |
| 3ffa185f |
672 | const Double_t ksecR2 = +0.6 * fgkmm; // internal (guess) |
| 54c9a3d9 |
673 | const Double_t ksecX3 = -3.123 * fgkmm; |
| 674 | const Double_t ksecY3 = -14.618 * fgkmm; |
| 675 | const Double_t ksecR3 = -0.6 * fgkmm; // external |
| 676 | //const Double_t ksecDip1 = 8.035 * fgkmm; |
| 677 | // |
| 678 | const Double_t ksecX4 = +11.280 * fgkmm; |
| 679 | const Double_t ksecY4 = -14.473 * fgkmm; |
| 680 | const Double_t ksecR4 = +0.8 * fgkmm; // internal |
| 681 | const Double_t ksecX5 = +19.544 * fgkmm; |
| 682 | const Double_t ksecY5 = +10.961 * fgkmm; |
| 683 | const Double_t ksecR5 = +0.8 * fgkmm; // internal |
| 684 | //const Double_t ksecDip2 = 4.553 * fgkmm; |
| d0048cec |
685 | // |
| 54c9a3d9 |
686 | const Double_t ksecX6 = +10.830 * fgkmm; |
| 687 | const Double_t ksecY6 = +16.858 * fgkmm; |
| 688 | const Double_t ksecR6 = +0.6 * fgkmm; // internal |
| 689 | const Double_t ksecX7 = +11.581 * fgkmm; |
| 690 | const Double_t ksecY7 = +13.317 * fgkmm; |
| 691 | const Double_t ksecR7 = -0.6 * fgkmm; // external |
| 692 | //const Double_t ksecDip3 = 6.978 * fgkmm; |
| 693 | // |
| 694 | const Double_t ksecX8 = -0.733 * fgkmm; |
| 695 | const Double_t ksecY8 = +17.486 * fgkmm; |
| 696 | const Double_t ksecR8 = +0.6 * fgkmm; // internal |
| 697 | const Double_t ksecX9 = +0.562 * fgkmm; |
| 698 | //const Double_t ksecY9 = +14.486 * fgkmm; // correction by |
| 699 | const Double_t ksecY9 = +14.107 * fgkmm; // Alberto |
| 700 | const Double_t ksecR9 = -0.6 * fgkmm; // external |
| 701 | //const Double_t ksecDip4 = 6.978 * fgkmm; |
| 702 | // |
| 703 | const Double_t ksecX10 = -12.252 * fgkmm; |
| 704 | const Double_t ksecY10 = +16.298 * fgkmm; |
| 705 | const Double_t ksecR10 = +0.6 * fgkmm; // internal |
| 706 | const Double_t ksecX11 = -10.445 * fgkmm; |
| 707 | const Double_t ksecY11 = +13.162 * fgkmm; |
| 708 | const Double_t ksecR11 = -0.6 * fgkmm; // external |
| 709 | //const Double_t ksecDip5 = 6.978 * fgkmm; |
| 710 | // |
| 711 | const Double_t ksecX12 = -22.276 * fgkmm; |
| 712 | const Double_t ksecY12 = +12.948 * fgkmm; |
| 713 | const Double_t ksecR12 = +0.85 * fgkmm; // internal |
| 714 | const Double_t ksecR13 = -0.8 * fgkmm; // external |
| 715 | const Double_t ksecAngleSide13 = 36.0 * fgkDegree; |
| 716 | // |
| 717 | const Int_t ksecNRadii = 20; |
| 718 | const Int_t ksecNPointsPerRadii = 4; |
| 719 | const Int_t ksecNCoolingTubeDips = 6; |
| 720 | // |
| 721 | // Since the rounded parts are approximated by a regular polygon |
| 722 | // and a cooling tube of the propper diameter must fit, a scaling factor |
| 723 | // increases the size of the polygon for the tube to fit. |
| 724 | //const Double_t ksecRCoolScale = 1./TMath::Cos(TMath::Pi()/ |
| 725 | // (Double_t)ksecNPointsPerRadii); |
| 726 | const Double_t ksecZEndLen = 30.000 * fgkmm; |
| 727 | //const Double_t ksecZFlangLen = 45.000 * fgkmm; |
| 728 | const Double_t ksecTl = 0.860 * fgkmm; |
| 729 | const Double_t ksecCthick2 = 0.600 * fgkmm; |
| 730 | //const Double_t ksecCthick3 = 1.80 * fgkmm; |
| 731 | //const Double_t ksecSidelen = 22.0 * fgkmm; |
| 732 | //const Double_t ksecSideD5 = 3.679 * fgkmm; |
| 733 | //const Double_t ksecSideD12 = 7.066 * fgkmm; |
| 734 | const Double_t ksecRCoolOut = 2.400 * fgkmm; |
| 735 | const Double_t ksecRCoolIn = 2.000 * fgkmm; |
| 736 | const Double_t ksecDl1 = 5.900 * fgkmm; |
| 737 | const Double_t ksecDl2 = 8.035 * fgkmm; |
| 738 | const Double_t ksecDl3 = 4.553 * fgkmm; |
| 739 | const Double_t ksecDl4 = 6.978 * fgkmm; |
| 740 | const Double_t ksecDl5 = 6.978 * fgkmm; |
| 741 | const Double_t ksecDl6 = 6.978 * fgkmm; |
| 742 | const Double_t ksecCoolTubeThick = 0.04 * fgkmm; |
| 743 | const Double_t ksecCoolTubeROuter = 2.6 * fgkmm; |
| 744 | const Double_t ksecCoolTubeFlatX = 3.696 * fgkmm; |
| 745 | const Double_t ksecCoolTubeFlatY = 0.68 * fgkmm; |
| 746 | //const Double_t ksecBeamX0 = 0.0 * fgkmm; // guess |
| 747 | //const Double_t ksecBeamY0 = (15.223 + 40.) * fgkmm; // guess |
| 748 | // |
| 749 | // redefine some of the points already defined above |
| 750 | // in the format of arrays (???) |
| 751 | const Int_t ksecNPoints = (ksecNPointsPerRadii + 1) * ksecNRadii + 8; |
| 752 | Double_t secX[ksecNRadii] = { |
| 753 | ksecX0, ksecX1, -1000.0, |
| 754 | ksecX2, ksecX3, -1000.0, |
| 755 | ksecX4, ksecX5, -1000.0, |
| 756 | ksecX6, ksecX7, -1000.0, |
| 757 | ksecX8, ksecX9, -1000.0, |
| 758 | ksecX10, ksecX11, -1000.0, |
| 759 | ksecX12, -1000.0 |
| 760 | }; |
| 761 | Double_t secY[ksecNRadii] = { |
| 762 | ksecY0, ksecY1, -1000.0, |
| 763 | ksecY2, ksecY3, -1000.0, |
| 764 | ksecY4, ksecY5, -1000.0, |
| 765 | ksecY6, ksecY7, -1000.0, |
| 766 | ksecY8, ksecY9, -1000.0, |
| 767 | ksecY10, ksecY11, -1000.0, |
| 768 | ksecY12, -1000.0 |
| 769 | }; |
| d0048cec |
770 | Double_t secR[ksecNRadii] = { |
| 54c9a3d9 |
771 | ksecR0, ksecR1, -.5 * ksecDipLength - ksecDipRadii, |
| 772 | ksecR2, ksecR3, -.5 * ksecDipLength - ksecDipRadii, |
| 773 | ksecR4, ksecR5, -.5 * ksecDipLength - ksecDipRadii, |
| 774 | ksecR6, ksecR7, -.5 * ksecDipLength - ksecDipRadii, |
| 775 | ksecR8, ksecR9, -.5 * ksecDipLength - ksecDipRadii, |
| 776 | ksecR10, ksecR11, -.5 * ksecDipLength - ksecDipRadii, |
| 777 | ksecR12, ksecR13 |
| 778 | }; |
| 779 | /* |
| 780 | Double_t secDip[ksecNRadii] = { |
| 781 | 0., 0., ksecDip0, 0., 0., ksecDip1, |
| 782 | 0., 0., ksecDip2, 0., 0., ksecDip3, |
| 783 | 0., 0., ksecDip4, 0., 0., ksecDip5, |
| 784 | 0., 0. |
| 785 | }; |
| 786 | */ |
| 787 | Double_t secX2[ksecNRadii]; |
| 788 | Double_t secY2[ksecNRadii]; |
| 789 | Double_t secR2[ksecNRadii] = { |
| 790 | ksecR0, ksecR1, ksecRCoolOut, |
| 791 | ksecR2, ksecR3, ksecRCoolOut, |
| 792 | ksecR4, ksecR5, ksecRCoolOut, |
| 793 | ksecR6, ksecR7, ksecRCoolOut, |
| 794 | ksecR8, ksecR9, ksecRCoolOut, |
| 795 | ksecR10, ksecR11, ksecRCoolOut, |
| 796 | ksecR12, ksecR13 |
| 797 | }; |
| d0048cec |
798 | Double_t secDip2[ksecNCoolingTubeDips] = { |
| 799 | ksecDl1, ksecDl2, ksecDl3, |
| 800 | ksecDl4, ksecDl5, ksecDl6 |
| 54c9a3d9 |
801 | }; |
| 802 | Double_t secX3[ksecNRadii]; |
| 803 | Double_t secY3[ksecNRadii]; |
| 804 | const Int_t ksecDipIndex[ksecNCoolingTubeDips] = {2, 5, 8, 11, 14, 17}; |
| 805 | Double_t secAngleStart[ksecNRadii]; |
| 806 | Double_t secAngleEnd[ksecNRadii]; |
| 807 | Double_t secAngleStart2[ksecNRadii]; |
| 808 | Double_t secAngleEnd2[ksecNRadii]; |
| 809 | Double_t secAngleTurbo[ksecNCoolingTubeDips] = {0., 0., 0., 0., 0., 0.0}; |
| 810 | //Double_t secAngleStart3[ksecNRadii]; |
| 811 | //Double_t secAngleEnd3[ksecNRadii]; |
| 812 | Double_t xpp[ksecNPoints], ypp[ksecNPoints]; |
| 813 | Double_t xpp2[ksecNPoints], ypp2[ksecNPoints]; |
| 814 | Double_t *xp[ksecNRadii], *xp2[ksecNRadii]; |
| 815 | Double_t *yp[ksecNRadii], *yp2[ksecNRadii]; |
| 816 | TGeoXtru *sA0, *sA1, *sB0, *sB1,*sB2; |
| 817 | TGeoBBox *sB3; |
| 818 | TGeoEltu *sTA0, *sTA1; |
| 819 | TGeoTube *sTB0, *sTB1; //,*sM0; |
| 820 | TGeoRotation *rot; |
| 821 | TGeoTranslation *trans; |
| 822 | TGeoCombiTrans *rotrans; |
| 823 | Double_t t, t0, t1, a, b, x0, y0,z0, x1, y1; |
| 824 | Int_t i, j, k, m; |
| 825 | Bool_t tst; |
| 826 | |
| 827 | if(!moth) { |
| 828 | AliError("Container volume (argument) is NULL"); |
| 829 | return; |
| 830 | } // end if(!moth) |
| 831 | for(i = 0; i < ksecNRadii; i++) { |
| 832 | xp[i] = &(xpp[i*(ksecNPointsPerRadii+1)]); |
| 833 | yp[i] = &(ypp[i*(ksecNPointsPerRadii+1)]); |
| 834 | xp2[i] = &(xpp2[i*(ksecNPointsPerRadii+1)]); |
| 835 | yp2[i] = &(ypp2[i*(ksecNPointsPerRadii+1)]); |
| 836 | secX2[i] = secX[i]; |
| 837 | secY2[i] = secY[i]; |
| 838 | secX3[i] = secX[i]; |
| 839 | secY3[i] = secY[i]; |
| 840 | } // end for i |
| 841 | // |
| 842 | // find starting and ending angles for all but cooling tube sections |
| 843 | secAngleStart[0] = 0.5 * ksecAngleSide13; |
| 844 | for(i = 0; i < ksecNRadii - 2; i++) { |
| 845 | tst = kFALSE; |
| 846 | for(j=0;j<ksecNCoolingTubeDips;j++) tst = (tst||i==ksecDipIndex[j]); |
| 847 | if (tst) continue; |
| 848 | tst = kFALSE; |
| 849 | for(j=0;j<ksecNCoolingTubeDips;j++) tst =(tst||(i+1)==ksecDipIndex[j]); |
| 850 | if (tst) j = i+2; else j = i+1; |
| 851 | AnglesForRoundedCorners(secX[i],secY[i],secR[i],secX[j],secY[j], |
| 852 | secR[j],t0,t1); |
| 853 | secAngleEnd[i] = t0; |
| 854 | secAngleStart[j] = t1; |
| 855 | if(secR[i] > 0.0 && secR[j] > 0.0) { |
| 856 | if(secAngleStart[i] > secAngleEnd[i]) secAngleEnd[i] += 360.0; |
| 857 | } // end if(secR[i]>0.0 && secR[j]>0.0) |
| 858 | secAngleStart2[i] = secAngleStart[i]; |
| 859 | secAngleEnd2[i] = secAngleEnd[i]; |
| 860 | } // end for i |
| 861 | secAngleEnd[ksecNRadii-2] = secAngleStart[ksecNRadii-2] + |
| 862 | (secAngleEnd[ksecNRadii-5] - secAngleStart[ksecNRadii-5]); |
| 863 | if (secAngleEnd[ksecNRadii-2] < 0.0) secAngleEnd[ksecNRadii-2] += 360.0; |
| 864 | secAngleStart[ksecNRadii-1] = secAngleEnd[ksecNRadii-2] - 180.0; |
| 865 | secAngleEnd[ksecNRadii-1] = secAngleStart[0]; |
| 866 | secAngleStart2[ksecNRadii-2] = secAngleStart[ksecNRadii-2]; |
| 867 | secAngleEnd2[ksecNRadii-2] = secAngleEnd[ksecNRadii-2]; |
| 868 | secAngleStart2[ksecNRadii-1] = secAngleStart[ksecNRadii-1]; |
| 869 | secAngleEnd2[ksecNRadii-1] = secAngleEnd[ksecNRadii-1]; |
| 870 | // |
| 871 | // find location of circle last rounded corner. |
| 872 | i = 0; |
| 873 | j = ksecNRadii - 2; |
| 874 | t0 = TanD(secAngleStart[i]-90.); |
| 875 | t1 = TanD(secAngleEnd[j]-90.); |
| 876 | t = secY[i] - secY[j]; |
| 877 | // NOTE: secR[i=0] < 0; secR[j=18] > 0; and secR[j+1=19] < 0 |
| 878 | t += (-secR[i]+secR[j+1]) * SinD(secAngleStart[i]); |
| 879 | t -= (secR[j]-secR[j+1]) * SinD(secAngleEnd[j]); |
| 880 | t += t1 * secX[j] - t0*secX[i]; |
| 881 | t += t1 * (secR[j] - secR[j+1]) * CosD(secAngleEnd[j]); |
| 882 | t -= t0 * (-secR[i]+secR[j+1]) * CosD(secAngleStart[i]); |
| 883 | secX[ksecNRadii-1] = t / (t1-t0); |
| 884 | secY[ksecNRadii-1] = TanD(90.0+0.5*ksecAngleSide13)* |
| 885 | (secX[ksecNRadii-1]-secX[0])+secY[0]; |
| 886 | secX2[ksecNRadii-1] = secX[ksecNRadii-1]; |
| 887 | secY2[ksecNRadii-1] = secY[ksecNRadii-1]; |
| 888 | secX3[ksecNRadii-1] = secX[ksecNRadii-1]; |
| 889 | secY3[ksecNRadii-1] = secY[ksecNRadii-1]; |
| d0048cec |
890 | |
| 54c9a3d9 |
891 | // find location of cooling tube centers |
| 892 | for(i = 0; i < ksecNCoolingTubeDips; i++) { |
| 893 | j = ksecDipIndex[i]; |
| 894 | x0 = secX[j-1] + TMath::Abs(secR[j-1]) * CosD(secAngleEnd[j-1]); |
| 895 | y0 = secY[j-1] + TMath::Abs(secR[j-1]) * SinD(secAngleEnd[j-1]); |
| 896 | x1 = secX[j+1] + TMath::Abs(secR[j+1]) * CosD(secAngleStart[j+1]); |
| 897 | y1 = secY[j+1] + TMath::Abs(secR[j+1]) * SinD(secAngleStart[j+1]); |
| 898 | t0 = TMath::Sqrt((x0-x1)*(x0-x1)+(y0-y1)*(y0-y1)); |
| 899 | t = secDip2[i] / t0; |
| 900 | a = x0+(x1-x0) * t; |
| 901 | b = y0+(y1-y0) * t; |
| d0048cec |
902 | if(i == 0) { |
| 54c9a3d9 |
903 | // get location of tube center->Surface for locating |
| 904 | // this sector around the beam pipe. |
| 905 | // This needs to be double checked, but I need my notes for that. |
| 906 | // (Bjorn Nilsen) |
| 907 | xAAtubeCenter0 = x0 + (x1 - x0) * t * 0.5; |
| 908 | yAAtubeCenter0 = y0 + (y1 - y0) * t * 0.5; |
| 909 | }// end if i==0 |
| 910 | if(a + b*(a - x0) / (b - y0) > 0.0) { |
| 911 | secX[j] = a + TMath::Abs(y1-y0) * 2.0 * ksecDipRadii/t0; |
| 912 | secY[j] = b - TMath::Sign(2.0*ksecDipRadii,y1-y0) * (x1-x0)/t0; |
| 913 | secX2[j] = a + TMath::Abs(y1-y0) * ksecTl/t0; |
| 914 | secY2[j] = b - TMath::Sign(ksecTl,y1-y0) * (x1-x0) / t0; |
| d0048cec |
915 | secX3[j] = a + TMath::Abs(y1-y0) * |
| 54c9a3d9 |
916 | (2.0*ksecDipRadii-0.5*ksecCoolTubeFlatY)/t0; |
| 917 | secY3[j] = b - TMath::Sign(2.0*ksecDipRadii-0.5*ksecCoolTubeFlatY, |
| 918 | y1-y0)*(x1-x0)/t0; |
| 919 | } else { |
| 920 | secX[j] = a - TMath::Abs(y1-y0)*2.0*ksecDipRadii/t0; |
| 921 | secY[j] = b + TMath::Sign(2.0*ksecDipRadii,y1-y0)*(x1-x0)/t0; |
| 922 | secX2[j] = a - TMath::Abs(y1-y0)*ksecTl/t0; |
| 923 | secY2[j] = b + TMath::Sign(ksecTl,y1-y0)*(x1-x0)/t0; |
| 924 | secX3[j] = a - TMath::Abs(y1-y0)*(2.0*ksecDipRadii-0.5* |
| 925 | ksecCoolTubeFlatY)/t0; |
| 926 | secY3[j] = b + TMath::Sign(2.0*ksecDipRadii-0.5*ksecCoolTubeFlatY, |
| 927 | y1-y0)*(x1-x0)/t0; |
| 928 | } // end if(a+b*(a-x0)/(b-y0)>0.0) |
| d0048cec |
929 | |
| 54c9a3d9 |
930 | // Set up Start and End angles to correspond to start/end of dips. |
| 931 | t1 = (secDip2[i]-TMath::Abs(secR[j])) / t0; |
| 932 | secAngleStart[j] =TMath::RadToDeg()*TMath::ATan2(y0+(y1-y0)*t1-secY[j], |
| 933 | x0+(x1-x0)*t1-secX[j]); |
| 934 | if (secAngleStart[j]<0.0) secAngleStart[j] += 360.0; |
| 935 | secAngleStart2[j] = secAngleStart[j]; |
| 936 | t1 = (secDip2[i]+TMath::Abs(secR[j]))/t0; |
| 937 | secAngleEnd[j] = TMath::RadToDeg()*TMath::ATan2(y0+(y1-y0)*t1-secY[j], |
| 938 | x0+(x1-x0)*t1-secX[j]); |
| 939 | if (secAngleEnd[j]<0.0) secAngleEnd[j] += 360.0; |
| 940 | secAngleEnd2[j] = secAngleEnd[j]; |
| 941 | if (secAngleEnd[j]>secAngleStart[j]) secAngleEnd[j] -= 360.0; |
| 942 | secR[j] = TMath::Sqrt(secR[j]*secR[j]+4.0*ksecDipRadii*ksecDipRadii); |
| 943 | } // end for i |
| d0048cec |
944 | |
| 54c9a3d9 |
945 | // Special cases |
| 946 | secAngleStart2[8] -= 360.; |
| 947 | secAngleStart2[11] -= 360.; |
| 948 | |
| 949 | SPDsectorShape(ksecNRadii, secX, secY, secR, secAngleStart, secAngleEnd, |
| 950 | ksecNPointsPerRadii, m, xp, yp); |
| 951 | |
| 952 | // Fix up dips to be square. |
| 953 | for(i = 0; i < ksecNCoolingTubeDips; i++) { |
| 954 | j = ksecDipIndex[i]; |
| 955 | t = 0.5*ksecDipLength+ksecDipRadii; |
| 956 | t0 = TMath::RadToDeg()*TMath::ATan(2.0*ksecDipRadii/t); |
| 957 | t1 = secAngleEnd[j] + t0; |
| 958 | t0 = secAngleStart[j] - t0; |
| 959 | x0 = xp[j][1] = secX[j] + t*CosD(t0); |
| 960 | y0 = yp[j][1] = secY[j] + t*SinD(t0); |
| 961 | x1 = xp[j][ksecNPointsPerRadii-1] = secX[j] + t*CosD(t1); |
| 962 | y1 = yp[j][ksecNPointsPerRadii-1] = secY[j] + t*SinD(t1); |
| 963 | t0 = 1./((Double_t)(ksecNPointsPerRadii-2)); |
| 964 | for(k = 2; k < ksecNPointsPerRadii - 1; k++) { |
| 965 | // extra points spread them out. |
| 966 | t = ((Double_t)(k-1)) * t0; |
| 967 | xp[j][k] = x0+(x1-x0) * t; |
| 968 | yp[j][k] = y0+(y1-y0) * t; |
| 969 | } // end for k |
| 970 | secAngleTurbo[i] = -TMath::RadToDeg() * TMath::ATan2(y1-y0, x1-x0); |
| d0048cec |
971 | if(GetDebug(3)) { |
| 54c9a3d9 |
972 | AliInfo( |
| 973 | Form("i=%d -- angle=%f -- x0,y0=(%f, %f) -- x1,y1=(%f, %f)", |
| 974 | i, secAngleTurbo[i], x0, y0, x1, y1)); |
| 975 | } // end if GetDebug(3) |
| 976 | } // end for i |
| 977 | sA0 = new TGeoXtru(2); |
| 978 | sA0->SetName("ITS SPD Carbon fiber support Sector A0"); |
| 979 | sA0->DefinePolygon(m, xpp, ypp); |
| 980 | sA0->DefineSection(0, -ksecDz); |
| 981 | sA0->DefineSection(1, ksecDz); |
| d0048cec |
982 | |
| 54c9a3d9 |
983 | // store the edges of each XY segment which defines |
| 984 | // one of the plane zones where staves will have to be placed |
| 985 | fSPDsectorX0.Set(ksecNCoolingTubeDips); |
| 986 | fSPDsectorY0.Set(ksecNCoolingTubeDips); |
| 987 | fSPDsectorX1.Set(ksecNCoolingTubeDips); |
| 988 | fSPDsectorY1.Set(ksecNCoolingTubeDips); |
| 989 | Int_t ixy0, ixy1; |
| 990 | for(i = 0; i < ksecNCoolingTubeDips; i++) { |
| 991 | // Find index in xpp[] and ypp[] corresponding to where the |
| 992 | // SPD ladders are to be attached. Order them according to |
| 993 | // the ALICE numbering schema. Using array of indexes (+-1 for |
| d0048cec |
994 | // cooling tubes. For any "bend/dip/edge, there are |
| 54c9a3d9 |
995 | // ksecNPointsPerRadii+1 points involved. |
| 996 | if(i == 0) j = 1; |
| 997 | else if (i == 1) j = 0; |
| 998 | else j = i; |
| 999 | ixy0 = (ksecDipIndex[j]-1)*(ksecNPointsPerRadii+1)+ |
| 1000 | (ksecNPointsPerRadii); |
| 1001 | ixy1 = (ksecDipIndex[j]+1) * (ksecNPointsPerRadii+1); |
| 1002 | fSPDsectorX0[i] = sA0->GetX(ixy0); |
| 1003 | fSPDsectorY0[i] = sA0->GetY(ixy0); |
| 1004 | fSPDsectorX1[i] = sA0->GetX(ixy1); |
| 1005 | fSPDsectorY1[i] = sA0->GetY(ixy1); |
| 1006 | } // end for i |
| d0048cec |
1007 | |
| 54c9a3d9 |
1008 | //printf("SectorA#%d ",0); |
| 1009 | InsidePoint(xpp[m-1],ypp[m-1],xpp[0],ypp[0],xpp[1],ypp[1],ksecCthick, |
| 1010 | xpp2[0],ypp2[0]); |
| 1011 | for(i = 1; i < m - 1; i++) { |
| 1012 | j = i / (ksecNPointsPerRadii+1); |
| 1013 | //printf("SectorA#%d ",i); |
| 1014 | InsidePoint(xpp[i-1],ypp[i-1],xpp[i],ypp[i],xpp[i+1],ypp[i+1], |
| 1015 | ksecCthick,xpp2[i],ypp2[i]); |
| 1016 | } // end for i |
| 1017 | //printf("SectorA#%d ",m); |
| 1018 | InsidePoint(xpp[m-2],ypp[m-2],xpp[m-1],ypp[m-1],xpp[0],ypp[0], |
| 1019 | ksecCthick,xpp2[m-1],ypp2[m-1]); |
| 1020 | // Fix center value of cooling tube dip and |
| 1021 | // find location of cooling tube centers |
| 1022 | for(i = 0; i < ksecNCoolingTubeDips; i++) { |
| 1023 | j = ksecDipIndex[i]; |
| 1024 | x0 = xp2[j][1]; |
| 1025 | y0 = yp2[j][1]; |
| 1026 | x1 = xp2[j][ksecNPointsPerRadii-1]; |
| 1027 | y1 = yp2[j][ksecNPointsPerRadii-1]; |
| 1028 | t0 = TMath::Sqrt((x0-x1)*(x0-x1)+(y0-y1)*(y0-y1)); |
| 1029 | t = secDip2[i]/t0; |
| 1030 | for(k = 2; k < ksecNPointsPerRadii - 1; k++) { |
| 1031 | // extra points spread them out. |
| 1032 | t = ((Double_t)(k-1)) * t0; |
| 1033 | xp2[j][k] = x0+(x1-x0) * t; |
| 1034 | yp2[j][k] = y0+(y1-y0) * t; |
| 1035 | } // end for k |
| 1036 | } // end for i |
| 1037 | sA1 = new TGeoXtru(2); |
| 1038 | sA1->SetName("ITS SPD Carbon fiber support Sector Air A1"); |
| 1039 | sA1->DefinePolygon(m, xpp2, ypp2); |
| 1040 | sA1->DefineSection(0, -ksecDz); |
| 1041 | sA1->DefineSection(1, ksecDz); |
| 1042 | // |
| 1043 | // Error in TGeoEltu. Semi-axis X must be < Semi-axis Y (?). |
| 1044 | sTA0 = new TGeoEltu("ITS SPD Cooling Tube TA0", 0.5 * ksecCoolTubeFlatY, |
| 1045 | 0.5 * ksecCoolTubeFlatX, ksecDz); |
| d0048cec |
1046 | sTA1 = new TGeoEltu("ITS SPD Cooling Tube coolant TA1", |
| 54c9a3d9 |
1047 | sTA0->GetA() - ksecCoolTubeThick, |
| 1048 | sTA0->GetB()-ksecCoolTubeThick,ksecDz); |
| 1049 | SPDsectorShape(ksecNRadii,secX2,secY2,secR2,secAngleStart2,secAngleEnd2, |
| 1050 | ksecNPointsPerRadii, m, xp, yp); |
| 1051 | sB0 = new TGeoXtru(2); |
| 1052 | sB0->SetName("ITS SPD Carbon fiber support Sector End B0"); |
| 1053 | sB0->DefinePolygon(m, xpp, ypp); |
| 1054 | sB0->DefineSection(0, ksecDz); |
| 1055 | sB0->DefineSection(1, ksecDz + ksecZEndLen); |
| 1056 | |
| 1057 | //printf("SectorB#%d ",0); |
| 53506676 |
1058 | // Points around the most sharpened tips have to be avoided - M.S. 24 feb 09 |
| 1059 | const Int_t nSpecialPoints = 5; |
| 1060 | const Int_t kSpecialPoints[nSpecialPoints] = {7, 17, 47, 62, 77}; |
| 1061 | Int_t i2 = 0; |
| 54c9a3d9 |
1062 | InsidePoint(xpp[m-1],ypp[m-1],xpp[0],ypp[0],xpp[1],ypp[1], |
| 53506676 |
1063 | ksecCthick2,xpp2[i2],ypp2[i2]); |
| 54c9a3d9 |
1064 | for(i = 1; i < m - 1; i++) { |
| 1065 | t = ksecCthick2; |
| 1066 | for(k = 0; k < ksecNCoolingTubeDips; k++) |
| 1067 | if((i/(ksecNPointsPerRadii+1))==ksecDipIndex[k]) |
| 1068 | if(!(ksecDipIndex[k]*(ksecNPointsPerRadii+1) == i || |
| 1069 | ksecDipIndex[k]*(ksecNPointsPerRadii+1) + |
| 1070 | ksecNPointsPerRadii == i)) |
| 1071 | t = ksecRCoolOut-ksecRCoolIn; |
| 1072 | //printf("SectorB#%d ",i); |
| 53506676 |
1073 | Bool_t useThisPoint = kTRUE; |
| 1074 | for(Int_t ii = 0; ii < nSpecialPoints; ii++) |
| 1075 | if ( (i == kSpecialPoints[ii] - 1) || |
| 1076 | (i == kSpecialPoints[ii] + 1) ) useThisPoint = kFALSE; |
| 1077 | if (useThisPoint) { |
| 1078 | i2++; |
| 1079 | InsidePoint(xpp[i-1],ypp[i-1],xpp[i],ypp[i],xpp[i+1],ypp[i+1],t, |
| 1080 | xpp2[i2],ypp2[i2]); |
| 1081 | } |
| 54c9a3d9 |
1082 | }// end for i |
| 1083 | //printf("SectorB#%d ",m); |
| 53506676 |
1084 | i2++; |
| 54c9a3d9 |
1085 | InsidePoint(xpp[m-2],ypp[m-2],xpp[m-1],ypp[m-1],xpp[0],ypp[0], |
| 53506676 |
1086 | ksecCthick2,xpp2[i2],ypp2[i2]); |
| 54c9a3d9 |
1087 | sB1 = new TGeoXtru(2); |
| 1088 | sB1->SetName("ITS SPD Carbon fiber support Sector Air End B1"); |
| 53506676 |
1089 | sB1->DefinePolygon(i2+1, xpp2, ypp2); |
| 54c9a3d9 |
1090 | sB1->DefineSection(0,sB0->GetZ(0)); |
| 1091 | sB1->DefineSection(1,sB0->GetZ(1)-ksecCthick2); |
| 1092 | const Double_t kspdEndHoleRadius1=5.698*fgkmm; |
| 1093 | const Double_t kspdEndHoleRadius2=2.336*fgkmm; |
| 1094 | const Double_t kspdEndHoleDisplacement=6.29*fgkmm; |
| 1095 | k = (m-1)/4; |
| 1096 | for(i=0;i<=k;i++){ |
| 1097 | t= ((Double_t)i)/((Double_t)(k)); |
| 1098 | if(!CFHolePoints(t,kspdEndHoleRadius1,kspdEndHoleRadius2, |
| 1099 | kspdEndHoleDisplacement,xpp2[i],ypp2[i])){ |
| 1100 | Warning("CarbonFiberSector","CFHolePoints failed " |
| 1101 | "i=%d m=%d k=%d t=%e",i,m,k,t); |
| 1102 | } // end if |
| 1103 | // simitry in each quadrant. |
| 1104 | xpp2[2*k-i] = -xpp2[i]; |
| 1105 | ypp2[2*k-i] = ypp2[i]; |
| 1106 | xpp2[2*k+i] = -xpp2[i]; |
| 1107 | ypp2[2*k+i] = -ypp2[i]; |
| 1108 | xpp2[4*k-i] = xpp2[i]; |
| 1109 | ypp2[4*k-i] = -ypp2[i]; |
| 1110 | }// end for i |
| 1111 | //xpp2[m-1] = xpp2[0]; // begining point in |
| 1112 | //ypp2[m-1] = ypp2[0]; // comment with end point |
| 1113 | sB2 = new TGeoXtru(2); |
| 1114 | sB2->SetName("ITS SPD Hole in Carbon fiber support End plate"); |
| 1115 | sB2->DefinePolygon(4*k, xpp2, ypp2); |
| 1116 | sB2->DefineSection(0,sB1->GetZ(1)); |
| 1117 | sB2->DefineSection(1,sB0->GetZ(1)); |
| 1118 | // SPD sector mount blocks |
| 1119 | const Double_t kMountBlock[3] = {0.5*(1.8-0.2)*fgkmm,0.5*22.0*fgkmm, |
| 1120 | 0.5*45.0*fgkmm}; |
| 1121 | sB3 = new TGeoBBox((Double_t*)kMountBlock); |
| 1122 | // SPD sector cooling tubes |
| 1123 | sTB0 = new TGeoTube("ITS SPD Cooling Tube End TB0", 0.0, |
| 7708d5f3 |
1124 | 0.5*ksecCoolTubeROuter,0.5*(sB1->GetZ(1)-sB1->GetZ(0))); |
| 54c9a3d9 |
1125 | sTB1 = new TGeoTube("ITS SPD Cooling Tube End coolant TB0", 0.0, |
| 1126 | sTB0->GetRmax() - ksecCoolTubeThick,sTB0->GetDz()); |
| 1127 | // |
| 1128 | if(GetDebug(3)) { |
| 1129 | if(medSPDcf) medSPDcf->Dump(); else AliInfo("medSPDcf = 0"); |
| 1130 | if(medSPDss) medSPDss->Dump(); else AliInfo("medSPDss = 0"); |
| 1131 | if(medSPDair) medSPDair->Dump(); else AliInfo("medSPDAir = 0"); |
| 1132 | if(medSPDcoolfl) medSPDcoolfl->Dump();else AliInfo("medSPDcoolfl = 0"); |
| 1133 | sA0->InspectShape(); |
| 1134 | sA1->InspectShape(); |
| 1135 | sB0->InspectShape(); |
| 1136 | sB1->InspectShape(); |
| 1137 | sB2->InspectShape(); |
| 1138 | } // end if(GetDebug(3)) |
| d0048cec |
1139 | |
| 54c9a3d9 |
1140 | // create the assembly of the support and place staves on it |
| 1141 | TGeoVolumeAssembly *vM0 = new TGeoVolumeAssembly( |
| 1142 | "ITSSPDSensitiveVirtualvolumeM0"); |
| 1143 | StavesInSector(vM0); |
| 1144 | // create other volumes with some graphical settings |
| 1145 | TGeoVolume *vA0 = new TGeoVolume("ITSSPDCarbonFiberSupportSectorA0", |
| 1146 | sA0, medSPDcf); |
| 1147 | vA0->SetVisibility(kTRUE); |
| 1148 | vA0->SetLineColor(4); // Blue |
| 1149 | vA0->SetLineWidth(1); |
| 1150 | vA0->SetFillColor(vA0->GetLineColor()); |
| 1151 | vA0->SetFillStyle(4010); // 10% transparent |
| 1152 | TGeoVolume *vA1 = new TGeoVolume("ITSSPDCarbonFiberSupportSectorAirA1", |
| 1153 | sA1, medSPDair); |
| 1154 | vA1->SetVisibility(kTRUE); |
| 1155 | vA1->SetLineColor(7); // light Blue |
| 1156 | vA1->SetLineWidth(1); |
| 1157 | vA1->SetFillColor(vA1->GetLineColor()); |
| 1158 | vA1->SetFillStyle(4090); // 90% transparent |
| 1159 | TGeoVolume *vTA0 = new TGeoVolume("ITSSPDCoolingTubeTA0", sTA0, medSPDss); |
| 1160 | vTA0->SetVisibility(kTRUE); |
| 1161 | vTA0->SetLineColor(15); // gray |
| 1162 | vTA0->SetLineWidth(1); |
| 1163 | vTA0->SetFillColor(vTA0->GetLineColor()); |
| 1164 | vTA0->SetFillStyle(4000); // 0% transparent |
| 1165 | TGeoVolume *vTA1 = new TGeoVolume("ITSSPDCoolingTubeFluidTA1", |
| 1166 | sTA1, medSPDcoolfl); |
| 1167 | vTA1->SetVisibility(kTRUE); |
| 1168 | vTA1->SetLineColor(6); // Purple |
| 1169 | vTA1->SetLineWidth(1); |
| 1170 | vTA1->SetFillColor(vTA1->GetLineColor()); |
| 1171 | vTA1->SetFillStyle(4000); // 0% transparent |
| 1172 | TGeoVolume *vB0 = new TGeoVolume("ITSSPDCarbonFiberSupportSectorEndB0", |
| 1173 | sB0, medSPDcf); |
| 1174 | vB0->SetVisibility(kTRUE); |
| 1175 | vB0->SetLineColor(1); // Black |
| 1176 | vB0->SetLineWidth(1); |
| 1177 | vB0->SetFillColor(vB0->GetLineColor()); |
| 1178 | vB0->SetFillStyle(4000); // 0% transparent |
| 1179 | TGeoVolume *vB1 = new TGeoVolume("ITSSPDCarbonFiberSupportSectorEndAirB1", |
| 1180 | sB1, medSPDair); |
| 1181 | vB1->SetVisibility(kTRUE); |
| 1182 | vB1->SetLineColor(0); // white |
| 1183 | vB1->SetLineWidth(1); |
| 1184 | vB1->SetFillColor(vB1->GetLineColor()); |
| 1185 | vB1->SetFillStyle(4100); // 100% transparent |
| 1186 | TGeoVolume *vB2 = new TGeoVolume("ITSSPDCarbonFiberSupportSectorEndAirB2", |
| 1187 | sB2, medSPDair); |
| 1188 | vB2->SetVisibility(kTRUE); |
| 1189 | vB2->SetLineColor(0); // white |
| 1190 | vB2->SetLineWidth(1); |
| 1191 | vB2->SetFillColor(vB2->GetLineColor()); |
| 1192 | vB2->SetFillStyle(4100); // 100% transparent |
| 1193 | TGeoVolume *vB3 = new TGeoVolume( |
| 1194 | "ITSSPDCarbonFiberSupportSectorMountBlockB3",sB3, medSPDcf); |
| 1195 | vB3->SetVisibility(kTRUE); |
| 1196 | vB3->SetLineColor(1); // Black |
| 1197 | vB3->SetLineWidth(1); |
| 1198 | vB3->SetFillColor(vB3->GetLineColor()); |
| 1199 | vB3->SetFillStyle(4000); // 0% transparent |
| 1200 | TGeoVolume *vTB0 = new TGeoVolume("ITSSPDCoolingTubeEndTB0",sTB0,medSPDss); |
| 1201 | vTB0->SetVisibility(kTRUE); |
| 1202 | vTB0->SetLineColor(15); // gray |
| 1203 | vTB0->SetLineWidth(1); |
| 1204 | vTB0->SetFillColor(vTB0->GetLineColor()); |
| 1205 | vTB0->SetFillStyle(4000); // 0% transparent |
| 1206 | TGeoVolume *vTB1 = new TGeoVolume("ITSSPDCoolingTubeEndFluidTB1",sTB1, |
| 1207 | medSPDcoolfl); |
| 1208 | vTB1->SetVisibility(kTRUE); |
| 1209 | vTB1->SetLineColor(7); // light blue |
| 1210 | vTB1->SetLineWidth(1); |
| 1211 | vTB1->SetFillColor(vTB1->GetLineColor()); |
| 1212 | vTB1->SetFillStyle(4050); // 0% transparent |
| d0048cec |
1213 | |
| 54c9a3d9 |
1214 | // add volumes to mother container passed as argument of this method |
| 1215 | moth->AddNode(vM0,1,0); // Add virtual volume to mother |
| 1216 | vA0->AddNode(vA1,1,0); // Put air inside carbon fiber. |
| 1217 | vB0->AddNode(vB1,1,0); // Put air inside carbon fiber ends. |
| 1218 | vB0->AddNode(vB2,1,0); // Put air wholes inside carbon fiber ends |
| 1219 | vTA0->AddNode(vTA1,1,0); // Put cooling liquid indide tube middel. |
| 1220 | vTB0->AddNode(vTB1,1,0); // Put cooling liquid inside tube end. |
| 1221 | Double_t tubeEndLocal[3]={0.0,0.0,sTA0->GetDz()}; |
| 1222 | for(i = 0; i < ksecNCoolingTubeDips; i++) { |
| 1223 | x0 = secX3[ksecDipIndex[i]]; |
| 1224 | y0 = secY3[ksecDipIndex[i]]; |
| 1225 | t = 90.0 - secAngleTurbo[i]; |
| 1226 | trans = new TGeoTranslation("",x0,y0,0.5*(sB1->GetZ(0)+sB1->GetZ(1))); |
| 1227 | vB1->AddNode(vTB0, i+1, trans); |
| 1228 | // Find location of tube ends for later use. |
| 1229 | trans->LocalToMaster(tubeEndLocal,fTubeEndSector[0][0][i]); |
| 1230 | rot = new TGeoRotation("", 0.0, 0.0, t); |
| 1231 | rotrans = new TGeoCombiTrans("", x0, y0, 0.0, rot); |
| 1232 | vM0->AddNode(vTA0, i+1, rotrans); |
| 1233 | } // end for i |
| 1234 | vM0->AddNode(vA0, 1, 0); |
| 1235 | vM0->AddNode(vB0, 1, 0); |
| 1236 | // Reflection. |
| 1237 | rot = new TGeoRotation("", 90., 0., 90., 90., 180., 0.); |
| 1238 | vM0->AddNode(vB0,2,rot); |
| 1239 | // Find location of tube ends for later use. |
| 1240 | for(i=0;i<ksecNCoolingTubeDips;i++) rot->LocalToMaster( |
| 1241 | fTubeEndSector[0][0][i],fTubeEndSector[0][1][i]); |
| 1242 | // left side |
| 1243 | t = -TMath::RadToDeg()*TMath::ATan2( |
| 1244 | sB0->GetX(0)-sB0->GetX(sB0->GetNvert()-1), |
| 1245 | sB0->GetY(0)-sB0->GetY(sB0->GetNvert()-1)); |
| 1246 | rot = new TGeoRotation("",t,0.0,0.0);// z axis rotation |
| 1247 | x0 = 0.5*(sB0->GetX(0)+sB0->GetX(sB0->GetNvert()-1))+ |
| 1248 | sB3->GetDX()*TMath::Cos(t*TMath::DegToRad()); |
| 1249 | y0 = 0.5*(sB0->GetY(0)+sB0->GetY(sB0->GetNvert()-1))+ |
| 1250 | sB3->GetDX()*TMath::Sin(t*TMath::DegToRad()); |
| 1251 | z0 = sB0->GetZ(0)+sB3->GetDZ(); |
| 1252 | rotrans = new TGeoCombiTrans("",x0,y0,z0,rot); |
| 1253 | vM0->AddNode(vB3,1,rotrans); // Put Mounting bracket on sector |
| 1254 | rotrans = new TGeoCombiTrans("",x0,y0,-z0,rot); |
| 1255 | vM0->AddNode(vB3,2,rotrans); // Put Mounting bracket on sector |
| 1256 | /* |
| 1257 | j = 0; // right side, find point with largest x value |
| 1258 | x1 = sB0->GetX(0); |
| 1259 | for(i=1;i<sB0->GetNvert();i++)if(sB0->GetX(i)>x1) {j=i;x1=sB0->GetX(i);} |
| 1260 | j--; // Too big by 1 |
| 1261 | //t = -TMath::RadToDeg()*TMath::ATan2( |
| 1262 | // sB0->GetX(j)-sB0->GetX(j-1), |
| 1263 | // sB0->GetY(j)-sB0->GetY(j-1)); |
| 1264 | */ |
| 1265 | t *= -1.0; |
| 1266 | rot = new TGeoRotation("",t,0.0,0.0); // z axis rotation |
| 1267 | /* // this way gets correct orientation but wrong "height" |
| 1268 | x0 = 0.5*(sB0->GetX(j)+sB0->GetX(j-1))+ |
| 1269 | sB3->GetDX()*TMath::Cos(t*TMath::DegToRad()); |
| 1270 | y0 = 0.5*(sB0->GetY(j)+sB0->GetY(j-1))+ |
| 1271 | sB3->GetDX()*TMath::Sin(t*TMath::DegToRad()); |
| 1272 | z0 = sB0->GetZ(0)+sB3->GetDZ(); |
| 1273 | */ // I don't understand the need for this factor 3.5. |
| 1274 | // posibly the SPD sector as coded isn't symetric which the |
| 1275 | // plans would suggest. |
| 1276 | x0 = -0.5*(sB0->GetX(0)+sB0->GetX(sB0->GetNvert()-1))-3.5* |
| 1277 | sB3->GetDX()*TMath::Cos(t*TMath::DegToRad()); |
| 1278 | y0 = 0.5*(sB0->GetY(0)+sB0->GetY(sB0->GetNvert()-1))-3.5* |
| 1279 | sB3->GetDX()*TMath::Sin(t*TMath::DegToRad()); |
| 22726349 |
1280 | rotrans = new TGeoCombiTrans("",1.01*x0,y0,z0,rot); |
| 54c9a3d9 |
1281 | vM0->AddNode(vB3,3,rotrans); // Put Mounting bracket on sector |
| 22726349 |
1282 | rotrans = new TGeoCombiTrans("",1.01*x0,y0,-z0,rot); |
| 54c9a3d9 |
1283 | vM0->AddNode(vB3,4,rotrans); // Put Mounting bracket on sector |
| 1284 | if(GetDebug(3)){ |
| 1285 | vM0->PrintNodes(); |
| 1286 | vA0->PrintNodes(); |
| 1287 | vA1->PrintNodes(); |
| 1288 | vB0->PrintNodes(); |
| 1289 | vB1->PrintNodes(); |
| 1290 | vB2->PrintNodes(); |
| 1291 | vB3->PrintNodes(); |
| 1292 | vTA0->PrintNodes(); |
| 1293 | vTA1->PrintNodes(); |
| 1294 | vTB0->PrintNodes(); |
| 1295 | vTB1->PrintNodes(); |
| 1296 | } // end if(GetDebug(3)) |
| bc3498f4 |
1297 | } |
| 54c9a3d9 |
1298 | //______________________________________________________________________ |
| 1299 | Bool_t AliITSv11GeometrySPD::CFHolePoints(Double_t s,Double_t r1, |
| 1300 | Double_t r2,Double_t l,Double_t &x,Double_t &y) const |
| bc3498f4 |
1301 | { |
| 54c9a3d9 |
1302 | // |
| 1303 | // Step along arck a distancs ds and compute boundry of |
| 1304 | // two holes (radius r1 and r2) a distance l apart (along |
| 1305 | // x-axis). |
| 1306 | // Inputs: |
| 1307 | // Double_t s fractional Distance along arcs [0-1] |
| 1308 | // where 0-> alpha=beta=0, 1-> alpha=90 degrees. |
| 1309 | // Double_t r1 radius at center circle |
| 1310 | // Double_t r2 radius of displaced circle |
| 1311 | // Double_t l Distance displaced circle is displaces (x-axis) |
| 1312 | // Output: |
| 1313 | // Double_t x x coordinate along double circle. |
| 1314 | // Double_t y y coordinate along double circle. |
| 1315 | // Return: |
| 1316 | // logical, kFALSE if an error |
| 1317 | // |
| 1318 | Double_t alpha,beta; |
| 1319 | Double_t ac,bc,scb,sca,t,alphac,betac; // at intersection of two circles |
| 1320 | |
| 1321 | x=y=0.0; |
| 1322 | ac = r1*r1-l*l-r2*r2; |
| 1323 | bc = 2.*l*r2; |
| 1324 | if(bc==0.0) {printf("bc=0 l=%e r2=%e\n",l,r2);return kFALSE;} |
| 1325 | betac = TMath::ACos(ac/bc); |
| 60e55aee |
1326 | alphac = TMath::Sqrt((bc-ac)*(bc+ac))/(2.*l*r1); |
| 54c9a3d9 |
1327 | scb = r2*betac; |
| 1328 | sca = r1*alphac; |
| 1329 | t = r1*0.5*TMath::Pi() - sca + scb; |
| 1330 | if(s<= scb/t){ |
| 1331 | beta = s*t/r2; |
| 1332 | x = r2*TMath::Cos(beta) + l; |
| 1333 | y = r2*TMath::Sin(beta); |
| 1334 | //printf("betac=%e scb=%e t=%e s=%e beta=%e x=%e y=%e\n", |
| 1335 | // betac,scb,t,s,beta,x,y); |
| 1336 | return kTRUE; |
| 1337 | }else{ |
| 1338 | beta = (s*t-scb+sca)/(r1*0.5*TMath::Pi()); |
| 1339 | alpha = beta*0.5*TMath::Pi(); |
| 1340 | x = r1*TMath::Cos(alpha); |
| 1341 | y = r1*TMath::Sin(alpha); |
| 1342 | //printf("alphac=%e sca=%e t=%e s=%e beta=%e alpha=%e x=%e y=%e\n", |
| 1343 | // alphac,sca,t,s,beta,alpha,x,y); |
| 1344 | return kTRUE; |
| 1345 | } // end if |
| 1346 | return kFALSE; |
| bc3498f4 |
1347 | } |
| 54c9a3d9 |
1348 | //______________________________________________________________________ |
| 1349 | Bool_t AliITSv11GeometrySPD::GetSectorMountingPoints(Int_t index,Double_t &x0, |
| 1350 | Double_t &y0, Double_t &x1, Double_t &y1) const |
| bc3498f4 |
1351 | { |
| 54c9a3d9 |
1352 | // |
| 1353 | // Returns the edges of the straight borders in the SPD sector shape, |
| 1354 | // which are used to mount staves on them. |
| 1355 | // Coordinate system is that of the carbon fiber sector volume. |
| 1356 | // --- |
| 1357 | // Index numbering is as follows: |
| 1358 | // /5 |
| 1359 | // /\/4 |
| 1360 | // 1\ \/3 |
| 1361 | // 0|___\/2 |
| 1362 | // --- |
| 1363 | // Arguments [the ones passed by reference contain output values]: |
| 1364 | // Int_t index --> location index according to above scheme [0-5] |
| 1365 | // Double_t &x0 --> (by ref) x0 location or the ladder sector [cm] |
| 1366 | // Double_t &y0 --> (by ref) y0 location of the ladder sector [cm] |
| 1367 | // Double_t &x1 --> (by ref) x1 location or the ladder sector [cm] |
| 1368 | // Double_t &y1 --> (by ref) y1 location of the ladder sector [cm] |
| 1369 | // TGeoManager *mgr --> The TGeo builder |
| 1370 | // --- |
| 1371 | // The location is described by a line going from (x0, y0) to (x1, y1) |
| 1372 | // --- |
| 1373 | // Returns kTRUE if no problems encountered. |
| 1374 | // Returns kFALSE if a problem was encountered (e.g.: shape not found). |
| d0048cec |
1375 | // |
| 54c9a3d9 |
1376 | Int_t isize = fSPDsectorX0.GetSize(); |
| 1377 | |
| 1378 | x0 = x1 = y0 = y1 = 0.0; |
| 1379 | if(index < 0 || index > isize) { |
| 1380 | AliError(Form("index = %d: allowed 0 --> %", index, isize)); |
| 1381 | return kFALSE; |
| 1382 | } // end if(index<0||index>isize) |
| 1383 | x0 = fSPDsectorX0[index]; |
| 1384 | x1 = fSPDsectorX1[index]; |
| 1385 | y0 = fSPDsectorY0[index]; |
| 1386 | y1 = fSPDsectorY1[index]; |
| 1387 | return kTRUE; |
| bc3498f4 |
1388 | } |
| 54c9a3d9 |
1389 | //______________________________________________________________________ |
| d0048cec |
1390 | void AliITSv11GeometrySPD::SPDsectorShape(Int_t n,const Double_t *xc, |
| 54c9a3d9 |
1391 | const Double_t *yc, const Double_t *r, |
| d0048cec |
1392 | const Double_t *ths, const Double_t *the, |
| 54c9a3d9 |
1393 | Int_t npr, Int_t &m, Double_t **xp, Double_t **yp) const |
| bc3498f4 |
1394 | { |
| 54c9a3d9 |
1395 | // |
| 1396 | // Code to compute the points that make up the shape of the SPD |
| 1397 | // Carbon fiber support sections |
| 1398 | // Inputs: |
| 1399 | // Int_t n size of arrays xc,yc, and r. |
| 1400 | // Double_t *xc array of x values for radii centers. |
| 1401 | // Double_t *yc array of y values for radii centers. |
| 1402 | // Double_t *r array of signed radii values. |
| 1403 | // Double_t *ths array of starting angles [degrees]. |
| 1404 | // Double_t *the array of ending angles [degrees]. |
| 1405 | // Int_t npr the number of lines segments to aproximate the arc. |
| 1406 | // Outputs (arguments passed by reference): |
| d0048cec |
1407 | // Int_t m the number of enetries in the arrays *xp[npr+1] |
| 54c9a3d9 |
1408 | // and *yp[npr+1]. |
| 1409 | // Double_t **xp array of x coordinate values of the line segments |
| 1410 | // which make up the SPD support sector shape. |
| 1411 | // Double_t **yp array of y coordinate values of the line segments |
| 1412 | // which make up the SPD support sector shape. |
| 1413 | // |
| 1414 | Int_t i, k; |
| 1415 | Double_t t, t0, t1; |
| 1416 | |
| 1417 | m = n*(npr + 1); |
| 1418 | if(GetDebug(2)) { |
| 1419 | cout <<" X \t Y \t R \t S \t E" << m << endl; |
| 1420 | for(i = 0; i < n; i++) { |
| 1421 | cout << "{" << xc[i] << ", "; |
| 1422 | cout << yc[i] << ", "; |
| 1423 | cout << r[i] << ", "; |
| 1424 | cout << ths[i] << ", "; |
| 1425 | cout << the[i] << "}, " << endl; |
| 1426 | } // end for i |
| 1427 | } // end if(GetDebug(2)) |
| 1428 | if (GetDebug(3)) cout << "Double_t sA0 = [" << n*(npr+1)+1<<"]["; |
| 1429 | if (GetDebug(4)) cout << "3] {"; |
| 1430 | else if(GetDebug(3)) cout <<"2] {"; |
| 1431 | t0 = (Double_t)npr; |
| 1432 | for(i = 0; i < n; i++) { |
| 1433 | t1 = (the[i] - ths[i]) / t0; |
| 1434 | if(GetDebug(5)) cout << "t1 = " << t1 << endl; |
| 1435 | for(k = 0; k <= npr; k++) { |
| 1436 | t = ths[i] + ((Double_t)k) * t1; |
| 1437 | xp[i][k] = TMath::Abs(r[i]) * CosD(t) + xc[i]; |
| 1438 | yp[i][k] = TMath::Abs(r[i]) * SinD(t) + yc[i]; |
| 1439 | if(GetDebug(3)) { |
| 1440 | cout << "{" << xp[i][k] << "," << yp[i][k]; |
| 1441 | if (GetDebug(4)) cout << "," << t; |
| 1442 | cout << "},"; |
| 1443 | } // end if GetDebug |
| 1444 | } // end for k |
| 1445 | if(GetDebug(3)) cout << endl; |
| 1446 | } // end of i |
| 1447 | if(GetDebug(3)) cout << "{" << xp[0][0] << ", " << yp[0][0]; |
| 1448 | if(GetDebug(4)) cout << "," << ths[0]; |
| 1449 | if(GetDebug(3)) cout << "}}" << endl; |
| 592651e2 |
1450 | } |
| 22726349 |
1451 | |
| 54c9a3d9 |
1452 | //______________________________________________________________________ |
| 1453 | TGeoVolume* AliITSv11GeometrySPD::CreateLadder(Int_t layer,TArrayD &sizes, |
| 1454 | TGeoManager *mgr) const |
| bc3498f4 |
1455 | { |
| 54c9a3d9 |
1456 | // |
| 1457 | // Creates the "ladder" = silicon sensor + 5 chips. |
| 1458 | // Returns a TGeoVolume containing the following components: |
| 1459 | // - the sensor (TGeoBBox), whose name depends on the layer |
| 1460 | // - 5 identical chips (TGeoBBox) |
| 1461 | // - a guard ring around the sensor (subtraction of TGeoBBoxes), |
| 1462 | // which is separated from the rest of sensor because it is not |
| 1463 | // a sensitive part |
| 1464 | // - bump bondings (TGeoBBox stripes for the whole width of the |
| 1465 | // sensor, one per column). |
| 1466 | // --- |
| 1467 | // Arguments: |
| 1468 | // 1 - the owner layer (MUST be 1 or 2 or a fatal error is raised) |
| 1469 | // 2 - a TArrayD passed by reference, which will contain relevant |
| 1470 | // dimensions related to this object: |
| 1471 | // size[0] = 'thickness' (the smallest dimension) |
| 1472 | // size[1] = 'length' (the direction along the ALICE Z axis) |
| d0048cec |
1473 | // size[2] = 'width' (extension in the direction perp. to the |
| 54c9a3d9 |
1474 | // above ones) |
| 1475 | // 3 - the used TGeoManager |
| 1476 | |
| d0048cec |
1477 | // ** CRITICAL CHECK ** |
| 54c9a3d9 |
1478 | // layer number can be ONLY 1 or 2 |
| 1479 | if (layer != 1 && layer != 2) AliFatal("Layer number MUST be 1 or 2"); |
| 1480 | |
| 1481 | // ** MEDIA ** |
| 1482 | TGeoMedium *medAir = GetMedium("AIR$",mgr); |
| 1483 | TGeoMedium *medSPDSiChip = GetMedium("SPD SI CHIP$",mgr); // SPD SI CHIP |
| 1484 | TGeoMedium *medSi = GetMedium("SI$",mgr); |
| 1485 | TGeoMedium *medBumpBond = GetMedium("COPPER$",mgr); // ??? BumpBond |
| d0048cec |
1486 | |
| 1487 | // ** SIZES ** |
| 54c9a3d9 |
1488 | Double_t chipThickness = fgkmm * 0.150; |
| 1489 | Double_t chipWidth = fgkmm * 15.950; |
| 1490 | Double_t chipLength = fgkmm * 13.600; |
| 1491 | Double_t chipSpacing = fgkmm * 0.400; // separation of chips along Z |
| 1492 | Double_t sensThickness = fgkmm * 0.200; |
| 1493 | Double_t sensLength = fgkmm * 69.600; |
| 1494 | Double_t sensWidth = fgkmm * 12.800; |
| d0048cec |
1495 | Double_t guardRingWidth = fgkmm * 0.560; // a border of this thickness |
| 54c9a3d9 |
1496 | // all around the sensor |
| 1497 | Double_t bbLength = fgkmm * 0.042; |
| 1498 | Double_t bbWidth = sensWidth; |
| 1499 | Double_t bbThickness = fgkmm * 0.012; |
| 1500 | Double_t bbPos = 0.080; // Z position w.r. to left pixel edge |
| 1501 | // compute the size of the container volume which |
| 1502 | // will also be returned in the referenced TArrayD; |
| 1503 | // for readability, they are linked by reference to a more meaningful name |
| 1504 | sizes.Set(3); |
| 1505 | Double_t &thickness = sizes[0]; |
| 1506 | Double_t &length = sizes[1]; |
| 1507 | Double_t &width = sizes[2]; |
| 1508 | // the container is a box which exactly enclose all the stuff; |
| 1509 | width = chipWidth; |
| 1510 | length = sensLength + 2.0*guardRingWidth; |
| 1511 | thickness = sensThickness + chipThickness + bbThickness; |
| 1512 | |
| 1513 | // ** VOLUMES ** |
| 1514 | // While creating this volume, since it is a sensitive volume, |
| 1515 | // we must respect some standard criteria for its local reference frame. |
| 1516 | // Local X must correspond to x coordinate of the sensitive volume: |
| d0048cec |
1517 | // this means that we are going to create the container with a local |
| 54c9a3d9 |
1518 | // reference system that is **not** in the middle of the box. |
| d0048cec |
1519 | // This is accomplished by calling the shape constructor with an |
| 54c9a3d9 |
1520 | // additional option ('originShift'): |
| 1521 | Double_t xSens = 0.5 * (width - sensWidth - 2.0*guardRingWidth); |
| 1522 | Double_t originShift[3] = {-xSens, 0., 0.}; |
| 1523 | TGeoBBox *shapeContainer = new TGeoBBox(0.5*width,0.5*thickness, |
| 1524 | 0.5*length,originShift); |
| 1525 | // then the volume is made of air, and using this shape |
| 1526 | TGeoVolume *container = new TGeoVolume(Form("ITSSPDlay%d-Ladder",layer), |
| 1527 | shapeContainer, medAir); |
| 1528 | // the chip is a common box |
| 1529 | TGeoVolume *volChip = mgr->MakeBox("ITSSPDchip",medSPDSiChip, |
| 1530 | 0.5*chipWidth,0.5*chipThickness,0.5*chipLength); |
| 1531 | // the sensor as well |
| 1532 | TGeoVolume *volSens = mgr->MakeBox(GetSenstiveVolumeName(layer),medSi, |
| 1533 | 0.5*sensWidth,0.5*sensThickness,0.5*sensLength); |
| d0048cec |
1534 | // the guard ring shape is the subtraction of two boxes with the |
| 54c9a3d9 |
1535 | // same center. |
| 1536 | TGeoBBox *shIn = new TGeoBBox(0.5*sensWidth,sensThickness,0.5*sensLength); |
| 1537 | TGeoBBox *shOut = new TGeoBBox(0.5*sensWidth+guardRingWidth, |
| 1538 | 0.5*sensThickness,0.5*sensLength+guardRingWidth); |
| 1539 | shIn->SetName("ITSSPDinnerBox"); |
| 1540 | shOut->SetName("ITSSPDouterBox"); |
| 1541 | TGeoCompositeShape *shBorder = new TGeoCompositeShape( |
| 1542 | "ITSSPDgaurdRingBorder",Form("%s-%s",shOut->GetName(),shIn->GetName())); |
| 1543 | TGeoVolume *volBorder = new TGeoVolume("ITSSPDgaurdRing",shBorder,medSi); |
| 1544 | // bump bonds for one whole column |
| 1545 | TGeoVolume *volBB = mgr->MakeBox("ITSSPDbb",medBumpBond,0.5*bbWidth, |
| 1546 | 0.5*bbThickness,0.5*bbLength); |
| 1547 | // set colors of all objects for visualization |
| 1548 | volSens->SetLineColor(kYellow + 1); |
| 1549 | volChip->SetLineColor(kGreen); |
| 1550 | volBorder->SetLineColor(kYellow + 3); |
| 1551 | volBB->SetLineColor(kGray); |
| 1552 | |
| 1553 | // ** MOVEMENTS ** |
| 1554 | // sensor is translated along thickness (X) and width (Y) |
| 1555 | Double_t ySens = 0.5 * (thickness - sensThickness); |
| 1556 | Double_t zSens = 0.0; |
| d0048cec |
1557 | // we want that the x of the ladder is the same as the one of |
| 54c9a3d9 |
1558 | // its sensitive volume |
| 1559 | TGeoTranslation *trSens = new TGeoTranslation(0.0, ySens, zSens); |
| 1560 | // bump bonds are translated along all axes: |
| 1561 | // keep same Y used for sensors, but change the Z |
| 1562 | TGeoTranslation *trBB[160]; |
| 1563 | Double_t x = 0.0; |
| 1564 | Double_t y = 0.5 * (thickness - bbThickness) - sensThickness; |
| 1565 | Double_t z = -0.5 * sensLength + guardRingWidth + fgkmm*0.425 - bbPos; |
| 1566 | Int_t i; |
| 1567 | for (i = 0; i < 160; i++) { |
| 1568 | trBB[i] = new TGeoTranslation(x, y, z); |
| 1569 | switch(i) { |
| 1570 | case 31:case 63:case 95:case 127: |
| 1571 | z += fgkmm * 0.625 + fgkmm * 0.2; |
| 1572 | break; |
| 1573 | default: |
| 1574 | z += fgkmm * 0.425; |
| 1575 | } // end switch |
| 1576 | } // end for i |
| 1577 | // the chips are translated along the length (Z) and thickness (X) |
| 1578 | TGeoTranslation *trChip[5] = {0, 0, 0, 0, 0}; |
| 1579 | x = -xSens; |
| 1580 | y = 0.5 * (chipThickness - thickness); |
| 1581 | z = 0.0; |
| 1582 | for (i = 0; i < 5; i++) { |
| d0048cec |
1583 | z = -0.5*length + guardRingWidth |
| 54c9a3d9 |
1584 | + (Double_t)i*chipSpacing + ((Double_t)(i) + 0.5)*chipLength; |
| 1585 | trChip[i] = new TGeoTranslation(x, y, z); |
| 1586 | } // end ofr i |
| d0048cec |
1587 | |
| 54c9a3d9 |
1588 | // add nodes to container |
| 1589 | container->AddNode(volSens, 1, trSens); |
| 1590 | container->AddNode(volBorder, 1, trSens); |
| 1591 | for (i = 0; i < 160; i++) container->AddNode(volBB,i+1,trBB[i]); |
| 1592 | for (i = 0; i < 5; i++) container->AddNode(volChip,i+3,trChip[i]); |
| 1593 | // return the container |
| 1594 | return container; |
| 592651e2 |
1595 | } |
| 22726349 |
1596 | |
| 1597 | /* |
| 1598 | //______________________________________________________________________ |
| 1599 | TGeoVolume* AliITSv11GeometrySPD::CreateLadder |
| 1600 | (Int_t layer, TArrayD &sizes, TGeoManager *mgr) const |
| 1601 | { |
| 1602 | // |
| 1603 | // Creates the "ladder" = silicon sensor + 5 chips. |
| 1604 | // Returns a TGeoVolume containing the following components: |
| 1605 | // - the sensor (TGeoBBox), whose name depends on the layer |
| 1606 | // - 5 identical chips (TGeoBBox) |
| 1607 | // - a guard ring around the sensor (subtraction of TGeoBBoxes), |
| 1608 | // which is separated from the rest of sensor because it is not |
| 1609 | // a sensitive part |
| 1610 | // - bump bondings (TGeoBBox stripes for the whole width of the |
| 1611 | // sensor, one per column). |
| 1612 | // --- |
| 1613 | // Arguments: |
| 1614 | // 1 - the owner layer (MUST be 1 or 2 or a fatal error is raised) |
| 1615 | // 2 - a TArrayD passed by reference, which will contain relevant |
| 1616 | // dimensions related to this object: |
| 1617 | // size[0] = 'thickness' (the smallest dimension) |
| 1618 | // size[1] = 'length' (the direction along the ALICE Z axis) |
| d0048cec |
1619 | // size[2] = 'width' (extension in the direction perp. to the |
| 22726349 |
1620 | // above ones) |
| 1621 | // 3 - the used TGeoManager |
| 1622 | |
| 1623 | // ** CRITICAL CHECK ****************************************************** |
| 1624 | // layer number can be ONLY 1 or 2 |
| 1625 | if (layer != 1 && layer != 2) AliFatal("Layer number MUST be 1 or 2"); |
| 1626 | |
| 1627 | // ** MEDIA *************************************************************** |
| d0048cec |
1628 | |
| 22726349 |
1629 | TGeoMedium *medAir = GetMedium("AIR$",mgr); |
| 1630 | TGeoMedium *medSPDSiChip = GetMedium("SPD SI CHIP$",mgr); // SPD SI CHIP |
| 1631 | TGeoMedium *medSi = GetMedium("SI$",mgr); |
| 1632 | TGeoMedium *medBumpBond = GetMedium("COPPER$",mgr); // ??? BumpBond |
| 1633 | |
| 1634 | // ** SIZES *************************************************************** |
| d0048cec |
1635 | |
| 22726349 |
1636 | Double_t chipThickness = fgkmm * 0.150; |
| 1637 | Double_t chipWidth = fgkmm * 15.950; |
| 1638 | Double_t chipLength = fgkmm * 13.600; |
| 1639 | Double_t chipSpacing = fgkmm * 0.400; // separation of chips along Z |
| 1640 | Double_t sensThickness = fgkmm * 0.200; |
| 1641 | Double_t sensLength = fgkmm * 69.600; |
| 1642 | Double_t sensWidth = fgkmm * 12.800; |
| 1643 | Double_t guardRingWidth = fgkmm * 0.560; // guard ring around sensor |
| 1644 | Double_t bbLength = fgkmm * 0.042; |
| 1645 | Double_t bbWidth = sensWidth; |
| 1646 | Double_t bbThickness = fgkmm * 0.012; |
| 1647 | Double_t bbPos = 0.080; // Z position w.r. to left pixel edge |
| d0048cec |
1648 | |
| 22726349 |
1649 | // the three dimensions of the box which contains the ladder |
| 1650 | // are returned in the 'sizes' argument, and are used for volumes positionement |
| 1651 | // for readability purpose, they are linked by reference to a more meaningful name |
| 1652 | sizes.Set(3); |
| 1653 | Double_t &thickness = sizes[0]; |
| 1654 | Double_t &length = sizes[1]; |
| 1655 | Double_t &width = sizes[2]; |
| 1656 | // the container is a box which exactly enclose all the stuff |
| 1657 | width = chipWidth; |
| 1658 | length = sensLength + 2.0*guardRingWidth; |
| 1659 | thickness = sensThickness + chipThickness + bbThickness; |
| 1660 | |
| 1661 | // ** VOLUMES ************************************************************* |
| d0048cec |
1662 | |
| 22726349 |
1663 | // This is a sensitive volume. |
| 1664 | // Local X must correspond to x coordinate of the sensitive volume: |
| d0048cec |
1665 | // to respect this, the origin of the local reference system |
| 1666 | // must be shifted from the middle of the box, using |
| 22726349 |
1667 | // an additional option ('originShift') when creating the container shape: |
| 1668 | Double_t xSens = 0.5 * (width - sensWidth - 2.0*guardRingWidth); |
| 1669 | Double_t originShift[3] = {-xSens, 0., 0.}; |
| d0048cec |
1670 | |
| 22726349 |
1671 | // now the container is a TGeoBBox with this shift, |
| 1672 | // and the volume is made of air (it does not exist in reality) |
| 1673 | TGeoBBox *shLadder = new TGeoBBox(0.5*width, 0.5*thickness, 0.5*length, originShift); |
| 1674 | TGeoVolume *vLadder = new TGeoVolume(Form("ITSSPDlay%d-Ladder", layer), shLadder, medAir); |
| d0048cec |
1675 | |
| 22726349 |
1676 | // the chip is a common box |
| d0048cec |
1677 | TGeoVolume *vChip = mgr->MakeBox("ITSSPDchip", medSPDSiChip, |
| 22726349 |
1678 | 0.5*chipWidth, 0.5*chipThickness, 0.5*chipLength); |
| d0048cec |
1679 | |
| 22726349 |
1680 | // to build the sensor with its guard ring, we create a TGeoBBox with the size |
| d0048cec |
1681 | // of the sensor + guard ring, and we insert the true sensor into it as an |
| 22726349 |
1682 | // internal node: this simplifies the implementation with the same result |
| 1683 | TGeoVolume *vSensGuard = mgr->MakeBox(Form("%s-guardRing", GetSenstiveVolumeName(layer)), |
| d0048cec |
1684 | medSi, |
| 22726349 |
1685 | 0.5*sensWidth + guardRingWidth, |
| 1686 | 0.5*sensThickness, |
| 1687 | 0.5*sensLength + guardRingWidth); |
| 1688 | TGeoVolume *vSens = mgr->MakeBox(GetSenstiveVolumeName(layer), medSi, |
| 1689 | 0.5*sensWidth,0.5*sensThickness,0.5*sensLength); |
| 1690 | vSensGuard->AddNode(vSens, 0); |
| 1691 | vSensGuard->SetTransparency(50); |
| d0048cec |
1692 | |
| 22726349 |
1693 | // bump bond is a common box for one whole column |
| 1694 | TGeoVolume *vBB = mgr->MakeBox("ITSSPDbb", medBumpBond, |
| 1695 | 0.5*bbWidth, 0.5*bbThickness, 0.5*bbLength); |
| d0048cec |
1696 | |
| 22726349 |
1697 | // set colors of all objects for visualization |
| 1698 | vLadder->SetLineColor(kRed); |
| 1699 | vSens->SetLineColor(kYellow + 1); |
| 1700 | vChip->SetLineColor(kGreen); |
| 1701 | vSensGuard->SetLineColor(kYellow + 3); |
| 1702 | vBB->SetLineColor(kGray); |
| 1703 | |
| 1704 | // ** MOVEMENTS ** |
| 1705 | // sensor is translated along thickness (Y) and width (X) |
| 1706 | Double_t ySens = 0.5 * (thickness - sensThickness); |
| 1707 | Double_t zSens = 0.0; |
| d0048cec |
1708 | // we want that the x of the ladder is the same as the one of |
| 22726349 |
1709 | // its sensitive volume |
| 1710 | TGeoTranslation *trSens = new TGeoTranslation(0.0, ySens, zSens); |
| 1711 | // bump bonds are translated along all axes: |
| 1712 | // keep same Y used for sensors, but change the Z |
| 1713 | TGeoTranslation *trBB[160]; |
| 1714 | Double_t x = 0.0; |
| 1715 | Double_t y = 0.5 * (thickness - bbThickness) - sensThickness; |
| 1716 | Double_t z = -0.5 * sensLength + guardRingWidth + fgkmm*0.425 - bbPos; |
| 1717 | Int_t i; |
| 1718 | for (i = 0; i < 160; i++) { |
| 1719 | trBB[i] = new TGeoTranslation(x, y, z); |
| 1720 | switch(i) { |
| 1721 | case 31:case 63:case 95:case 127: |
| 1722 | z += fgkmm * 0.625 + fgkmm * 0.2; |
| 1723 | break; |
| 1724 | default: |
| 1725 | z += fgkmm * 0.425; |
| 1726 | } // end switch |
| 1727 | } // end for i |
| 1728 | // the chips are translated along the length (Z) and thickness (X) |
| 1729 | TGeoTranslation *trChip[5] = {0, 0, 0, 0, 0}; |
| 1730 | x = -xSens; |
| 1731 | y = 0.5 * (chipThickness - thickness); |
| 1732 | z = 0.0; |
| 1733 | for (i = 0; i < 5; i++) { |
| d0048cec |
1734 | z = -0.5*length + guardRingWidth |
| 22726349 |
1735 | + (Double_t)i*chipSpacing + ((Double_t)(i) + 0.5)*chipLength; |
| 1736 | trChip[i] = new TGeoTranslation(x, y, z); |
| 1737 | } // end ofr i |
| d0048cec |
1738 | |
| 22726349 |
1739 | // add nodes to container |
| 1740 | vLadder->AddNode(vSensGuard, 1, trSens); |
| 1741 | //vLadderAddNode(volBorder, 1, trSens); |
| 1742 | for (i = 0; i < 160; i++) vLadder->AddNode(vBB,i+1,trBB[i]); |
| 1743 | for (i = 0; i < 5; i++) vLadder->AddNode(vChip,i+3,trChip[i]); |
| 1744 | // return the container |
| 1745 | return vLadder; |
| 1746 | } |
| 1747 | */ |
| 1748 | |
| 7855ea93 |
1749 | //______________________________________________________________________ |
| 54c9a3d9 |
1750 | TGeoVolume* AliITSv11GeometrySPD::CreateClip(TArrayD &sizes,Bool_t isDummy, |
| 1751 | TGeoManager *mgr) const |
| 1752 | { |
| 1753 | // |
| 1754 | // Creates the carbon fiber clips which are added to the central ladders. |
| 1755 | // They have a complicated shape which is approximated by a TGeoXtru |
| 1756 | // Implementation of a single clip over an half-stave. |
| 1757 | // It has a complicated shape which is approximated to a section like this: |
| d0048cec |
1758 | // |
| 54c9a3d9 |
1759 | // 6 |
| 1760 | // /\ . |
| 1761 | // 7 //\\ 5 |
| 1762 | // / 1\\___________________4 |
| 1763 | // 0 \___________________ |
| 1764 | // 2 3 |
| d0048cec |
1765 | // with a finite thickness for all the shape |
| 54c9a3d9 |
1766 | // Its local reference frame is such that point A corresponds to origin. |
| d0048cec |
1767 | // |
| 54c9a3d9 |
1768 | Double_t fullLength = fgkmm * 12.6; // = x4 - x0 |
| 1769 | Double_t flatLength = fgkmm * 5.4; // = x4 - x3 |
| 1770 | Double_t inclLongLength = fgkmm * 5.0; // = 5-6 |
| 1771 | Double_t inclShortLength = fgkmm * 2.0; // = 6-7 |
| 1772 | Double_t fullHeight = fgkmm * 2.8; // = y6 - y3 |
| 3ffa185f |
1773 | Double_t thickness = fgkmm * 0.18; // thickness |
| 54c9a3d9 |
1774 | Double_t totalLength = fgkmm * 52.0; // total length in Z |
| d0048cec |
1775 | Double_t holeSize = fgkmm * 5.0; // dimension of cubic |
| 54c9a3d9 |
1776 | // hole inserted for pt1000 |
| 1777 | Double_t angle1 = 27.0; // supplementary of angle DCB |
| 1778 | Double_t angle2; // angle DCB |
| 1779 | Double_t angle3; // angle of GH with vertical |
| d0048cec |
1780 | |
| 54c9a3d9 |
1781 | angle2 = 0.5 * (180.0 - angle1); |
| d0048cec |
1782 | angle3 = 90.0 - TMath::ACos(fullLength - flatLength - |
| 1783 | inclLongLength*TMath::Cos(angle1)) * |
| 54c9a3d9 |
1784 | TMath::RadToDeg(); |
| 1785 | angle1 *= TMath::DegToRad(); |
| 1786 | angle2 *= TMath::DegToRad(); |
| 1787 | angle3 *= TMath::DegToRad(); |
| 1788 | |
| 1789 | Double_t x[8], y[8]; |
| d0048cec |
1790 | |
| 54c9a3d9 |
1791 | x[0] = 0.0; |
| 1792 | x[1] = x[0] + fullLength - flatLength - inclLongLength*TMath::Cos(angle1); |
| 1793 | x[2] = x[0] + fullLength - flatLength; |
| 1794 | x[3] = x[0] + fullLength; |
| 1795 | x[4] = x[3]; |
| 1796 | x[5] = x[4] - flatLength + thickness * TMath::Cos(angle2); |
| 1797 | x[6] = x[1]; |
| 1798 | x[7] = x[0]; |
| d0048cec |
1799 | |
| 54c9a3d9 |
1800 | y[0] = 0.0; |
| 1801 | y[1] = y[0] + inclShortLength * TMath::Cos(angle3); |
| 1802 | y[2] = y[1] - inclLongLength * TMath::Sin(angle1); |
| 1803 | y[3] = y[2]; |
| 1804 | y[4] = y[3] + thickness; |
| 1805 | y[5] = y[4]; |
| 1806 | y[6] = y[1] + thickness; |
| 1807 | y[7] = y[0] + thickness; |
| d0048cec |
1808 | |
| 54c9a3d9 |
1809 | sizes.Set(7); |
| 1810 | sizes[0] = totalLength; |
| 1811 | sizes[1] = fullHeight; |
| 1812 | sizes[2] = y[2]; |
| 1813 | sizes[3] = y[6]; |
| 1814 | sizes[4] = x[0]; |
| 1815 | sizes[5] = x[3]; |
| 1816 | sizes[6] = x[2]; |
| 1817 | |
| 1818 | if(isDummy){// use this argument when on ewant just the |
| 1819 | // positions without create any volume |
| 1820 | return NULL; |
| 1821 | } // end if isDummy |
| 1822 | |
| 1823 | TGeoXtru *shClip = new TGeoXtru(2); |
| 1824 | shClip->SetName("ITSSPDshclip"); |
| 1825 | shClip->DefinePolygon(8, x, y); |
| 1826 | shClip->DefineSection(0, -0.5*totalLength, 0., 0., 1.0); |
| 1827 | shClip->DefineSection(1, 0.5*totalLength, 0., 0., 1.0); |
| d0048cec |
1828 | |
| 54c9a3d9 |
1829 | TGeoBBox *shHole = new TGeoBBox("ITSSPDSHClipHole",0.5*holeSize, |
| 1830 | 0.5*holeSize,0.5*holeSize); |
| 1831 | TGeoTranslation *tr1 = new TGeoTranslation("ITSSPDTRClipHole1",x[2],0.0, |
| 1832 | fgkmm*14.); |
| 1833 | TGeoTranslation *tr2 = new TGeoTranslation("ITSSPDTRClipHole2",x[2],0.0, |
| 1834 | 0.0); |
| 1835 | TGeoTranslation *tr3 = new TGeoTranslation("ITSSPDTRClipHole3",x[2],0.0, |
| 1836 | -fgkmm*14.); |
| 1837 | tr1->RegisterYourself(); |
| 1838 | tr2->RegisterYourself(); |
| 1839 | tr3->RegisterYourself(); |
| 1840 | |
| 1841 | //TString strExpr("ITSSPDshclip-("); |
| 1842 | TString strExpr(shClip->GetName()); |
| 1843 | strExpr.Append("-("); |
| 1844 | strExpr.Append(Form("%s:%s+", shHole->GetName(), tr1->GetName())); |
| 1845 | strExpr.Append(Form("%s:%s+", shHole->GetName(), tr2->GetName())); |
| 1846 | strExpr.Append(Form("%s:%s)", shHole->GetName(), tr3->GetName())); |
| 1847 | TGeoCompositeShape *shClipHole = new TGeoCompositeShape( |
| 1848 | "ITSSPDSHClipHoles",strExpr.Data()); |
| 1849 | |
| 1850 | TGeoMedium *mat = GetMedium("SPD C (M55J)$", mgr); |
| 1851 | TGeoVolume *vClip = new TGeoVolume("ITSSPDclip", shClipHole, mat); |
| 1852 | vClip->SetLineColor(kGray + 2); |
| 1853 | return vClip; |
| 1854 | }//______________________________________________________________________ |
| 7855ea93 |
1855 | TGeoCompositeShape* AliITSv11GeometrySPD::CreateGroundingFoilShape |
| 54c9a3d9 |
1856 | (Int_t itype,Double_t &length,Double_t &width, |
| 1857 | Double_t thickness,TArrayD &sizes) |
| bc3498f4 |
1858 | { |
| 54c9a3d9 |
1859 | // |
| d0048cec |
1860 | // Creates the typical composite shape of the grounding foil: |
| 1861 | // |
| 54c9a3d9 |
1862 | // +---------------------------------------------------------+ |
| 1863 | // | 5 6 9 | |
| 1864 | // | +-----------+ +------------+ 10 |
| 1865 | // | O | | | |
| 1866 | // | 3 /-----+ 4 +------+ |
| 1867 | // | 1 / 7 8 |
| 1868 | // | /----------/ |
| 1869 | // +-----/ 2 + |
| 1870 | // 0 |
| 1871 | // Z + 11 |
| 1872 | // |
| d0048cec |
1873 | // This shape is used 4 times: two layers of glue, one in kapton |
| 1874 | // and one in aluminum, taking into account that the aliminum |
| 54c9a3d9 |
1875 | // layer has small differences in the size of some parts. |
| 1876 | // --- |
| d0048cec |
1877 | // In order to overcome problems apparently due to a large number |
| 1878 | // of points, the shape creation is done according the following |
| 54c9a3d9 |
1879 | // steps: |
| d0048cec |
1880 | // 1) a TGeoBBox is created with a size right enough to contain |
| 54c9a3d9 |
1881 | // the whole shape (0-1-X-13) |
| d0048cec |
1882 | // 2) holes are defined as other TGeoBBox which are subtracted |
| 54c9a3d9 |
1883 | // from the main shape |
| d0048cec |
1884 | // 3) a TGeoXtru is defined connecting the points (0-->11-->0) |
| 54c9a3d9 |
1885 | // and is also subtracted from the main shape |
| 1886 | // --- |
| d0048cec |
1887 | // The argument ("type") is used to choose between all these |
| 54c9a3d9 |
1888 | // possibilities: |
| 1889 | // - type = 0 --> kapton layer |
| 1890 | // - type = 1 --> aluminum layer |
| 1891 | // - type = 2 --> glue layer between support and GF |
| 1892 | // - type = 3 --> glue layer between GF and ladders |
| d0048cec |
1893 | // Returns: a TGeoCompositeShape which will then be used to shape |
| 1894 | // several volumes. Since TGeoXtru is used, the local reference |
| 54c9a3d9 |
1895 | // frame of this object has X horizontal and Y vertical w.r to |
| 1896 | // the shape drawn above, and Z axis going perpendicularly to the screen. |
| d0048cec |
1897 | // This is not the correct reference for the half stave, for which |
| 1898 | // the "long" dimension is Z and the "short" is X, while Y goes in |
| 1899 | // the direction of thickness. This will imply some rotations when |
| 54c9a3d9 |
1900 | // using the volumes created with this shape. |
| d0048cec |
1901 | |
| 54c9a3d9 |
1902 | // suffix to differentiate names |
| 1903 | Char_t type[10]; |
| d0048cec |
1904 | |
| 54c9a3d9 |
1905 | // size of the virtual box containing exactly this volume |
| 1906 | length = fgkmm * 243.18; |
| 1907 | width = fgkmm * 15.95; |
| 1908 | if (itype == 1) { |
| 1909 | length -= fgkmm * 0.4; |
| 1910 | width -= fgkmm * 0.4; |
| 1911 | } // end if itype==1 |
| 1912 | switch (itype) { |
| 1913 | case 0: |
| 1914 | sprintf(type,"Kap"); |
| 1915 | break; |
| 1916 | case 1: |
| 1917 | sprintf(type,"Alu"); |
| 1918 | break; |
| 1919 | case 2: |
| 1920 | sprintf(type,"Glue1"); |
| 1921 | break; |
| 1922 | case 3: |
| 1923 | sprintf(type,"Glue2"); |
| 1924 | break; |
| 1925 | } |
| d0048cec |
1926 | // we divide the shape in several slices along the horizontal |
| 1927 | // direction (local X) here we define define the length of all |
| 54c9a3d9 |
1928 | // sectors (from leftmost to rightmost) |
| 1929 | Int_t i; |
| 1930 | Double_t sliceLength[] = { 140.71, 2.48, 26.78, 4.00, |
| 1931 | 10.00, 24.40, 10.00, 24.81 }; |
| 1932 | for (i = 0; i < 8; i++) sliceLength[i] *= fgkmm; |
| 1933 | if (itype == 1) { |
| 1934 | sliceLength[0] -= fgkmm * 0.2; |
| 1935 | sliceLength[4] -= fgkmm * 0.2; |
| 1936 | sliceLength[5] += fgkmm * 0.4; |
| 1937 | sliceLength[6] -= fgkmm * 0.4; |
| 1938 | } // end if itype ==1 |
| d0048cec |
1939 | |
| 1940 | // as shown in the drawing, we have four different widths |
| 54c9a3d9 |
1941 | // (along local Y) in this shape: |
| 1942 | Double_t widthMax = fgkmm * 15.95; |
| 1943 | Double_t widthMed1 = fgkmm * 15.00; |
| 1944 | Double_t widthMed2 = fgkmm * 11.00; |
| 1945 | Double_t widthMin = fgkmm * 4.40; |
| 1946 | if (itype == 1) { |
| 1947 | widthMax -= fgkmm * 0.4; |
| 1948 | widthMed1 -= fgkmm * 0.4; |
| 1949 | widthMed2 -= fgkmm * 0.4; |
| 1950 | widthMin -= fgkmm * 0.4; |
| 1951 | } // end if itype==1 |
| d0048cec |
1952 | |
| 54c9a3d9 |
1953 | // create the main shape |
| 1954 | TGeoBBox *shGroundFull = 0; |
| 1955 | shGroundFull = new TGeoBBox(Form("ITSSPDSHgFoil%sFull", type), |
| 1956 | 0.5*length,0.5*width, 0.5*thickness); |
| d0048cec |
1957 | |
| 1958 | // create the polygonal shape to be subtracted to give the correct |
| 1959 | // shape to the borders its vertices are defined in sugh a way that |
| 1960 | // this polygonal will be placed in the correct place considered |
| 1961 | // that the origin of the local reference frame is in the center |
| 1962 | // of the main box: we fix the starting point at the lower-left |
| 1963 | // edge of the shape (point 12), and add all points in order, |
| 54c9a3d9 |
1964 | // following a clockwise rotation |
| d0048cec |
1965 | |
| 54c9a3d9 |
1966 | Double_t x[13], y[13]; |
| 1967 | x[ 0] = -0.5 * length + sliceLength[0]; |
| 1968 | y[ 0] = -0.5 * widthMax; |
| 1969 | |
| 1970 | x[ 1] = x[0] + sliceLength[1]; |
| 1971 | y[ 1] = y[0] + (widthMax - widthMed1); |
| 1972 | |
| 1973 | x[ 2] = x[1] + sliceLength[2]; |
| 1974 | y[ 2] = y[1]; |
| 1975 | |
| 1976 | x[ 3] = x[2] + sliceLength[3]; |
| 1977 | y[ 3] = y[2] + (widthMed1 - widthMed2); |
| 1978 | |
| 1979 | x[ 4] = x[3] + sliceLength[4]; |
| 1980 | y[ 4] = y[3]; |
| 1981 | |
| 1982 | x[ 5] = x[4]; |
| 1983 | y[ 5] = y[4] + (widthMed2 - widthMin); |
| 1984 | |
| 1985 | x[ 6] = x[5] + sliceLength[5]; |
| 1986 | y[ 6] = y[5]; |
| 1987 | |
| 1988 | x[ 7] = x[6]; |
| 1989 | y[ 7] = y[4]; |
| 1990 | |
| 1991 | x[ 8] = x[7] + sliceLength[6]; |
| 1992 | y[ 8] = y[7]; |
| 1993 | |
| 1994 | x[ 9] = x[8]; |
| 1995 | y[ 9] = y[6]; |
| 1996 | |
| 1997 | x[10] = x[9] + sliceLength[7] + 0.5; |
| 1998 | y[10] = y[9]; |
| 1999 | |
| 2000 | x[11] = x[10]; |
| 2001 | y[11] = y[0] - 0.5; |
| 2002 | |
| 2003 | x[12] = x[0]; |
| 2004 | y[12] = y[11]; |
| 2005 | |
| 2006 | // create the shape |
| 2007 | TGeoXtru *shGroundXtru = new TGeoXtru(2); |
| 2008 | shGroundXtru->SetName(Form("ITSSPDSHgFoil%sXtru", type)); |
| 2009 | shGroundXtru->DefinePolygon(13, x, y); |
| 2010 | shGroundXtru->DefineSection(0, -thickness, 0., 0., 1.0); |
| 2011 | shGroundXtru->DefineSection(1, thickness, 0., 0., 1.0); |
| d0048cec |
2012 | |
| 54c9a3d9 |
2013 | // define a string which will express the algebric operations among volumes |
| 2014 | // and add the subtraction of this shape from the main one |
| 2015 | TString strComposite(Form("ITSSPDSHgFoil%sFull-(%s+", type, |
| 2016 | shGroundXtru->GetName())); |
| d0048cec |
2017 | |
| 54c9a3d9 |
2018 | // define the holes according to size information coming from drawings: |
| 2019 | Double_t holeLength = fgkmm * 10.00; |
| 2020 | Double_t holeWidth = fgkmm * 7.50; |
| d0048cec |
2021 | Double_t holeSepX0 = fgkmm * 7.05; // separation between center |
| 54c9a3d9 |
2022 | // of first hole and left border |
| d0048cec |
2023 | Double_t holeSepXC = fgkmm * 14.00; // separation between the centers |
| 54c9a3d9 |
2024 | // of two consecutive holes |
| d0048cec |
2025 | Double_t holeSepX1 = fgkmm * 15.42; // separation between centers of |
| 54c9a3d9 |
2026 | // 5th and 6th hole |
| d0048cec |
2027 | Double_t holeSepX2 = fgkmm * 22.00; // separation between centers of |
| 54c9a3d9 |
2028 | // 10th and 11th hole |
| 2029 | if (itype == 1) { |
| 2030 | holeSepX0 -= fgkmm * 0.2; |
| 2031 | holeLength += fgkmm * 0.4; |
| 2032 | holeWidth += fgkmm * 0.4; |
| 2033 | } // end if itype==1 |
| 2034 | sizes.Set(7); |
| 2035 | sizes[0] = holeLength; |
| 2036 | sizes[1] = holeWidth; |
| 2037 | sizes[2] = holeSepX0; |
| 2038 | sizes[3] = holeSepXC; |
| 2039 | sizes[4] = holeSepX1; |
| 2040 | sizes[5] = holeSepX2; |
| 2041 | sizes[6] = fgkmm * 4.40; |
| d0048cec |
2042 | |
| 54c9a3d9 |
2043 | // X position of hole center (will change for each hole) |
| 2044 | Double_t holeX = -0.5*length; |
| 2045 | // Y position of center of all holes (= 4.4 mm from upper border) |
| 2046 | Double_t holeY = 0.5*(width - holeWidth) - widthMin; |
| d0048cec |
2047 | |
| 54c9a3d9 |
2048 | // create a shape for the holes (common) |
| 2049 | TGeoBBox *shHole = 0; |
| 2050 | shHole = new TGeoBBox(Form("ITSSPD%sGfoilHole", type),0.5*holeLength, |
| 2051 | 0.5*holeWidth, thickness); |
| d0048cec |
2052 | |
| 54c9a3d9 |
2053 | // insert the holes in the XTRU shape: |
| d0048cec |
2054 | // starting from the first value of X, they are simply |
| 54c9a3d9 |
2055 | // shifted along this axis |
| 2056 | char name[200]; |
| 2057 | TGeoTranslation *transHole[11]; |
| 4adcf390 |
2058 | for (i = 0; i < 11; i++) { |
| 54c9a3d9 |
2059 | // set the position of the hole, depending on index |
| 2060 | if (i == 0) { |
| 2061 | holeX += holeSepX0; |
| 2062 | }else if (i < 5) { |
| 2063 | holeX += holeSepXC; |
| 2064 | }else if (i == 5) { |
| 2065 | holeX += holeSepX1; |
| 2066 | }else if (i < 10) { |
| 2067 | holeX += holeSepXC; |
| 2068 | }else { |
| 2069 | holeX += holeSepX2; |
| 2070 | } // end if else if's |
| 2071 | //cout << i << " --> X = " << holeX << endl; |
| 2072 | sprintf(name,"ITSSPDTRgFoil%sHole%d", type, i); |
| 2073 | transHole[i] = new TGeoTranslation(name, holeX, holeY, 0.0); |
| 2074 | transHole[i]->RegisterYourself(); |
| 2075 | strComposite.Append(Form("ITSSPD%sGfoilHole:%s", type, name)); |
| 2076 | if (i < 10) strComposite.Append("+"); else strComposite.Append(")"); |
| 2077 | } // end for i |
| d0048cec |
2078 | |
| 54c9a3d9 |
2079 | // create composite shape |
| 2080 | TGeoCompositeShape *shGround = new TGeoCompositeShape( |
| 2081 | Form("ITSSPDSHgFoil%s", type), strComposite.Data()); |
| 2082 | |
| 2083 | return shGround; |
| 592651e2 |
2084 | } |
| 54c9a3d9 |
2085 | //______________________________________________________________________ |
| d0048cec |
2086 | TGeoVolumeAssembly* AliITSv11GeometrySPD::CreateGroundingFoil(Bool_t isRight, |
| 54c9a3d9 |
2087 | TArrayD &sizes, TGeoManager *mgr) |
| bc3498f4 |
2088 | { |
| 54c9a3d9 |
2089 | // |
| d0048cec |
2090 | // Create a volume containing all parts of the grounding foil a |
| 2091 | // for a half-stave. |
| 54c9a3d9 |
2092 | // It consists of 4 layers with the same shape but different thickness: |
| 2093 | // 1) a layer of glue |
| 2094 | // 2) the aluminum layer |
| 2095 | // 3) the kapton layer |
| 2096 | // 4) another layer of glue |
| 2097 | // --- |
| 2098 | // Arguments: |
| d0048cec |
2099 | // 1: a boolean value to know if it is the grounding foir for |
| 54c9a3d9 |
2100 | // the right or left side |
| 2101 | // 2: a TArrayD which will contain the dimension of the container box: |
| 2102 | // - size[0] = length along Z (the beam line direction) |
| d0048cec |
2103 | // - size[1] = the 'width' of the stave, which defines, together |
| 54c9a3d9 |
2104 | // with Z, the plane of the carbon fiber support |
| d0048cec |
2105 | // - size[2] = 'thickness' (= the direction along which all |
| 54c9a3d9 |
2106 | // stave components are superimposed) |
| 2107 | // 3: the TGeoManager |
| 2108 | // --- |
| d0048cec |
2109 | // The return value is a TGeoBBox volume containing all grounding |
| 54c9a3d9 |
2110 | // foil components. |
| 2111 | // to avoid strange behaviour of the geometry manager, |
| 2112 | // create a suffix to be used in the names of all shapes |
| 2113 | // |
| 2114 | char suf[5]; |
| 2115 | if (isRight) strcpy(suf, "R"); else strcpy(suf, "L"); |
| d0048cec |
2116 | // this volume will be created in order to ease its placement in |
| 2117 | // the half-stave; then, it is added here the small distance of |
| 2118 | // the "central" edge of each volume from the Z=0 plane in the stave |
| 54c9a3d9 |
2119 | // reference (which coincides with ALICE one) |
| 2120 | Double_t dist = fgkmm * 0.71; |
| d0048cec |
2121 | |
| 54c9a3d9 |
2122 | // define materials |
| 2123 | TGeoMedium *medKap = GetMedium("SPD KAPTON(POLYCH2)$", mgr); |
| 2124 | TGeoMedium *medAlu = GetMedium("AL$", mgr); |
| 2125 | TGeoMedium *medGlue = GetMedium("EPOXY$", mgr); //??? GLUE_GF_SUPPORT |
| d0048cec |
2126 | |
| 54c9a3d9 |
2127 | // compute the volume shapes (thicknesses change from one to the other) |
| 2128 | Double_t kpLength, kpWidth, alLength, alWidth; |
| 2129 | TArrayD kpSize, alSize, glSize; |
| ed0e944d |
2130 | Double_t kpThickness = fgkmm * 0.04; |
| 2131 | Double_t alThickness = fgkmm * 0.01; |
| 2132 | //cout << "AL THICKNESS" << alThickness << endl; |
| 2133 | //Double_t g0Thickness = fgkmm * 0.1175 - fgkGapHalfStave; |
| 2134 | //Double_t g1Thickness = fgkmm * 0.1175 - fgkGapLadder; |
| 2135 | Double_t g0Thickness = fgkmm * 0.1275 - fgkGapHalfStave; |
| 2136 | Double_t g1Thickness = fgkmm * 0.1275 - fgkGapLadder; |
| 54c9a3d9 |
2137 | TGeoCompositeShape *kpShape = CreateGroundingFoilShape(0,kpLength,kpWidth, |
| 2138 | kpThickness, kpSize); |
| 2139 | TGeoCompositeShape *alShape = CreateGroundingFoilShape(1,alLength,alWidth, |
| 2140 | alThickness, alSize); |
| 3ffa185f |
2141 | TGeoCompositeShape *g0Shape = CreateGroundingFoilShape(2,kpLength,kpWidth, |
| 2142 | g0Thickness, glSize); |
| 2143 | TGeoCompositeShape *g1Shape = CreateGroundingFoilShape(3,kpLength,kpWidth, |
| 2144 | g1Thickness, glSize); |
| d0048cec |
2145 | // create the component volumes and register their sizes in the |
| 2146 | // passed arrays for readability reasons, some reference variables |
| 54c9a3d9 |
2147 | // explicit the meaning of the array slots |
| 2148 | TGeoVolume *kpVol = new TGeoVolume(Form("ITSSPDgFoilKap%s",suf), |
| 2149 | kpShape, medKap); |
| 2150 | TGeoVolume *alVol = new TGeoVolume(Form("ITSSPDgFoilAlu%s",suf), |
| 2151 | alShape, medAlu); |
| 3ffa185f |
2152 | TGeoVolume *g0Vol = new TGeoVolume(Form("ITSSPDgFoilGlue%s",suf), |
| 2153 | g0Shape, medGlue); |
| 2154 | TGeoVolume *g1Vol = new TGeoVolume(Form("ITSSPDgFoilGlue%s",suf), |
| 2155 | g1Shape, medGlue); |
| 54c9a3d9 |
2156 | // set colors for the volumes |
| 2157 | kpVol->SetLineColor(kRed); |
| 2158 | alVol->SetLineColor(kGray); |
| 3ffa185f |
2159 | g0Vol->SetLineColor(kYellow); |
| 2160 | g1Vol->SetLineColor(kYellow); |
| 54c9a3d9 |
2161 | // create references for the final size object |
| 2162 | if (sizes.GetSize() != 3) sizes.Set(3); |
| 2163 | Double_t &fullThickness = sizes[0]; |
| 2164 | Double_t &fullLength = sizes[1]; |
| 2165 | Double_t &fullWidth = sizes[2]; |
| d0048cec |
2166 | // kapton leads the larger dimensions of the foil |
| 54c9a3d9 |
2167 | // (including the cited small distance from Z=0 stave reference plane) |
| 2168 | // the thickness is the sum of the ones of all components |
| 2169 | fullLength = kpLength + dist; |
| 2170 | fullWidth = kpWidth; |
| 3ffa185f |
2171 | fullThickness = kpThickness + alThickness + g0Thickness + g1Thickness; |
| 54c9a3d9 |
2172 | // create the container |
| d0048cec |
2173 | // TGeoMedium *air = GetMedium("AIR$", mgr); |
| 2174 | TGeoVolumeAssembly *container = new TGeoVolumeAssembly(Form("ITSSPDgFOIL-%s",suf)); |
| 2175 | // TGeoVolume *container = mgr->MakeBox(Form("ITSSPDgFOIL-%s",suf), |
| 2176 | // air, 0.5*fullThickness, 0.5*fullWidth, 0.5*fullLength); |
| 2177 | // create the common correction rotation (which depends of what side |
| 54c9a3d9 |
2178 | // we are building) |
| 2179 | TGeoRotation *rotCorr = new TGeoRotation(*gGeoIdentity); |
| 2180 | if (isRight) rotCorr->RotateY(90.0); |
| d0048cec |
2181 | else rotCorr->RotateY(-90.0); |
| 2182 | // compute the translations, which are in the length and |
| 54c9a3d9 |
2183 | // thickness directions |
| 2184 | Double_t x, y, z, shift = 0.0; |
| 2185 | if (isRight) shift = dist; |
| 2186 | // glue (bottom) |
| 3ffa185f |
2187 | x = -0.5*(fullThickness - g0Thickness); |
| 54c9a3d9 |
2188 | z = 0.5*(fullLength - kpLength) - shift; |
| 2189 | TGeoCombiTrans *glTrans0 = new TGeoCombiTrans(x, 0.0, z, rotCorr); |
| 2190 | // kapton |
| 3ffa185f |
2191 | x += 0.5*(g0Thickness + kpThickness); |
| 54c9a3d9 |
2192 | TGeoCombiTrans *kpTrans = new TGeoCombiTrans(x, 0.0, z, rotCorr); |
| 2193 | // aluminum |
| 2194 | x += 0.5*(kpThickness + alThickness); |
| 2195 | z = 0.5*(fullLength - alLength) - shift - 0.5*(kpLength - alLength); |
| 2196 | TGeoCombiTrans *alTrans = new TGeoCombiTrans(x, 0.0, z, rotCorr); |
| 2197 | // glue (top) |
| 3ffa185f |
2198 | x += 0.5*(alThickness + g1Thickness); |
| 54c9a3d9 |
2199 | z = 0.5*(fullLength - kpLength) - shift; |
| 2200 | TGeoCombiTrans *glTrans1 = new TGeoCombiTrans(x, 0.0, z, rotCorr); |
| d0048cec |
2201 | |
| ed0e944d |
2202 | //cout << fgkGapHalfStave << endl; |
| 2203 | //cout << g0Thickness << endl; |
| 2204 | //cout << kpThickness << endl; |
| 2205 | //cout << alThickness << endl; |
| 2206 | //cout << g1Thickness << endl; |
| 54c9a3d9 |
2207 | |
| 2208 | // add to container |
| 22726349 |
2209 | container->SetLineColor(kMagenta-10); |
| 54c9a3d9 |
2210 | container->AddNode(kpVol, 1, kpTrans); |
| 2211 | container->AddNode(alVol, 1, alTrans); |
| 3ffa185f |
2212 | container->AddNode(g0Vol, 1, glTrans0); |
| d0048cec |
2213 | container->AddNode(g1Vol, 2, glTrans1); |
| 2214 | // to add the grease we remember the sizes of the holes, stored as |
| 54c9a3d9 |
2215 | // additional parameters in the kapton layer size: |
| 2216 | // - sizes[3] = hole length |
| 2217 | // - sizes[4] = hole width |
| 2218 | // - sizes[5] = position of first hole center |
| 2219 | // - sizes[6] = standard separation between holes |
| 2220 | // - sizes[7] = separation between 5th and 6th hole |
| 2221 | // - sizes[8] = separation between 10th and 11th hole |
| d0048cec |
2222 | // - sizes[9] = separation between the upper hole border and |
| 54c9a3d9 |
2223 | // the foil border |
| 2224 | Double_t holeLength = kpSize[0]; |
| 2225 | Double_t holeWidth = kpSize[1]; |
| 2226 | Double_t holeFirstZ = kpSize[2]; |
| 2227 | Double_t holeSepZ = kpSize[3]; |
| 2228 | Double_t holeSep5th6th = kpSize[4]; |
| 2229 | Double_t holeSep10th11th = kpSize[5]; |
| 2230 | Double_t holeSepY = kpSize[6]; |
| 2231 | // volume (common) |
| 2232 | // Grease has not been defined to date. Need much more information |
| 2233 | // no this material! |
| 2234 | TGeoMedium *grease = GetMedium("SPD KAPTON(POLYCH2)$", mgr); // ??? GREASE |
| 2235 | TGeoVolume *hVol = mgr->MakeBox("ITSSPDGrease", grease, |
| 2236 | 0.5*fullThickness, 0.5*holeWidth, 0.5*holeLength); |
| 2237 | hVol->SetLineColor(kBlue); |
| 2238 | // displacement of volumes in the container |
| 2239 | Int_t idx = 1; // copy numbers start from 1. |
| 2240 | x = 0.0; |
| 2241 | y = 0.5*(fullWidth - holeWidth) - holeSepY; |
| 2242 | if (isRight) z = holeFirstZ - 0.5*fullLength + dist; |
| 2243 | else z = 0.5*fullLength - holeFirstZ - dist; |
| 2244 | for (Int_t i = 0; i < 11; i++) { |
| 2245 | TGeoTranslation *t = 0; |
| 2246 | t = new TGeoTranslation(x, y, -z); |
| 2247 | container->AddNode(hVol, idx++, t); |
| 2248 | if (i < 4) shift = holeSepZ; |
| 2249 | else if (i == 4) shift = holeSep5th6th; |
| 2250 | else if (i < 9) shift = holeSepZ; |
| 2251 | else shift = holeSep10th11th; |
| 2252 | if (isRight) z += shift; |
| 2253 | else z -= shift; |
| 2254 | } // end for i |
| 2255 | return container; |
| 592651e2 |
2256 | } |
| 54c9a3d9 |
2257 | //___________________________________________________________________ |
| 2258 | TGeoVolumeAssembly* AliITSv11GeometrySPD::CreateMCM(Bool_t isRight, |
| 2259 | TArrayD &sizes, TGeoManager *mgr) const |
| bc3498f4 |
2260 | { |
| 54c9a3d9 |
2261 | // |
| 2262 | // Create a TGeoAssembly containing all the components of the MCM. |
| 2263 | // The TGeoVolume container is rejected due to the possibility of overlaps |
| 2264 | // when placing this object on the carbon fiber sector. |
| 2265 | // The assembly contains: |
| 2266 | // - the thin part of the MCM (integrated circuit) |
| 2267 | // - the MCM chips (specifications from EDMS) |
| 2268 | // - the cap which covers the zone where chips are bound to MCM |
| 2269 | // --- |
| d0048cec |
2270 | // The local reference frame of this assembly is defined in such a way |
| 2271 | // that all volumes are contained in a virtual box whose center |
| 2272 | // is placed exactly in the middle of the occupied space w.r to all |
| 2273 | // directions. This will ease the positioning of this object in the |
| 2274 | // half-stave. The sizes of this virtual box are stored in |
| 54c9a3d9 |
2275 | // the array passed by reference. |
| 2276 | // --- |
| 2277 | // Arguments: |
| d0048cec |
2278 | // - a boolean flag to know if this is the "left" or "right" MCM, when |
| 2279 | // looking at the stave from above (i.e. the direction from which |
| 2280 | // one sees bus over ladders over grounding foil) and keeping the |
| 2281 | // continuous border in the upper part, one sees the thicker part |
| 54c9a3d9 |
2282 | // on the left or right. |
| d0048cec |
2283 | // - an array passed by reference which will contain the size of |
| 54c9a3d9 |
2284 | // the virtual container. |
| 2285 | // - a pointer to the used TGeoManager. |
| 2286 | // |
| 2287 | |
| 2288 | // to distinguish the "left" and "right" objects, a suffix is created |
| 2289 | char suf[5]; |
| 2290 | if (isRight) strcpy(suf, "R"); else strcpy(suf, "L"); |
| 2291 | |
| 2292 | // ** MEDIA ** |
| 2293 | TGeoMedium *medBase = GetMedium("SPD KAPTON(POLYCH2)$",mgr);// ??? MCM BASE |
| 2294 | TGeoMedium *medChip = GetMedium("SPD SI CHIP$",mgr); |
| 2295 | TGeoMedium *medCap = GetMedium("AL$",mgr); |
| 2296 | |
| d0048cec |
2297 | // The shape of the MCM is divided into 3 sectors with different |
| 54c9a3d9 |
2298 | // widths (Y) and lengths (X), like in this sketch: |
| 2299 | // |
| d0048cec |
2300 | // 0 1 2 |
| 54c9a3d9 |
2301 | // +---------------------+-----------------------------------+ |
| 2302 | // | 4 sect 2 | |
| 2303 | // | 6 sect 1 /-------------------+ |
| 2304 | // | sect 0 /--------------/ 3 |
| 2305 | // +--------------------/ 5 |
| 2306 | // 8 7 |
| 2307 | // |
| 2308 | // the inclination of all oblique borders (6-7, 4-5) is always 45 degrees. |
| 2309 | // From drawings we can parametrize the dimensions of all these sectors, |
| 2310 | // then the shape of this part of the MCM is implemented as a |
| d0048cec |
2311 | // TGeoXtru centerd in the virtual XY space. |
| 54c9a3d9 |
2312 | // The first step is definig the relevant sizes of this shape: |
| 2313 | Int_t i, j; |
| 2314 | Double_t mcmThickness = fgkmm * 0.35; |
| 2315 | Double_t sizeXtot = fgkmm * 105.6; // total distance (0-2) |
| 2316 | // resp. 7-8, 5-6 and 3-4 |
| 2317 | Double_t sizeXsector[3] = {fgkmm * 28.4, fgkmm * 41.4, fgkmm * 28.8}; |
| 2318 | // resp. 0-8, 1-6 and 2-3 |
| 2319 | Double_t sizeYsector[3] = {fgkmm * 15.0, fgkmm * 11.0, fgkmm * 8.0}; |
| 2320 | Double_t sizeSep01 = fgkmm * 4.0; // x(6)-x(7) |
| 2321 | Double_t sizeSep12 = fgkmm * 3.0; // x(4)-x(5) |
| 2322 | |
| 2323 | // define sizes of chips (last is the thickest) |
| 2324 | Double_t chipLength[5] = { 4.00, 6.15, 3.85, 5.60, 18.00 }; |
| 2325 | Double_t chipWidth[5] = { 3.00, 4.10, 3.85, 5.60, 5.45 }; |
| 2326 | Double_t chipThickness[5] = { 0.60, 0.30, 0.30, 1.00, 1.20 }; |
| 2327 | TString name[5]; |
| 2328 | name[0] = "ITSSPDanalog"; |
| 2329 | name[1] = "ITSSPDpilot"; |
| 2330 | name[2] = "ITSSPDgol"; |
| 2331 | name[3] = "ITSSPDrx40"; |
| 2332 | name[4] = "ITSSPDoptical"; |
| 2333 | Color_t color[5] = { kCyan, kGreen, kYellow, kBlue, kOrange }; |
| 2334 | |
| 2335 | // define the sizes of the cover |
| 2336 | Double_t capThickness = fgkmm * 0.3; |
| 2337 | Double_t capHeight = fgkmm * 1.7; |
| 2338 | |
| 2339 | // compute the total size of the virtual container box |
| 2340 | sizes.Set(3); |
| 2341 | Double_t &thickness = sizes[0]; |
| 2342 | Double_t &length = sizes[1]; |
| 2343 | Double_t &width = sizes[2]; |
| 2344 | length = sizeXtot; |
| 2345 | width = sizeYsector[0]; |
| 2346 | thickness = mcmThickness + capHeight; |
| 2347 | |
| d0048cec |
2348 | // define all the relevant vertices of the polygon |
| 54c9a3d9 |
2349 | // which defines the transverse shape of the MCM. |
| d0048cec |
2350 | // These values are used to several purposes, and |
| 54c9a3d9 |
2351 | // for each one, some points must be excluded |
| 2352 | Double_t xRef[9], yRef[9]; |
| 2353 | xRef[0] = -0.5*sizeXtot; |
| 2354 | yRef[0] = 0.5*sizeYsector[0]; |
| 2355 | xRef[1] = xRef[0] + sizeXsector[0] + sizeSep01; |
| 2356 | yRef[1] = yRef[0]; |
| 2357 | xRef[2] = -xRef[0]; |
| 2358 | yRef[2] = yRef[0]; |
| 2359 | xRef[3] = xRef[2]; |
| 2360 | yRef[3] = yRef[2] - sizeYsector[2]; |
| 2361 | xRef[4] = xRef[3] - sizeXsector[2]; |
| 2362 | yRef[4] = yRef[3]; |
| 2363 | xRef[5] = xRef[4] - sizeSep12; |
| 2364 | yRef[5] = yRef[4] - sizeSep12; |
| 2365 | xRef[6] = xRef[5] - sizeXsector[1]; |
| 2366 | yRef[6] = yRef[5]; |
| 2367 | xRef[7] = xRef[6] - sizeSep01; |
| 2368 | yRef[7] = yRef[6] - sizeSep01; |
| 2369 | xRef[8] = xRef[0]; |
| 2370 | yRef[8] = -yRef[0]; |
| 2371 | |
| d0048cec |
2372 | // the above points are defined for the "right" MCM (if ve view the |
| 2373 | // stave from above) in order to change to the "left" one, we must |
| 54c9a3d9 |
2374 | // change the sign to all X values: |
| 2375 | if (isRight) for (i = 0; i < 9; i++) xRef[i] = -xRef[i]; |
| d0048cec |
2376 | |
| 2377 | // the shape of the MCM and glue layer are done excluding point 1, |
| 54c9a3d9 |
2378 | // which is not necessary and cause the geometry builder to get confused |
| 2379 | j = 0; |
| 2380 | Double_t xBase[8], yBase[8]; |
| 2381 | for (i = 0; i < 9; i++) { |
| 2382 | if (i == 1) continue; |
| 2383 | xBase[j] = xRef[i]; |
| 2384 | yBase[j] = yRef[i]; |
| 2385 | j++; |
| 2386 | } // end for i |
| 2387 | |
| 2388 | // the MCM cover is superimposed over the zones 1 and 2 only |
| 2389 | Double_t xCap[6], yCap[6]; |
| 2390 | j = 0; |
| 2391 | for (i = 1; i <= 6; i++) { |
| 2392 | xCap[j] = xRef[i]; |
| 2393 | yCap[j] = yRef[i]; |
| 2394 | j++; |
| 2395 | } // end for i |
| 2396 | |
| d0048cec |
2397 | // define positions of chips, |
| 54c9a3d9 |
2398 | // which must be added to the bottom-left corner of MCM |
| 2399 | // and divided by 1E4; |
| 2400 | Double_t chipX[5], chipY[5]; |
| 2401 | if (isRight) { |
| 2402 | chipX[0] = 666320.; |
| 2403 | chipX[1] = 508320.; |
| 2404 | chipX[2] = 381320.; |
| 2405 | chipX[3] = 295320.; |
| 2406 | chipX[4] = 150320.; |
| 2407 | chipY[0] = 23750.; |
| 2408 | chipY[1] = 27750.; |
| 2409 | chipY[2] = 20750.; |
| 2410 | chipY[3] = 42750.; |
| 2411 | chipY[4] = 39750.; |
| 2412 | } else { |
| 2413 | chipX[0] = 389730.; |
| 2414 | chipX[1] = 548630.; |
| 2415 | chipX[2] = 674930.; |
| 2416 | chipX[3] = 761430.; |
| 2417 | chipX[4] = 905430.; |
| 2418 | chipY[0] = 96250.; |
| 2419 | chipY[1] = 91950.; |
| 2420 | chipY[2] = 99250.; |
| 2421 | chipY[3] = 107250.; |
| 2422 | chipY[4] = 109750.; |
| 2423 | } // end if isRight |
| 2424 | for (i = 0; i < 5; i++) { |
| 2425 | chipX[i] *= 0.00001; |
| 2426 | chipY[i] *= 0.00001; |
| 2427 | if (isRight) { |
| 2428 | chipX[i] += xRef[3]; |
| 2429 | chipY[i] += yRef[3]; |
| 2430 | } else { |
| 2431 | chipX[i] += xRef[8]; |
| 2432 | chipY[i] += yRef[8]; |
| 2433 | } // end for isRight |
| 2434 | chipLength[i] *= fgkmm; |
| 2435 | chipWidth[i] *= fgkmm; |
| 2436 | chipThickness[i] *= fgkmm; |
| 2437 | } // end for i |
| 2438 | |
| d0048cec |
2439 | // create shapes for MCM |
| 54c9a3d9 |
2440 | Double_t z1, z2; |
| 2441 | TGeoXtru *shBase = new TGeoXtru(2); |
| 2442 | z1 = -0.5*thickness; |
| 2443 | z2 = z1 + mcmThickness; |
| 2444 | shBase->DefinePolygon(8, xBase, yBase); |
| 2445 | shBase->DefineSection(0, z1, 0., 0., 1.0); |
| 2446 | shBase->DefineSection(1, z2, 0., 0., 1.0); |
| 2447 | |
| 2448 | // create volumes of MCM |
| 2449 | TGeoVolume *volBase = new TGeoVolume("ITSSPDbase", shBase, medBase); |
| 2450 | volBase->SetLineColor(kRed); |
| 2451 | |
| d0048cec |
2452 | // to create the border of the MCM cover, it is required the |
| 2453 | // subtraction of two shapes the outer is created using the |
| 54c9a3d9 |
2454 | // reference points defined here |
| 2455 | TGeoXtru *shCapOut = new TGeoXtru(2); |
| 2456 | shCapOut->SetName(Form("ITSSPDshCAPOUT%s", suf)); |
| 2457 | z1 = z2; |
| 2458 | z2 = z1 + capHeight - capThickness; |
| 2459 | shCapOut->DefinePolygon(6, xCap, yCap); |
| 2460 | shCapOut->DefineSection(0, z1, 0., 0., 1.0); |
| 2461 | shCapOut->DefineSection(1, z2, 0., 0., 1.0); |
| 2462 | // the inner is built similarly but subtracting the thickness |
| 2463 | Double_t angle, cs; |
| 2464 | Double_t xin[6], yin[6]; |
| 2465 | if (!isRight) { |
| 2466 | angle = 45.0; |
| 2467 | cs = TMath::Cos( 0.5*(TMath::Pi() - angle*TMath::DegToRad()) ); |
| 2468 | xin[0] = xCap[0] + capThickness; |
| 2469 | yin[0] = yCap[0] - capThickness; |
| 2470 | xin[1] = xCap[1] - capThickness; |
| 2471 | yin[1] = yin[0]; |
| 2472 | xin[2] = xin[1]; |
| 2473 | yin[2] = yCap[2] + capThickness; |
| 2474 | xin[3] = xCap[3] - capThickness*cs; |
| 2475 | yin[3] = yin[2]; |
| 2476 | xin[4] = xin[3] - sizeSep12; |
| 2477 | yin[4] = yCap[4] + capThickness; |
| 2478 | xin[5] = xin[0]; |
| 2479 | yin[5] = yin[4]; |
| 2480 | } else { |
| 2481 | angle = 45.0; |
| 2482 | cs = TMath::Cos( 0.5*(TMath::Pi() - angle*TMath::DegToRad()) ); |
| 2483 | xin[0] = xCap[0] - capThickness; |
| 2484 | yin[0] = yCap[0] - capThickness; |
| 2485 | xin[1] = xCap[1] + capThickness; |
| 2486 | yin[1] = yin[0]; |
| 2487 | xin[2] = xin[1]; |
| 2488 | yin[2] = yCap[2] + capThickness; |
| 2489 | xin[3] = xCap[3] - capThickness*cs; |
| 2490 | yin[3] = yin[2]; |
| 2491 | xin[4] = xin[3] + sizeSep12; |
| 2492 | yin[4] = yCap[4] + capThickness; |
| 2493 | xin[5] = xin[0]; |
| 2494 | yin[5] = yin[4]; |
| 2495 | } // end if !isRight |
| 2496 | TGeoXtru *shCapIn = new TGeoXtru(2); |
| 2497 | shCapIn->SetName(Form("ITSSPDshCAPIN%s", suf)); |
| 2498 | shCapIn->DefinePolygon(6, xin, yin); |
| 2499 | shCapIn->DefineSection(0, z1 - 0.01, 0., 0., 1.0); |
| 2500 | shCapIn->DefineSection(1, z2 + 0.01, 0., 0., 1.0); |
| 2501 | // compose shapes |
| 2502 | TGeoCompositeShape *shCapBorder = new TGeoCompositeShape( |
| d0048cec |
2503 | Form("ITSSPDshBORDER%s", suf), |
| 54c9a3d9 |
2504 | Form("%s-%s", shCapOut->GetName(), |
| 2505 | shCapIn->GetName())); |
| 2506 | // create volume |
| 2507 | TGeoVolume *volCapBorder = new TGeoVolume("ITSSPDcapBoarder", |
| 2508 | shCapBorder,medCap); |
| 2509 | volCapBorder->SetLineColor(kGreen); |
| d0048cec |
2510 | // finally, we create the top of the cover, which has the same |
| 2511 | // shape of outer border and a thickness equal of the one othe |
| 54c9a3d9 |
2512 | // cover border one |
| 2513 | TGeoXtru *shCapTop = new TGeoXtru(2); |
| 2514 | z1 = z2; |
| 2515 | z2 = z1 + capThickness; |
| 2516 | shCapTop->DefinePolygon(6, xCap, yCap); |
| 2517 | shCapTop->DefineSection(0, z1, 0., 0., 1.0); |
| 2518 | shCapTop->DefineSection(1, z2, 0., 0., 1.0); |
| 2519 | TGeoVolume *volCapTop = new TGeoVolume("ITSSPDcapTop", shCapTop, medCap); |
| 2520 | volCapTop->SetLineColor(kBlue); |
| 2521 | |
| 2522 | // create container assembly with right suffix |
| 2523 | TGeoVolumeAssembly *mcmAssembly = new TGeoVolumeAssembly( |
| 2524 | Form("ITSSPDmcm%s", suf)); |
| 2525 | |
| 2526 | // add mcm layer |
| 2527 | mcmAssembly->AddNode(volBase, 1, gGeoIdentity); |
| 2528 | // add chips |
| 2529 | for (i = 0; i < 5; i++) { |
| 2530 | TGeoVolume *box = gGeoManager->MakeBox(name[i],medChip, |
| 2531 | 0.5*chipLength[i], 0.5*chipWidth[i], 0.5*chipThickness[i]); |
| 2532 | TGeoTranslation *tr = new TGeoTranslation(chipX[i],chipY[i], |
| 2533 | 0.5*(-thickness + chipThickness[i]) + mcmThickness); |
| 2534 | box->SetLineColor(color[i]); |
| 2535 | mcmAssembly->AddNode(box, 1, tr); |
| 2536 | } // end for i |
| 2537 | // add cap border |
| 2538 | mcmAssembly->AddNode(volCapBorder, 1, gGeoIdentity); |
| 2539 | // add cap top |
| d0048cec |
2540 | mcmAssembly->AddNode(volCapTop, 1, gGeoIdentity); |
| 54c9a3d9 |
2541 | |
| 2542 | return mcmAssembly; |
| 592651e2 |
2543 | } |
| 7f69c251 |
2544 | |
| 2545 | /* |
| 2546 | //__________________________________________________________________________________________ |
| 2547 | TGeoVolumeAssembly* AliITSv11GeometrySPD::CreatePixelBus |
| 2548 | (Bool_t isRight, TArrayD &sizes, TGeoManager *mgr) const |
| 2549 | { |
| 3ffa185f |
2550 | // |
| d0048cec |
2551 | // The pixel bus is implemented as a TGeoBBox with some objects on it, |
| 3ffa185f |
2552 | // which could affect the particle energy loss. |
| 2553 | // --- |
| d0048cec |
2554 | // In order to avoid confusion, the bus is directly displaced |
| 3ffa185f |
2555 | // according to the axis orientations which are used in the final stave: |
| 2556 | // X --> thickness direction |
| 2557 | // Y --> width direction |
| 2558 | // Z --> length direction |
| 2559 | // |
| d0048cec |
2560 | |
| 2561 | |
| 3ffa185f |
2562 | // ** MEDIA ** |
| d0048cec |
2563 | |
| 3ffa185f |
2564 | //PIXEL BUS |
| 2565 | TGeoMedium *medBus = GetMedium("SPDBUS(AL+KPT+EPOX)$",mgr); |
| 2566 | TGeoMedium *medPt1000 = GetMedium("CERAMICS$",mgr); // ??? PT1000 |
| 2567 | // Capacity |
| 2568 | TGeoMedium *medCap = GetMedium("SDD X7R capacitors$",mgr); |
| 2569 | // ??? Resistance |
| 2570 | // TGeoMedium *medRes = GetMedium("SDD X7R capacitors$",mgr); |
| 2571 | TGeoMedium *medRes = GetMedium("ALUMINUM$",mgr); |
| 2572 | TGeoMedium *medExt = GetMedium("SDDKAPTON (POLYCH2)$", mgr); |
| 2573 | // ** SIZES & POSITIONS ** |
| 2574 | Double_t busLength = 170.501 * fgkmm; // length of plane part |
| 2575 | Double_t busWidth = 13.800 * fgkmm; // width |
| 2576 | Double_t busThickness = 0.280 * fgkmm; // thickness |
| 2577 | Double_t pt1000Length = fgkmm * 1.50; |
| 2578 | Double_t pt1000Width = fgkmm * 3.10; |
| 2579 | Double_t pt1000Thickness = fgkmm * 0.60; |
| 2580 | Double_t pt1000Y, pt1000Z[10];// position of the pt1000's along the bus |
| 2581 | Double_t capLength = fgkmm * 2.55; |
| 2582 | Double_t capWidth = fgkmm * 1.50; |
| 2583 | Double_t capThickness = fgkmm * 1.35; |
| 2584 | Double_t capY[2], capZ[2]; |
| d0048cec |
2585 | |
| 3ffa185f |
2586 | Double_t resLength = fgkmm * 2.20; |
| 2587 | Double_t resWidth = fgkmm * 0.80; |
| 2588 | Double_t resThickness = fgkmm * 0.35; |
| 2589 | Double_t resY[2], resZ[2]; |
| d0048cec |
2590 | |
| 3ffa185f |
2591 | Double_t extThickness = fgkmm * 0.25; |
| 2592 | Double_t ext1Length = fgkmm * (26.7 - 10.0); |
| 2593 | Double_t ext2Length = fgkmm * (285.0 - ext1Length + extThickness); |
| 2594 | Double_t extWidth = fgkmm * 11.0; |
| 2595 | Double_t extHeight = fgkmm * 2.5; |
| d0048cec |
2596 | |
| 2597 | |
| 2598 | // position of pt1000, resistors and capacitors depends on the |
| 3ffa185f |
2599 | // bus if it's left or right one |
| 2600 | if (!isRight) { |
| 2601 | pt1000Y = 64400.; |
| 2602 | pt1000Z[0] = 66160.; |
| 2603 | pt1000Z[1] = 206200.; |
| 2604 | pt1000Z[2] = 346200.; |
| 2605 | pt1000Z[3] = 486200.; |
| 2606 | pt1000Z[4] = 626200.; |
| 2607 | pt1000Z[5] = 776200.; |
| 2608 | pt1000Z[6] = 916200.; |
| 2609 | pt1000Z[7] = 1056200.; |
| 2610 | pt1000Z[8] = 1196200.; |
| d0048cec |
2611 | pt1000Z[9] = 1336200.; |
| 3ffa185f |
2612 | resZ[0] = 1397500.; |
| 2613 | resY[0] = 26900.; |
| 2614 | resZ[1] = 682500.; |
| 2615 | resY[1] = 27800.; |
| 2616 | capZ[0] = 1395700.; |
| 2617 | capY[0] = 45700.; |
| 2618 | capZ[1] = 692600.; |
| 2619 | capY[1] = 45400.; |
| 2620 | } else { |
| 2621 | pt1000Y = 66100.; |
| 2622 | pt1000Z[0] = 319700.; |
| 2623 | pt1000Z[1] = 459700.; |
| 2624 | pt1000Z[2] = 599700.; |
| 2625 | pt1000Z[3] = 739700.; |
| 2626 | pt1000Z[4] = 879700.; |
| 2627 | pt1000Z[5] = 1029700.; |
| 2628 | pt1000Z[6] = 1169700.; |
| 2629 | pt1000Z[7] = 1309700.; |
| 2630 | pt1000Z[8] = 1449700.; |
| d0048cec |
2631 | pt1000Z[9] = 1589700.; |
| 3ffa185f |
2632 | capY[0] = 44500.; |
| 2633 | capZ[0] = 266700.; |
| 2634 | capY[1] = 44300.; |
| 2635 | capZ[1] = 974700.; |
| 2636 | resZ[0] = 266500.; |
| 2637 | resY[0] = 29200.; |
| 2638 | resZ[1] = 974600.; |
| 2639 | resY[1] = 29900.; |
| 2640 | } // end if isRight |
| 2641 | Int_t i; |
| 2642 | pt1000Y *= 1E-4 * fgkmm; |
| 2643 | for (i = 0; i < 10; i++) { |
| 2644 | pt1000Z[i] *= 1E-4 * fgkmm; |
| 2645 | if (i < 2) { |
| 2646 | capZ[i] *= 1E-4 * fgkmm; |
| 2647 | capY[i] *= 1E-4 * fgkmm; |
| 2648 | resZ[i] *= 1E-4 * fgkmm; |
| 2649 | resY[i] *= 1E-4 * fgkmm; |
| 2650 | } // end if iM2 |
| 2651 | } // end for i |
| d0048cec |
2652 | |
| 3ffa185f |
2653 | Double_t &fullLength = sizes[1]; |
| 2654 | Double_t &fullWidth = sizes[2]; |
| 2655 | Double_t &fullThickness = sizes[0]; |
| 2656 | fullLength = busLength; |
| 2657 | fullWidth = busWidth; |
| 2658 | // add the thickness of the thickest component on bus (capacity) |
| d0048cec |
2659 | fullThickness = busThickness + capThickness; |
| 3ffa185f |
2660 | // ** VOLUMES ** |
| 2661 | TGeoVolumeAssembly *container = new TGeoVolumeAssembly("PixelBus"); |
| 2662 | TGeoVolume *bus = mgr->MakeBox("Bus", medBus, 0.5*busThickness, 0.5*busWidth, 0.5*busLength); |
| 2663 | TGeoVolume *pt1000 = mgr->MakeBox("PT1000", medPt1000, 0.5*pt1000Thickness, 0.5*pt1000Width, 0.5*pt1000Length); |
| 2664 | TGeoVolume *res = mgr->MakeBox("Resistor", medRes, 0.5*resThickness, 0.5*resWidth, 0.5*resLength); |
| 2665 | TGeoVolume *cap = mgr->MakeBox("Capacitor", medCap, 0.5*capThickness, 0.5*capWidth, 0.5*capLength); |
| 2666 | TGeoVolume *ext1 = mgr->MakeBox("Extender1", medExt, 0.5*extThickness, 0.5*extWidth, 0.5*ext1Length); |
| 2667 | TGeoVolume *ext2 = mgr->MakeBox("Extender2", medExt, 0.5*extHeight - extThickness, 0.5*extWidth, 0.5*extThickness); |
| 2668 | TGeoVolume *ext3 = mgr->MakeBox("Extender3", medExt, extThickness, 0.5*extWidth, 0.5*ext2Length); |
| 2669 | bus->SetLineColor(kYellow + 2); |
| 2670 | pt1000->SetLineColor(kGreen + 3); |
| 2671 | res->SetLineColor(kRed + 1); |
| 2672 | cap->SetLineColor(kBlue - 7); |
| 2673 | ext1->SetLineColor(kGray); |
| 2674 | ext2->SetLineColor(kGray); |
| 2675 | ext3->SetLineColor(kGray); |
| d0048cec |
2676 | |
| 3ffa185f |
2677 | // ** MOVEMENTS AND POSITIONEMENT ** |
| 2678 | // bus |
| d0048cec |
2679 | TGeoTranslation *trBus = new TGeoTranslation(0.5 * (busThickness - |
| 3ffa185f |
2680 | fullThickness), 0.0, 0.0); |
| 2681 | container->AddNode(bus, 0, trBus); |
| 2682 | Double_t zRef, yRef, x, y, z; |
| 2683 | if (isRight) { |
| 2684 | zRef = -0.5*fullLength; |
| 2685 | yRef = -0.5*fullWidth; |
| 2686 | } else { |
| 2687 | zRef = -0.5*fullLength; |
| 2688 | yRef = -0.5*fullWidth; |
| 2689 | } // end if isRight |
| 2690 | // pt1000 |
| 2691 | x = 0.5*(pt1000Thickness - fullThickness) + busThickness; |
| 2692 | for (i = 0; i < 10; i++) { |
| 2693 | y = yRef + pt1000Y; |
| 2694 | z = zRef + pt1000Z[i]; |
| 2695 | TGeoTranslation *tr = new TGeoTranslation(x, y, z); |
| 2696 | container->AddNode(pt1000, i, tr); |
| 2697 | } // end for i |
| 2698 | // capacitors |
| 2699 | x = 0.5*(capThickness - fullThickness) + busThickness; |
| 2700 | for (i = 0; i < 2; i++) { |
| 2701 | y = yRef + capY[i]; |
| 2702 | z = zRef + capZ[i]; |
| 2703 | TGeoTranslation *tr = new TGeoTranslation(x, y, z); |
| 2704 | container->AddNode(cap, i, tr); |
| 2705 | } // end for i |
| 2706 | // resistors |
| 2707 | x = 0.5*(resThickness - fullThickness) + busThickness; |
| 2708 | for (i = 0; i < 2; i++) { |
| 2709 | y = yRef + resY[i]; |
| 2710 | z = zRef + resZ[i]; |
| 2711 | TGeoTranslation *tr = new TGeoTranslation(x, y, z); |
| 2712 | container->AddNode(res, i, tr); |
| 2713 | } // end for i |
| 2714 | // extender |
| 2715 | if (isRight) { |
| 2716 | y = 0.5 * (-fullWidth + extWidth); |
| 2717 | z = 0.5 * (-fullLength + fgkmm * 10.0); |
| 2718 | } |
| 2719 | else { |
| 2720 | y = 0.5 * (fullWidth - extWidth); |
| 2721 | z = 0.5 * ( fullLength - fgkmm * 10.0); |
| 2722 | } |
| 2723 | x = 0.5 * (extThickness - fullThickness) + busThickness; |
| 2724 | //y = 0.5 * (fullWidth - extWidth); |
| 2725 | TGeoTranslation *trExt1 = new TGeoTranslation(x, y, z); |
| 2726 | if (isRight) { |
| 2727 | z -= 0.5 * (ext1Length - extThickness); |
| 2728 | } |
| 2729 | else { |
| 2730 | z += 0.5 * (ext1Length - extThickness); |
| 2731 | } |
| 2732 | x += 0.5*(extHeight - extThickness); |
| 2733 | TGeoTranslation *trExt2 = new TGeoTranslation(x, y, z); |
| 2734 | if (isRight) { |
| 2735 | z -= 0.5 * (ext2Length - extThickness); |
| 2736 | } |
| 2737 | else { |
| 2738 | z += 0.5 * (ext2Length - extThickness); |
| 2739 | } |
| 2740 | x += 0.5*(extHeight - extThickness) + extThickness; |
| 2741 | TGeoTranslation *trExt3 = new TGeoTranslation(x, y, z); |
| 2742 | container->AddNode(ext1, 0, trExt1); |
| 2743 | container->AddNode(ext2, 0, trExt2); |
| 2744 | container->AddNode(ext3, 0, trExt3); |
| d0048cec |
2745 | |
| 2746 | |
| 3ffa185f |
2747 | sizes[3] = yRef + pt1000Y; |
| 2748 | sizes[4] = zRef + pt1000Z[2]; |
| 2749 | sizes[5] = zRef + pt1000Z[7]; |
| d0048cec |
2750 | |
| 3ffa185f |
2751 | return container; |
| 7f69c251 |
2752 | } |
| 2753 | */ |
| 2754 | |
| 54c9a3d9 |
2755 | //______________________________________________________________________ |
| bc3498f4 |
2756 | TGeoVolumeAssembly* AliITSv11GeometrySPD::CreatePixelBus |
| 22726349 |
2757 | (Bool_t isRight, Int_t ilayer, TArrayD &sizes, TGeoManager *mgr) const |
| bc3498f4 |
2758 | { |
| 54c9a3d9 |
2759 | // |
| d0048cec |
2760 | // The pixel bus is implemented as a TGeoBBox with some objects on it, |
| 54c9a3d9 |
2761 | // which could affect the particle energy loss. |
| 2762 | // --- |
| d0048cec |
2763 | // In order to avoid confusion, the bus is directly displaced |
| 54c9a3d9 |
2764 | // according to the axis orientations which are used in the final stave: |
| 2765 | // X --> thickness direction |
| 2766 | // Y --> width direction |
| 2767 | // Z --> length direction |
| 2768 | // |
| d0048cec |
2769 | |
| 22726349 |
2770 | // ** CRITICAL CHECK ****************************************************** |
| 2771 | // layer number can be ONLY 1 or 2 |
| 2772 | if (ilayer != 1 && ilayer != 2) AliFatal("Layer number MUST be 1 or 2"); |
| 54c9a3d9 |
2773 | |
| 2774 | // ** MEDIA ** |
| 2775 | //PIXEL BUS |
| 2776 | TGeoMedium *medBus = GetMedium("SPDBUS(AL+KPT+EPOX)$",mgr); |
| 2777 | TGeoMedium *medPt1000 = GetMedium("CERAMICS$",mgr); // ??? PT1000 |
| 2778 | // Capacity |
| 2779 | TGeoMedium *medCap = GetMedium("SDD X7R capacitors$",mgr); |
| 2780 | // ??? Resistance |
| d0048cec |
2781 | //TGeoMedium *medRes = GetMedium("SDD X7R capacitors$",mgr); |
| 7f69c251 |
2782 | TGeoMedium *medRes = GetMedium("ALUMINUM$",mgr); |
| 3ffa185f |
2783 | TGeoMedium *medExt = GetMedium("SDDKAPTON (POLYCH2)$", mgr); |
| 54c9a3d9 |
2784 | // ** SIZES & POSITIONS ** |
| 2785 | Double_t busLength = 170.501 * fgkmm; // length of plane part |
| 2786 | Double_t busWidth = 13.800 * fgkmm; // width |
| 2787 | Double_t busThickness = 0.280 * fgkmm; // thickness |
| 2788 | Double_t pt1000Length = fgkmm * 1.50; |
| 2789 | Double_t pt1000Width = fgkmm * 3.10; |
| 2790 | Double_t pt1000Thickness = fgkmm * 0.60; |
| 2791 | Double_t pt1000Y, pt1000Z[10];// position of the pt1000's along the bus |
| 2792 | Double_t capLength = fgkmm * 2.55; |
| 2793 | Double_t capWidth = fgkmm * 1.50; |
| 2794 | Double_t capThickness = fgkmm * 1.35; |
| 2795 | Double_t capY[2], capZ[2]; |
| d0048cec |
2796 | |
| 54c9a3d9 |
2797 | Double_t resLength = fgkmm * 2.20; |
| 2798 | Double_t resWidth = fgkmm * 0.80; |
| 2799 | Double_t resThickness = fgkmm * 0.35; |
| 2800 | Double_t resY[2], resZ[2]; |
| d0048cec |
2801 | |
| 7f69c251 |
2802 | Double_t extThickness = fgkmm * 0.25; |
| 3ffa185f |
2803 | Double_t ext1Length = fgkmm * (26.7 - 10.0); |
| ddf00e3c |
2804 | Double_t ext2Length = fgkmm * 284.0 - ext1Length + extThickness; |
| 3ffa185f |
2805 | Double_t extWidth = fgkmm * 11.0; |
| 2806 | Double_t extHeight = fgkmm * 2.5; |
| d0048cec |
2807 | |
| 2808 | // position of pt1000, resistors and capacitors depends on the |
| 54c9a3d9 |
2809 | // bus if it's left or right one |
| 2810 | if (!isRight) { |
| 2811 | pt1000Y = 64400.; |
| 2812 | pt1000Z[0] = 66160.; |
| 2813 | pt1000Z[1] = 206200.; |
| 2814 | pt1000Z[2] = 346200.; |
| 2815 | pt1000Z[3] = 486200.; |
| 2816 | pt1000Z[4] = 626200.; |
| 2817 | pt1000Z[5] = 776200.; |
| 2818 | pt1000Z[6] = 916200.; |
| 2819 | pt1000Z[7] = 1056200.; |
| 2820 | pt1000Z[8] = 1196200.; |
| d0048cec |
2821 | pt1000Z[9] = 1336200.; |
| 54c9a3d9 |
2822 | resZ[0] = 1397500.; |
| 2823 | resY[0] = 26900.; |
| 2824 | resZ[1] = 682500.; |
| 2825 | resY[1] = 27800.; |
| 2826 | capZ[0] = 1395700.; |
| 2827 | capY[0] = 45700.; |
| 2828 | capZ[1] = 692600.; |
| 2829 | capY[1] = 45400.; |
| 2830 | } else { |
| 2831 | pt1000Y = 66100.; |
| 2832 | pt1000Z[0] = 319700.; |
| 2833 | pt1000Z[1] = 459700.; |
| 2834 | pt1000Z[2] = 599700.; |
| 2835 | pt1000Z[3] = 739700.; |
| 2836 | pt1000Z[4] = 879700.; |
| 2837 | pt1000Z[5] = 1029700.; |
| 2838 | pt1000Z[6] = 1169700.; |
| 2839 | pt1000Z[7] = 1309700.; |
| 2840 | pt1000Z[8] = 1449700.; |
| d0048cec |
2841 | pt1000Z[9] = 1589700.; |
| 54c9a3d9 |
2842 | capY[0] = 44500.; |
| 2843 | capZ[0] = 266700.; |
| 2844 | capY[1] = 44300.; |
| 2845 | capZ[1] = 974700.; |
| 2846 | resZ[0] = 266500.; |
| 2847 | resY[0] = 29200.; |
| 2848 | resZ[1] = 974600.; |
| 2849 | resY[1] = 29900.; |
| 2850 | } // end if isRight |
| 2851 | Int_t i; |
| 2852 | pt1000Y *= 1E-4 * fgkmm; |
| 2853 | for (i = 0; i < 10; i++) { |
| 2854 | pt1000Z[i] *= 1E-4 * fgkmm; |
| 2855 | if (i < 2) { |
| 2856 | capZ[i] *= 1E-4 * fgkmm; |
| 2857 | capY[i] *= 1E-4 * fgkmm; |
| 2858 | resZ[i] *= 1E-4 * fgkmm; |
| 2859 | resY[i] *= 1E-4 * fgkmm; |
| 2860 | } // end if iM2 |
| 2861 | } // end for i |
| d0048cec |
2862 | |
| 54c9a3d9 |
2863 | Double_t &fullLength = sizes[1]; |
| 2864 | Double_t &fullWidth = sizes[2]; |
| 2865 | Double_t &fullThickness = sizes[0]; |
| 2866 | fullLength = busLength; |
| 2867 | fullWidth = busWidth; |
| 2868 | // add the thickness of the thickest component on bus (capacity) |
| d0048cec |
2869 | fullThickness = busThickness + capThickness; |
| 54c9a3d9 |
2870 | |
| 2871 | // ** VOLUMES ** |
| 2872 | TGeoVolumeAssembly *container = new TGeoVolumeAssembly("ITSSPDpixelBus"); |
| d0048cec |
2873 | TGeoVolume *bus = mgr->MakeBox("ITSSPDbus", medBus, 0.5*busThickness, |
| 54c9a3d9 |
2874 | 0.5*busWidth, 0.5*busLength); |
| 2875 | TGeoVolume *pt1000 = mgr->MakeBox("ITSSPDpt1000",medPt1000, |
| 2876 | 0.5*pt1000Thickness,0.5*pt1000Width, 0.5*pt1000Length); |
| 2877 | TGeoVolume *res = mgr->MakeBox("ITSSPDresistor", medRes, 0.5*resThickness, |
| 2878 | 0.5*resWidth, 0.5*resLength); |
| 2879 | TGeoVolume *cap = mgr->MakeBox("ITSSPDcapacitor", medCap, 0.5*capThickness, |
| 2880 | 0.5*capWidth, 0.5*capLength); |
| d0048cec |
2881 | |
| 7f69c251 |
2882 | TGeoVolume *ext1 = mgr->MakeBox("Extender1", medExt, 0.5*extThickness, 0.5*extWidth, 0.5*ext1Length); |
| 3ffa185f |
2883 | TGeoVolume *ext2 = mgr->MakeBox("Extender2", medExt, 0.5*extHeight - 2.*extThickness, 0.5*extWidth, 0.5*extThickness); |
| 2884 | TGeoVolume *ext3 = mgr->MakeBox("Extender3", medExt, 0.5*extThickness, 0.5*(extWidth-0.8*fgkmm), 0.5*ext2Length + extThickness); // Hardcode fix of a small overlap |
| 54c9a3d9 |
2885 | bus->SetLineColor(kYellow + 2); |
| 2886 | pt1000->SetLineColor(kGreen + 3); |
| 2887 | res->SetLineColor(kRed + 1); |
| 2888 | cap->SetLineColor(kBlue - 7); |
| 7f69c251 |
2889 | ext1->SetLineColor(kGray); |
| 3ffa185f |
2890 | ext2->SetLineColor(kGray); |
| 2891 | ext3->SetLineColor(kGray); |
| 54c9a3d9 |
2892 | |
| 2893 | // ** MOVEMENTS AND POSITIONEMENT ** |
| 2894 | // bus |
| d0048cec |
2895 | TGeoTranslation *trBus = new TGeoTranslation(0.5 * (busThickness - |
| 54c9a3d9 |
2896 | fullThickness), 0.0, 0.0); |
| 2897 | container->AddNode(bus, 1, trBus); |
| 2898 | Double_t zRef, yRef, x, y, z; |
| 2899 | if (isRight) { |
| 2900 | zRef = -0.5*fullLength; |
| 2901 | yRef = -0.5*fullWidth; |
| 2902 | } else { |
| 2903 | zRef = -0.5*fullLength; |
| 2904 | yRef = -0.5*fullWidth; |
| 2905 | } // end if isRight |
| 2906 | // pt1000 |
| 2907 | x = 0.5*(pt1000Thickness - fullThickness) + busThickness; |
| 2908 | for (i = 0; i < 10; i++) { |
| 2909 | y = yRef + pt1000Y; |
| 2910 | z = zRef + pt1000Z[i]; |
| 2911 | TGeoTranslation *tr = new TGeoTranslation(x, y, z); |
| 2912 | container->AddNode(pt1000, i+1, tr); |
| 2913 | } // end for i |
| 2914 | // capacitors |
| 2915 | x = 0.5*(capThickness - fullThickness) + busThickness; |
| 2916 | for (i = 0; i < 2; i++) { |
| 2917 | y = yRef + capY[i]; |
| 2918 | z = zRef + capZ[i]; |
| 2919 | TGeoTranslation *tr = new TGeoTranslation(x, y, z); |
| 2920 | container->AddNode(cap, i+1, tr); |
| 2921 | } // end for i |
| 2922 | // resistors |
| 2923 | x = 0.5*(resThickness - fullThickness) + busThickness; |
| 2924 | for (i = 0; i < 2; i++) { |
| 2925 | y = yRef + resY[i]; |
| 2926 | z = zRef + resZ[i]; |
| 2927 | TGeoTranslation *tr = new TGeoTranslation(x, y, z); |
| 2928 | container->AddNode(res, i+1, tr); |
| 2929 | } // end for i |
| d0048cec |
2930 | |
| 7f69c251 |
2931 | // extender |
| 22726349 |
2932 | if (ilayer == 2) { |
| 3ffa185f |
2933 | if (isRight) { |
| 2934 | y = 0.5 * (fullWidth - extWidth) - 0.1; |
| 2935 | z = 0.5 * (-fullLength + fgkmm * 10.0); |
| 2936 | } |
| 2937 | else { |
| 2938 | y = 0.5 * (fullWidth - extWidth) - 0.1; |
| 2939 | z = 0.5 * ( fullLength - fgkmm * 10.0); |
| 2940 | } |
| 22726349 |
2941 | } |
| 2942 | else { |
| 2943 | if (isRight) { |
| 2944 | y = -0.5 * (fullWidth - extWidth); |
| 2945 | z = 0.5 * (-fullLength + fgkmm * 10.0); |
| 2946 | } |
| 2947 | else { |
| 2948 | y = -0.5 * (fullWidth - extWidth); |
| 2949 | z = 0.5 * ( fullLength - fgkmm * 10.0); |
| 2950 | } |
| 2951 | } |
| 3ffa185f |
2952 | x = 0.5 * (extThickness - fullThickness) + busThickness; |
| 2953 | //y = 0.5 * (fullWidth - extWidth); |
| 2954 | TGeoTranslation *trExt1 = new TGeoTranslation(x, y, z); |
| 2955 | if (isRight) { |
| 2956 | z -= 0.5 * (ext1Length - extThickness); |
| 2957 | } |
| 2958 | else { |
| 2959 | z += 0.5 * (ext1Length - extThickness); |
| 2960 | } |
| 2961 | x += 0.5*(extHeight - 3.*extThickness); |
| 2962 | TGeoTranslation *trExt2 = new TGeoTranslation(x, y, z); |
| 2963 | if (isRight) { |
| 2964 | z -= 0.5 * (ext2Length - extThickness) + 2.5*extThickness; |
| 2965 | } |
| 2966 | else { |
| 2967 | z += 0.5 * (ext2Length - extThickness) + 2.5*extThickness; |
| 2968 | } |
| 2969 | x += 0.5*(extHeight - extThickness) - 2.*extThickness; |
| 2970 | TGeoTranslation *trExt3 = new TGeoTranslation(x, y, z); |
| 2971 | container->AddNode(ext1, 0, trExt1); |
| 2972 | container->AddNode(ext2, 0, trExt2); |
| 2973 | container->AddNode(ext3, 0, trExt3); |
| d0048cec |
2974 | |
| 54c9a3d9 |
2975 | sizes[3] = yRef + pt1000Y; |
| 2976 | sizes[4] = zRef + pt1000Z[2]; |
| 2977 | sizes[5] = zRef + pt1000Z[7]; |
| d0048cec |
2978 | |
| 54c9a3d9 |
2979 | return container; |
| 592651e2 |
2980 | } |
| 7f69c251 |
2981 | |
| 2982 | //______________________________________________________________________ |
| 0b9c8a10 |
2983 | TList* AliITSv11GeometrySPD::CreateConeModule(TGeoManager *mgr) const |
| 7f69c251 |
2984 | { |
| 2985 | TGeoMedium *medInox = GetMedium("INOX$",mgr); |
| 3ffa185f |
2986 | TGeoMedium *medExt = GetMedium("SDDKAPTON (POLYCH2)$", mgr); |
| 2987 | TGeoMedium *medPlate = GetMedium("SPD C (M55J)$", mgr); |
| d0048cec |
2988 | |
| 3ffa185f |
2989 | Double_t extThickness = fgkmm * 0.25; |
| 2990 | Double_t ext1Length = fgkmm * (26.7 - 10.0); |
| 2991 | Double_t ext2Length = fgkmm * (285.0 - ext1Length + extThickness); |
| d0048cec |
2992 | |
| 7f69c251 |
2993 | Double_t cableThickness = 1.5 * fgkmm; |
| 2994 | Double_t cableL1 = 350.0 * fgkmm - extThickness - ext1Length - ext2Length; |
| b0d2bb60 |
2995 | Double_t cableL2 = 340.0 * fgkmm; |
| 7f69c251 |
2996 | //Double_t cableL3 = 570.0 * fgkmm; |
| 2997 | Double_t cableL3 = 57.0 * fgkmm; |
| 2998 | Double_t cableW1 = 11.0 * fgkmm; |
| 2999 | Double_t cableW2 = 30.0 * fgkmm; |
| 3000 | Double_t cableW3 = 50.0 * fgkmm; |
| d0048cec |
3001 | |
| 7f69c251 |
3002 | Double_t mcmThickness = 1.2 *fgkmm; |
| 3003 | Double_t mcmLength = cableL1 + cableL2 + cableL3; |
| 3004 | Double_t mcmWidth = cableW1; |
| d0048cec |
3005 | |
| 7f69c251 |
3006 | Double_t plateLength = 200.0 * fgkmm; |
| 3007 | Double_t plateWidth = 50.0 * fgkmm; |
| 3008 | Double_t plateThickness = 5.0 * fgkmm; |
| d0048cec |
3009 | |
| 7f69c251 |
3010 | Double_t x[12], y[12]; |
| d0048cec |
3011 | |
| 7f69c251 |
3012 | x[0] = 7.5; |
| 3013 | y[0] = 0.0 + 0.5 * cableW1; |
| d0048cec |
3014 | |
| 7f69c251 |
3015 | x[1] = x[0] + cableL1 - 0.5*(cableW2 - cableW1); |
| 3016 | y[1] = y[0]; |
| d0048cec |
3017 | |
| 3018 | x[2] = x[0] + cableL1; |
| 7f69c251 |
3019 | y[2] = y[1] + 0.5*(cableW2 - cableW1); |
| d0048cec |
3020 | |
| 7f69c251 |
3021 | x[3] = x[2] + cableL2; |
| 3022 | y[3] = y[2]; |
| d0048cec |
3023 | |
| 7f69c251 |
3024 | x[4] = x[3] + 0.5*(cableW3 - cableW2); |
| 3025 | y[4] = y[3] + 0.5*(cableW3 - cableW2); |
| d0048cec |
3026 | |
| 7f69c251 |
3027 | x[5] = x[4] + cableL3 - 0.5*(cableW3 - cableW2); |
| 3028 | y[5] = y[4]; |
| d0048cec |
3029 | |
| 7f69c251 |
3030 | for (Int_t i = 6; i < 12; i++) { |
| 3031 | x[i] = x[11 - i]; |
| 3032 | y[i] = -y[11 - i]; |
| 3033 | } |
| d0048cec |
3034 | |
| 0b9c8a10 |
3035 | TGeoVolumeAssembly* container[2]; |
| 3036 | container[0] = new TGeoVolumeAssembly("ITSSPDConeModule"); |
| 3037 | container[1] = new TGeoVolumeAssembly("ITSSPDCoolingModule"); |
| d0048cec |
3038 | |
| 7f69c251 |
3039 | TGeoXtru *shCable = new TGeoXtru(2); |
| 3040 | shCable->DefinePolygon(12, x, y); |
| 3041 | shCable->DefineSection(0, 0., 0., 0., 1.0); |
| 3042 | shCable->DefineSection(1, cableThickness, 0., 0., 1.0); |
| d0048cec |
3043 | |
| 7f69c251 |
3044 | TGeoVolume *volCable = new TGeoVolume("ITSSPDExtender", shCable, medExt); |
| 3045 | volCable->SetLineColor(kGreen); |
| d0048cec |
3046 | |
| 0df245e4 |
3047 | TGeoVolume *volTube = gGeoManager->MakeTube("ITSSPDCoolingTubeCone", medInox, 5.*fgkmm, 6.*fgkmm, 0.5*(x[5] - x[0])); |
| 7f69c251 |
3048 | volTube->SetLineColor(kGray); |
| d0048cec |
3049 | |
| 7f69c251 |
3050 | Double_t thickness = cableThickness + mcmThickness; |
| 3051 | TGeoBBox *shOut = new TGeoBBox("ITSSPD_shape_plateout", 0.5*plateThickness, 0.5*plateLength, 0.5*plateWidth); |
| 3052 | TGeoBBox *shIn = new TGeoBBox("ITSSPD_shape_platein", 0.5*thickness, 0.52*plateLength, 0.5*cableW2); |
| 3053 | Char_t string[255]; |
| 3054 | sprintf(string, "%s-%s", shOut->GetName(), shIn->GetName()); |
| 3055 | TGeoCompositeShape *shPlate = new TGeoCompositeShape("ITSSPDPlate_shape", string); |
| 3056 | TGeoVolume *volPlate = new TGeoVolume("ITSSPDPlate", shPlate, medPlate); |
| 3057 | volPlate->SetLineColor(kRed); |
| d0048cec |
3058 | |
| 7f69c251 |
3059 | TGeoVolume *volMCMExt = gGeoManager->MakeBox("ITSSPDextenderMCM", medExt, 0.5*mcmThickness, 0.5*mcmLength, 0.5*mcmWidth); |
| 3060 | volMCMExt->SetLineColor(kGreen+3); |
| d0048cec |
3061 | |
| 7f69c251 |
3062 | TGeoRotation *rot = new TGeoRotation(*gGeoIdentity); |
| 3063 | rot->RotateX(90.0); |
| 3064 | rot->RotateZ(90.0); |
| 0b9c8a10 |
3065 | container[0]->AddNode(volCable, 0, rot); |
| d0048cec |
3066 | |
| 7f69c251 |
3067 | TGeoTranslation *combi = new TGeoTranslation(cableThickness + 0.5*mcmThickness, x[0] + 0.5*mcmLength, 0.0); |
| 0b9c8a10 |
3068 | container[0]->AddNode(volMCMExt, 0, combi); |
| d0048cec |
3069 | |
| 7f69c251 |
3070 | TGeoRotation *rot1 = new TGeoRotation(*gGeoIdentity); |
| 93cd1f79 |
3071 | rot1->RotateX(87.5); |
| 0b9c8a10 |
3072 | TGeoCombiTrans *tr = new TGeoCombiTrans(1.15, x[0] + 0.5*(x[5] - x[0]), -2.95, rot1); |
| 3073 | container[1]->AddNode(volTube, 0, tr); |
| d0048cec |
3074 | |
| 7f69c251 |
3075 | TGeoTranslation *tr1 = new TGeoTranslation(0.5*plateThickness - 0.5*(plateThickness-thickness), x[3] - x[0] - 0.52*plateLength, 0.0); |
| 0b9c8a10 |
3076 | container[0]->AddNode(volPlate, 0, tr1); |
| d0048cec |
3077 | |
| 0b9c8a10 |
3078 | TList* conemodulelist = new TList(); |
| 3079 | |
| 3080 | conemodulelist->Add(container[0]); |
| 3081 | conemodulelist->Add(container[1]); |
| d0048cec |
3082 | |
| 0b9c8a10 |
3083 | return conemodulelist; |
| 7f69c251 |
3084 | } |
| 3085 | |
| 3086 | //______________________________________________________________________ |
| 3087 | void AliITSv11GeometrySPD::CreateCones(TGeoVolume *moth) const |
| 3088 | { |
| d0048cec |
3089 | |
| 0b9c8a10 |
3090 | TList* modulelist = CreateConeModule(gGeoManager); |
| 3091 | TGeoVolumeAssembly* module; |
| d0048cec |
3092 | |
| 7f69c251 |
3093 | //Double_t angle[10] = {18., 54., 90., 126., 162., -18., -54., -90., -126., -162.}; |
| 0b9c8a10 |
3094 | // angleNm for cone modules (cables), angleNc for cooling tubes |
| 3095 | Double_t angle1m[10] = {18., 54., 90., 129., 165., 201.0, 237.0, 273.0, 309.0, 345.0}; |
| 3096 | Double_t angle2m[10] = {18., 53., 90., 126., 162., 198.0, 233.0, 270.0, 309.0, 342.0}; |
| 3614667b |
3097 | Double_t angle1c[10] = {18., 54., 90., 124., 165., 201.0, 237.0, 273.0, 304.0, 345.0}; |
| 0b9c8a10 |
3098 | Double_t angle2c[10] = {18., 44., 90., 126., 162., 198.0, 223.0, 270.0, 309.0, 342.0}; |
| 3099 | |
| 3100 | // First add the cables |
| 3101 | module = (TGeoVolumeAssembly*)modulelist->At(0); |
| 7f69c251 |
3102 | for (Int_t i = 0; i < 10; i++) { |
| 3103 | TGeoRotation *rot1 = new TGeoRotation(*gGeoIdentity); |
| 3104 | rot1->RotateY(-90.0); |
| b0d2bb60 |
3105 | rot1->RotateX(45.0); |
| 0b9c8a10 |
3106 | angle1m[i] -= 1.5; |
| 3107 | rot1->RotateZ(90.0 - angle1m[i]); |
| ddf00e3c |
3108 | TGeoCombiTrans *tr1 = new TGeoCombiTrans(0.0, 0.0, 38.0, rot1); |
| 7f69c251 |
3109 | moth->AddNode(module, 2*i, tr1); |
| 3110 | TGeoRotation *rot2 = new TGeoRotation(*gGeoIdentity); |
| 3111 | rot2->RotateY(90.0); |
| b0d2bb60 |
3112 | rot2->RotateX(-45.0); |
| 0b9c8a10 |
3113 | angle2m[i] -= 1.5; |
| 3114 | rot2->RotateZ(90.0 - angle2m[i]); |
| ddf00e3c |
3115 | TGeoCombiTrans *tr2 = new TGeoCombiTrans(0.0, 0.0, -37.9, rot2); |
| 0b9c8a10 |
3116 | moth->AddNode(module, 2*i+1, tr2); |
| 3117 | } |
| 3118 | |
| 3119 | // Then the cooling tubes |
| 3120 | module = (TGeoVolumeAssembly*)modulelist->At(1); |
| 3121 | for (Int_t i = 0; i < 10; i++) { |
| 3122 | TGeoRotation *rot1 = new TGeoRotation(*gGeoIdentity); |
| 3123 | rot1->RotateY(-90.0); |
| b0d2bb60 |
3124 | rot1->RotateX(45.0); |
| 0b9c8a10 |
3125 | angle1c[i] -= 1.5; |
| 3126 | rot1->RotateZ(90.0 - angle1c[i]); |
| ddf00e3c |
3127 | TGeoCombiTrans *tr1 = new TGeoCombiTrans(0.0, 0.0, 38.0, rot1); |
| 0b9c8a10 |
3128 | moth->AddNode(module, 2*i, tr1); |
| 3129 | TGeoRotation *rot2 = new TGeoRotation(*gGeoIdentity); |
| 3130 | rot2->RotateY(90.0); |
| b0d2bb60 |
3131 | rot2->RotateX(-45.0); |
| 0b9c8a10 |
3132 | angle2c[i] -= 1.5; |
| 3133 | rot2->RotateZ(90.0 - angle2c[i]); |
| ddf00e3c |
3134 | TGeoCombiTrans *tr2 = new TGeoCombiTrans(0.0, 0.0, -37.9, rot2); |
| 7f69c251 |
3135 | moth->AddNode(module, 2*i+1, tr2); |
| 3136 | } |
| 3137 | } |
| 3138 | |
| 54c9a3d9 |
3139 | //______________________________________________________________________ |
| 3140 | TGeoVolume* AliITSv11GeometrySPD::CreateExtender( |
| 3141 | const Double_t *extenderParams, const TGeoMedium *extenderMedium, |
| 3142 | TArrayD& sizes) const |
| bc3498f4 |
3143 | { |
| 54c9a3d9 |
3144 | // |
| 3145 | // ------------------ CREATE AN EXTENDER ------------------------ |
| 3146 | // |
| 3147 | // This function creates the following picture (in plane xOy) |
| 3148 | // Should be useful for the definition of the pixel bus and MCM extenders |
| d0048cec |
3149 | // The origin corresponds to point 0 on the picture, at half-width |
| 3150 | // in Z direction |
| 54c9a3d9 |
3151 | // |
| 3152 | // Y 7 6 5 |
| 3153 | // ^ +---+---------------------+ |
| 3154 | // | / | |
| 3155 | // | / | |
| 3156 | // 0------> X / +---------------------+ |
| 3157 | // / / 3 4 |
| 3158 | // / / |
| 3159 | // 9 8 / / |
| 3160 | // +-----------+ / |
| 3161 | // | / |
| 3162 | // | / |
| 3163 | // ---> +-----------+---+ |
| 3164 | // | 0 1 2 |
| 3165 | // | |
| 3166 | // origin (0,0,0) |
| 3167 | // |
| 3168 | // |
| 3169 | // Takes 6 parameters in the following order : |
| 3170 | // |--> par 0 : inner length [0-1] / [9-8] |
| 3171 | // |--> par 1 : thickness ( = [0-9] / [4-5]) |
| 3172 | // |--> par 2 : angle of the slope |
| 3173 | // |--> par 3 : total height in local Y direction |
| 3174 | // |--> par 4 : outer length [3-4] / [6-5] |
| 3175 | // |--> par 5 : width in local Z direction |
| 3176 | // |
| d0048cec |
3177 | Double_t slopeDeltaX = (extenderParams[3] - extenderParams[1] |
| 3178 | * TMath::Cos(extenderParams[2])) / |
| 54c9a3d9 |
3179 | TMath::Tan(extenderParams[2]); |
| 3180 | Double_t extenderXtruX[10] = { |
| 3181 | 0 , |
| 3182 | extenderParams[0] , |
| d0048cec |
3183 | extenderParams[0]+extenderParams[1]*TMath::Sin(extenderParams[2]) , |
| 54c9a3d9 |
3184 | extenderParams[0]+extenderParams[1]*TMath::Sin(extenderParams[2])+ |
| 3185 | slopeDeltaX , |
| 3186 | extenderParams[0]+extenderParams[1]*TMath::Sin(extenderParams[2])+ |
| d0048cec |
3187 | slopeDeltaX + extenderParams[4], |
| 54c9a3d9 |
3188 | extenderParams[0]+extenderParams[1]*TMath::Sin(extenderParams[2])+ |
| d0048cec |
3189 | slopeDeltaX + extenderParams[4], |
| 54c9a3d9 |
3190 | extenderParams[0]+extenderParams[1]*TMath::Sin(extenderParams[2])+ |
| d0048cec |
3191 | slopeDeltaX , |
| 54c9a3d9 |
3192 | extenderParams[0]+extenderParams[1]*TMath::Sin(extenderParams[2])+ |
| 3193 | slopeDeltaX - extenderParams[1] * TMath::Sin(extenderParams[2]) , |
| 3194 | extenderParams[0] , |
| 3195 | 0 |
| 3196 | }; |
| 3197 | Double_t extenderXtruY[10] = { |
| 3198 | 0 , |
| 3199 | 0 , |
| 3200 | extenderParams[1] * (1-TMath::Cos(extenderParams[2])) , |
| 3201 | extenderParams[3] - extenderParams[1] , |
| 3202 | extenderParams[3] - extenderParams[1] , |
| 3203 | extenderParams[3] , |
| 3204 | extenderParams[3] , |
| 3205 | extenderParams[3]-extenderParams[1]*(1-TMath::Cos(extenderParams[2])) , |
| 3206 | extenderParams[1] , |
| 3207 | extenderParams[1] |
| 3208 | }; |
| 592651e2 |
3209 | |
| 54c9a3d9 |
3210 | if (sizes.GetSize() != 3) sizes.Set(3); |
| 3211 | Double_t &thickness = sizes[0]; |
| 3212 | Double_t &length = sizes[1]; |
| 3213 | Double_t &width = sizes[2]; |
| 3214 | |
| 3215 | thickness = extenderParams[3]; |
| 3216 | width = extenderParams[5]; |
| 3217 | length = extenderParams[0]+extenderParams[1]* |
| 3218 | TMath::Sin(extenderParams[2])+slopeDeltaX+extenderParams[4]; |
| 3219 | |
| 3220 | // creation of the volume |
| 3221 | TGeoXtru *extenderXtru = new TGeoXtru(2); |
| 3222 | TGeoVolume *extenderXtruVol = new TGeoVolume("ITSSPDextender",extenderXtru, |
| 3223 | extenderMedium); |
| 3224 | extenderXtru->DefinePolygon(10,extenderXtruX,extenderXtruY); |
| 3225 | extenderXtru->DefineSection(0,-0.5*extenderParams[4]); |
| 3226 | extenderXtru->DefineSection(1, 0.5*extenderParams[4]); |
| 3227 | return extenderXtruVol; |
| 3228 | } |
| bc3498f4 |
3229 | //______________________________________________________________________ |
| 3230 | TGeoVolumeAssembly* AliITSv11GeometrySPD::CreatePixelBusAndExtensions |
| 3231 | (Bool_t /*zpos*/, TGeoManager *mgr) const |
| 3232 | { |
| 54c9a3d9 |
3233 | // |
| 3234 | // Creates an assembly which contains the pixel bus and its extension |
| 3235 | // and the extension of the MCM. |
| 3236 | // By: Renaud Vernet |
| d0048cec |
3237 | // NOTE: to be defined its material and its extension in the outside |
| 54c9a3d9 |
3238 | // direction |
| 3239 | // |
| 3240 | // ==== constants ===== |
| 3241 | //get the media |
| 3242 | // PIXEL BUS |
| 3243 | //TGeoMedium *medPixelBus = GetMedium("SPDBUS(AL+KPT+EPOX)$",mgr); |
| 3244 | // IXEL BUS EXTENDER |
| 3245 | TGeoMedium *medPBExtender = GetMedium("SDDKAPTON (POLYCH2)$",mgr); |
| 3246 | //MCM EXTENDER |
| 3247 | TGeoMedium *medMCMExtender = GetMedium("SDDKAPTON (POLYCH2)$",mgr); |
| 3248 | // //geometrical constants |
| 3249 | const Double_t kPbextenderThickness = 0.07 * fgkmm; |
| 3250 | //design=?? 70 deg. seems OK |
| 3251 | const Double_t kPbExtenderSlopeAngle = 70.0 * TMath::Pi()/180.; |
| 3252 | // = 2.6 - (0.28+0.05+0.35) cf design |
| 3253 | const Double_t kPbExtenderHeight = 1.92 * fgkmm; |
| 3254 | const Double_t kPbExtenderWidthY = 11.0 * fgkmm; |
| 3255 | //design=?? 70 deg. seems OK |
| 3256 | const Double_t kMcmExtenderSlopeAngle = 70.0 * TMath::Pi()/180.; |
| 3257 | const Double_t kMcmExtenderThickness = 0.10 * fgkmm; |
| 3258 | const Double_t kMcmExtenderHeight = 1.8 * fgkmm; |
| 3259 | const Double_t kMcmExtenderWidthY = kPbExtenderWidthY; |
| 3260 | // const Double_t groundingThickness = 0.07 * fgkmm; |
| 3261 | // const Double_t grounding2pixelBusDz = 0.625 * fgkmm; |
| 3262 | // const Double_t pixelBusThickness = 0.28 * fgkmm; |
| 3263 | // const Double_t groundingWidthX = 170.501 * fgkmm; |
| 3264 | // const Double_t pixelBusContactDx = 1.099 * fgkmm; |
| 3265 | // const Double_t pixelBusWidthY = 13.8 * fgkmm; |
| 3266 | //design=20 deg. |
| 3267 | // const Double_t pixelBusContactPhi = 20.0 * TMath::Pi()/180. |
| 3268 | // const Double_t pbExtenderTopZ = 2.72 * fgkmm; |
| 3269 | // const Double_t mcmThickness = 0.35 * fgkmm; |
| 3270 | // const Double_t halfStaveTotalLength = 247.64 * fgkmm; |
| 3271 | // const Double_t deltaYOrigin = 15.95/2.* fgkmm; |
| 3272 | // const Double_t deltaXOrigin = 1.1 * fgkmm; |
| 3273 | // const Double_t deltaZOrigin = halfStaveTotalLength / 2.; |
| 3274 | // const Double_t grounding2pixelBusDz2 = grounding2pixelBusDz+ |
| 3275 | // groundingThickness/2. + pixelBusThickness/2.; |
| 3276 | // const Double_t pixelBusWidthX = groundingWidthX; |
| 3277 | // const Double_t pixelBusRaiseLength = (pixelBusContactDx- |
| 3278 | // pixelBusThickness*TMath::Sin(pixelBusContactPhi))/ |
| 3279 | // TMath::Cos(pixelBusContactPhi); |
| 3280 | // const Double_t pbExtenderBaseZ = grounding2pixelBusDz2 + |
| 3281 | // pixelBusRaiseLength*TMath::Sin(pixelBusContactPhi) + |
| 3282 | // 2*pixelBusThickness*TMath::Sin(pixelBusContactPhi)* |
| 3283 | // TMath::Tan(pixelBusContactPhi); |
| 3284 | // const Double_t pbExtenderDeltaZ = pbExtenderTopZ-pbExtenderBaseZ; |
| d0048cec |
3285 | // const Double_t pbExtenderEndPointX = 2*deltaZOrigin - |
| 54c9a3d9 |
3286 | // groundingWidthX - 2*pixelBusThickness*TMath::Sin(pixelBusContactPhi); |
| 3287 | // const Double_t pbExtenderXtru3L = 1.5 * fgkmm; //arbitrary ? |
| d0048cec |
3288 | // const Double_t pbExtenderXtru4L = (pbExtenderDeltaZ + |
| 54c9a3d9 |
3289 | // pixelBusThickness*(TMath::Cos(extenderSlope)-2))/ |
| 3290 | // TMath::Sin(extenderSlope); |
| 3291 | // const Double_t kMcmExtenderEndPointX = deltaZOrigin - 48.2 * fgkmm; |
| 3292 | // const Double_t kMcmExtenderXtru3L = 1.5 * fgkmm; |
| 3293 | // //===== end constants ===== |
| 3294 | const Double_t kPbExtenderInnerLength = 10. * fgkmm; |
| 3295 | const Double_t kPbExtenderOuterLength = 15. * fgkmm; |
| 3296 | const Double_t kMcmExtenderInnerLength = 10. * fgkmm; |
| 3297 | const Double_t kMcmExtenderOuterLength = 15. * fgkmm; |
| 3298 | Double_t pbExtenderParams[6] = {kPbExtenderInnerLength, //0 |
| 3299 | kPbextenderThickness, //1 |
| 3300 | kPbExtenderSlopeAngle, //2 |
| 3301 | kPbExtenderHeight, //3 |
| 3302 | kPbExtenderOuterLength, //4 |
| 3303 | kPbExtenderWidthY}; //5 |
| d0048cec |
3304 | |
| 54c9a3d9 |
3305 | Double_t mcmExtenderParams[6] = {kMcmExtenderInnerLength, //0 |
| 3306 | kMcmExtenderThickness, //1 |
| 3307 | kMcmExtenderSlopeAngle, //2 |
| 3308 | kMcmExtenderHeight, //3 |
| 3309 | kMcmExtenderOuterLength, //4 |
| 3310 | kMcmExtenderWidthY}; //5 |
| d0048cec |
3311 | |
| 54c9a3d9 |
3312 | TArrayD sizes(3); |
| 3313 | TGeoVolume* pbExtender = CreateExtender(pbExtenderParams,medPBExtender, |
| 3314 | sizes); |
| 3315 | if(GetDebug(1))printf("CREATED AN EXTENDER : THICKNESS = %5.5f cm\t" |
| 3316 | "LENGTH=%5.5f cm\tWIDTH=%5.5f cm\n",sizes[0],sizes[1],sizes[2]); |
| 3317 | TGeoVolume* mcmExtender = CreateExtender(mcmExtenderParams,medMCMExtender, |
| 3318 | sizes); |
| 3319 | if(GetDebug(1))printf("CREATED AN EXTENDER : THICKNESS = %5.5f cm\t" |
| 3320 | "LENGTH=%5.5f cm\tWIDTH=%5.5f cm\n",sizes[0],sizes[1],sizes[2]); |
| 3321 | // Double_t pixelBusValues[5] = {pixelBusWidthX, //0 |
| 3322 | // pixelBusThickness, //1 |
| 3323 | // pixelBusContactPhi, //2 |
| 3324 | // pixelBusRaiseLength, //3 |
| 3325 | // pixelBusWidthY}; //4 |
| d0048cec |
3326 | |
| 54c9a3d9 |
3327 | // Double_t pbExtenderValues[8] = {pixelBusRaiseLength, //0 |
| 3328 | // pixelBusContactPhi, //1 |
| 3329 | // pbExtenderXtru3L, //2 |
| 3330 | // pixelBusThickness, //3 |
| 3331 | // extenderSlope, //4 |
| 3332 | // pbExtenderXtru4L, //5 |
| 3333 | // pbExtenderEndPointX, //6 |
| 3334 | // kPbExtenderWidthY}; //7 |
| d0048cec |
3335 | |
| 54c9a3d9 |
3336 | // Double_t mcmExtenderValues[6] = {mcmExtenderXtru3L, //0 |
| 3337 | // mcmExtenderThickness, //1 |
| 3338 | // extenderSlope, //2 |
| 3339 | // deltaMcmMcmExtender, //3 |
| 3340 | // mcmExtenderEndPointX, //4 |
| 3341 | // mcmExtenderWidthY}; //5 |
| 3342 | // TGeoVolumeAssembly *pixelBus=new TGeoVolumeAssembly("ITSSPDpixelBus"); |
| d0048cec |
3343 | // CreatePixelBus(pixelBus,pixelBusValues,medPixelBus); |
| 54c9a3d9 |
3344 | // TGeoVolumeAssembly *pbExtender = new TGeoVolumeAssembly( |
| 3345 | // "ITSSPDpixelBusExtender"); |
| 3346 | // CreatePixelBusExtender(pbExtender,pbExtenderValues,medPBExtender); |
| 3347 | // TGeoVolumeAssembly *mcmExtender = new TGeoVolumeAssembly( |
| 3348 | // "ITSSPDmcmExtender"); |
| 3349 | // CreateMCMExtender(mcmExtender,mcmExtenderValues,medMCMExtender); |
| 3350 | //-------------- DEFINITION OF GEOMETRICAL TRANSFORMATIONS -------- |
| 3351 | // TGeoRotation * commonRot = new TGeoRotation("commonRot",0,90,0); |
| 3352 | // commonRot->MultiplyBy(new TGeoRotation("rot",-90,0,0)); |
| 3353 | // TGeoTranslation * pixelBusTrans = new TGeoTranslation( |
| 3354 | // pixelBusThickness/2. - deltaXOrigin + 0.52*fgkmm , |
| d0048cec |
3355 | // -pixelBusWidthY/2. + deltaYOrigin , |
| 54c9a3d9 |
3356 | // -groundingWidthX/2. + deltaZOrigin); |
| 3357 | // TGeoRotation *pixelBusRot = new TGeoRotation(*commonRot); |
| 3358 | // TGeoTranslation *pbExtenderTrans =new TGeoTranslation(*pixelBusTrans); |
| 3359 | // TGeoRotation *pbExtenderRot = new TGeoRotation(*pixelBusRot); |
| 3360 | // pbExtenderTrans->SetDz(*(pbExtenderTrans->GetTranslation()+2) - |
| 3361 | // pixelBusWidthX/2. - 2*pixelBusThickness* |
| d0048cec |
3362 | // TMath::Sin(pixelBusContactPhi)); |
| 54c9a3d9 |
3363 | // if (!zpos) { |
| 3364 | // pbExtenderTrans->SetDy(*(pbExtenderTrans->GetTranslation()+1) - |
| 3365 | // (pixelBusWidthY - kPbExtenderWidthY)/2.); |
| 3366 | // } else { |
| 3367 | // pbExtenderTrans->SetDy(*(pbExtenderTrans->GetTranslation()+1) + |
| 3368 | // (pixelBusWidthY - kPbExtenderWidthY)/2.); |
| 3369 | // } |
| 3370 | // pbExtenderTrans->SetDx(*(pbExtenderTrans->GetTranslation()) + |
| 3371 | // pixelBusThickness/2 + 2*pixelBusThickness* |
| 3372 | // TMath::Sin(pixelBusContactPhi)* |
| 3373 | // TMath::Tan(pixelBusContactPhi)); |
| 3374 | // TGeoTranslation * mcmExtenderTrans = new TGeoTranslation(0.12*fgkmm + |
| 3375 | // mcmThickness - deltaXOrigin, |
| 3376 | // pbExtenderTrans->GetTranslation()[1], |
| 3377 | // -4.82); |
| 3378 | // TGeoRotation * mcmExtenderRot = new TGeoRotation(*pbExtenderRot); |
| 3379 | // // add pt1000 components |
| 3380 | // Double_t pt1000Z = fgkmm * 64400. * 1E-4; |
| d0048cec |
3381 | // //Double_t pt1000X[10] = {319700., 459700., 599700., 739700., |
| 54c9a3d9 |
3382 | // 879700., 1029700., 1169700., 1309700., |
| 3383 | // 1449700., 1589700.}; |
| 3384 | // Double_t pt1000X[10] ={66160., 206200., 346200., 486200., 626200., |
| 3385 | // 776200., 916200., 1056200., 1196200., 1336200.}; |
| 3386 | // Double_t pt1000size[3] = {fgkmm*1.5, fgkmm*0.6, fgkmm*3.1}; |
| 3387 | // Int_t i; |
| 3388 | // for (i = 0; i < 10; i++) { |
| 3389 | // pt1000X[i] *= fgkmm * 1E-4; |
| 3390 | // } |
| 3391 | // TGeoVolume *pt1000 = mgr->MakeBox("ITSSPDpt1000",0,0.5*pt1000size[0], |
| 3392 | // 0.5*pt1000size[1], 0.5*pt1000size[2]); |
| 3393 | // pt1000->SetLineColor(kGray); |
| 3394 | // Double_t refThickness = - pixelBusThickness; |
| 3395 | // for (i = 0; i < 10; i++) { |
| 3396 | // TGeoTranslation *tr = new TGeoTranslation(pt1000X[i]- |
| 3397 | // 0.5*pixelBusWidthX, 0.002+0.5*(-3.*refThickness+pt1000size[3]), |
| 3398 | // pt1000Z -0.5*pixelBusWidthY); |
| 3399 | // pixelBus->AddNode(pt1000, i+1, tr); |
| 3400 | // } |
| d0048cec |
3401 | |
| 54c9a3d9 |
3402 | //CREATE FINAL VOLUME ASSEMBLY AND ROTATE IT |
| 3403 | TGeoVolumeAssembly *assembly = new TGeoVolumeAssembly("ITSSPDextenders"); |
| 3404 | // assembly->AddNode((TGeoVolume*)pixelBus,1, |
| 3405 | // new TGeoCombiTrans(*pixelBusTrans,*pixelBusRot)); |
| 3406 | // assembly->AddNode((TGeoVolume*)pbExtender,1, |
| 3407 | // new TGeoCombiTrans(*pbExtenderTrans,*pbExtenderRot)); |
| 3408 | // assembly->AddNode((TGeoVolume*)mcmExtender,1, |
| 3409 | // new TGeoCombiTrans(*mcmExtenderTrans,*mcmExtenderRot)); |
| 3410 | // assembly->AddNode(mcmExtender,1,new TGeoIdentity()); |
| 3411 | assembly->AddNode(pbExtender,1); |
| 3412 | assembly->AddNode(mcmExtender,1); |
| 3413 | // assembly->SetTransparency(50); |
| d0048cec |
3414 | |
| 54c9a3d9 |
3415 | return assembly; |
| 592651e2 |
3416 | } |
| 54c9a3d9 |
3417 | //______________________________________________________________________ |
| 3418 | TGeoVolumeAssembly* AliITSv11GeometrySPD::CreateHalfStave(Bool_t isRight, |
| 3419 | Int_t layer,Int_t idxCentral,Int_t idxSide,TArrayD &sizes,TGeoManager *mgr) |
| bc3498f4 |
3420 | { |
| 54c9a3d9 |
3421 | // |
| d0048cec |
3422 | // Implementation of an half-stave, which depends on the side where |
| 3423 | // we are on the stave. The convention for "left" and "right" is the |
| 3424 | // same as for the MCM. The return value is a TGeoAssembly which is |
| 3425 | // structured in such a way that the origin of its local reference |
| 54c9a3d9 |
3426 | // frame coincides with the origin of the whole stave. |
| 3427 | // The TArrayD passed by reference will contain details of the shape: |
| 3428 | // - sizes[0] = thickness |
| 3429 | // - sizes[1] = length |
| 3430 | // - sizes[2] = width |
| 3431 | // - sizes[3] = common 'x' position for eventual clips |
| 3432 | // - sizes[4] = common 'y' position for eventual clips |
| 3433 | // - sizes[5] = 'z' position of first clip |
| 3434 | // - sizes[6] = 'z' position of second clip |
| 3435 | // |
| 3436 | |
| 3437 | // ** CHECK ** |
| 3438 | |
| 3439 | // idxCentral and idxSide must be different |
| 3440 | if (idxCentral == idxSide) { |
| 3441 | AliInfo("Ladders must be inserted in half-stave with " |
| 3442 | "different indexes."); |
| 3443 | idxSide = idxCentral + 1; |
| 3444 | AliInfo(Form("Central ladder will be inserted with index %d", |
| 3445 | idxCentral)); |
| 3446 | AliInfo(Form("Side ladder will be inserted with index %d",idxSide)); |
| 3447 | } // end if |
| 3448 | |
| 3449 | // define the separations along Z direction between the objects |
| 3450 | Double_t sepLadderLadder = fgkmm * 0.2; // sep. btw the 2 ladders |
| d0048cec |
3451 | Double_t sepLadderCenter = fgkmm * 0.4; // sep. btw the "central" ladder |
| 54c9a3d9 |
3452 | // and the Z=0 plane in stave ref. |
| 3453 | Double_t sepLadderMCM = fgkmm * 0.3; // sep. btw the "external" ladder |
| 3454 | // and MCM |
| d0048cec |
3455 | Double_t sepBusCenter = fgkmm * 0.3; // sep. btw the bus central edge |
| 54c9a3d9 |
3456 | // and the Z=0 plane in stave ref. |
| 3457 | |
| 3458 | // ** VOLUMES ** |
| 3459 | |
| 3460 | // grounding foil |
| 3461 | TArrayD grndSize(3); |
| 3462 | // This one line repalces the 3 bellow, BNS. |
| 3463 | TGeoVolume *grndVol = CreateGroundingFoil(isRight, grndSize, mgr); |
| 3464 | Double_t &grndThickness = grndSize[0]; |
| 3465 | Double_t &grndLength = grndSize[1]; |
| 3466 | |
| 3467 | // ladder |
| 3468 | TArrayD ladderSize(3); |
| 3469 | TGeoVolume *ladder = CreateLadder(layer, ladderSize, mgr); |
| 3470 | Double_t ladderThickness = ladderSize[0]; |
| 3471 | Double_t ladderLength = ladderSize[1]; |
| 3472 | Double_t ladderWidth = ladderSize[2]; |
| 3473 | |
| 3474 | // MCM |
| 3475 | TArrayD mcmSize(3); |
| 3476 | TGeoVolumeAssembly *mcm = CreateMCM(!isRight,mcmSize,mgr); |
| 3477 | Double_t mcmThickness = mcmSize[0]; |
| 3478 | Double_t mcmLength = mcmSize[1]; |
| 3479 | Double_t mcmWidth = mcmSize[2]; |
| d0048cec |
3480 | |
| 54c9a3d9 |
3481 | // bus |
| 3482 | TArrayD busSize(6); |
| 22726349 |
3483 | TGeoVolumeAssembly *bus = CreatePixelBus(isRight, layer, busSize, mgr); |
| 54c9a3d9 |
3484 | Double_t busThickness = busSize[0]; |
| 3485 | Double_t busLength = busSize[1]; |
| 3486 | Double_t busWidth = busSize[2]; |
| 3487 | |
| 3488 | // glue between ladders and pixel bus |
| 3489 | TGeoMedium *medLadGlue = GetMedium("EPOXY$", mgr); |
| 3490 | Double_t ladGlueThickness = fgkmm * 0.1175 - fgkGapLadder; |
| 3491 | TGeoVolume *ladderGlue = mgr->MakeBox("ITSSPDladderGlue",medLadGlue, |
| 3492 | 0.5*ladGlueThickness, 0.5*busWidth, 0.5*busLength); |
| 3493 | ladderGlue->SetLineColor(kYellow + 5); |
| 3494 | |
| 3495 | // create references for the whole object, as usual |
| 3496 | sizes.Set(7); |
| 3497 | Double_t &fullThickness = sizes[0]; |
| 3498 | Double_t &fullLength = sizes[1]; |
| 3499 | Double_t &fullWidth = sizes[2]; |
| d0048cec |
3500 | |
| 54c9a3d9 |
3501 | // compute the full size of the container |
| 3502 | fullLength = sepLadderCenter+2.0*ladderLength+sepLadderMCM+ |
| 3503 | sepLadderLadder+mcmLength; |
| 3504 | fullWidth = ladderWidth; |
| 3505 | fullThickness = grndThickness + fgkGapLadder + mcmThickness + busThickness; |
| ed0e944d |
3506 | //cout << "HSTAVE FULL THICKNESS = " << fullThickness << endl; |
| 54c9a3d9 |
3507 | |
| 3508 | // ** MOVEMENTS ** |
| 3509 | |
| 3510 | // grounding foil (shifted only along thickness) |
| 3511 | Double_t xGrnd = -0.5*fullThickness + 0.5*grndThickness; |
| 3512 | Double_t zGrnd = -0.5*grndLength; |
| 3513 | if (!isRight) zGrnd = -zGrnd; |
| 3514 | TGeoTranslation *grndTrans = new TGeoTranslation(xGrnd, 0.0, zGrnd); |
| 3515 | |
| 3516 | // ladders (translations along thickness and length) |
| d0048cec |
3517 | // layers must be sorted going from the one at largest Z to the |
| 54c9a3d9 |
3518 | // one at smallest Z: |
| 3519 | // -|Zmax| ------> |Zmax| |
| 3520 | // 3 2 1 0 |
| d0048cec |
3521 | // then, for layer 1 ladders they must be placed exactly this way, |
| 3522 | // and in layer 2 at the opposite. In order to remember the placements, |
| 3523 | // we define as "inner" and "outer" ladder respectively the one close |
| 54c9a3d9 |
3524 | // to barrel center, and the one closer to MCM, respectively. |
| 3525 | Double_t xLad, zLadIn, zLadOut; |
| 3526 | xLad = xGrnd + 0.5*(grndThickness + ladderThickness) + |
| 3527 | 0.01175 - fgkGapLadder; |
| 3528 | zLadIn = -sepLadderCenter - 0.5*ladderLength; |
| 3529 | zLadOut = zLadIn - sepLadderLadder - ladderLength; |
| 3530 | if (!isRight) { |
| 3531 | zLadIn = -zLadIn; |
| 3532 | zLadOut = -zLadOut; |
| 3533 | } // end if !isRight |
| 3534 | TGeoRotation *rotLad = new TGeoRotation(*gGeoIdentity); |
| 3535 | rotLad->RotateZ(90.0); |
| 3536 | rotLad->RotateY(180.0); |
| 3537 | Double_t sensWidth = fgkmm * 12.800; |
| 3538 | Double_t chipWidth = fgkmm * 15.950; |
| 3539 | Double_t guardRingWidth = fgkmm * 0.560; |
| 3540 | Double_t ladderShift = 0.5 * (chipWidth - sensWidth - 2.0*guardRingWidth); |
| 3541 | TGeoCombiTrans *trLadIn = new TGeoCombiTrans(xLad,ladderShift,zLadIn, |
| 3542 | rotLad); |
| 3543 | TGeoCombiTrans *trLadOut = new TGeoCombiTrans(xLad,ladderShift,zLadOut, |
| 3544 | rotLad); |
| 3545 | |
| d0048cec |
3546 | // MCM (length and thickness direction, placing at same level as the |
| 3547 | // ladder, which implies to recompute the position of center, because |
| 3548 | // ladder and MCM have NOT the same thickness) the two copies of the |
| 54c9a3d9 |
3549 | // MCM are placed at the same distance from the center, on both sides |
| d0048cec |
3550 | Double_t xMCM = xGrnd + 0.5*grndThickness + 0.5*mcmThickness + |
| 54c9a3d9 |
3551 | 0.01175 - fgkGapLadder; |
| 3552 | Double_t yMCM = 0.5*(fullWidth - mcmWidth); |
| 3553 | Double_t zMCM = zLadOut - 0.5*ladderLength - 0.5*mcmLength - sepLadderMCM; |
| d0048cec |
3554 | if (!isRight) zMCM = zLadOut + 0.5*ladderLength + 0.5*mcmLength + |
| 54c9a3d9 |
3555 | sepLadderMCM; |
| 3556 | |
| 3557 | // create the correction rotations |
| 3558 | TGeoRotation *rotMCM = new TGeoRotation(*gGeoIdentity); |
| 3559 | rotMCM->RotateY(90.0); |
| 3560 | TGeoCombiTrans *trMCM = new TGeoCombiTrans(xMCM, yMCM, zMCM, rotMCM); |
| 3561 | |
| 3562 | // glue between ladders and pixel bus |
| d0048cec |
3563 | Double_t xLadGlue = xLad + 0.5*ladderThickness + 0.01175 - |
| 54c9a3d9 |
3564 | fgkGapLadder + 0.5*ladGlueThickness; |
| 3565 | |
| 3566 | // bus (length and thickness direction) |
| 3567 | Double_t xBus = xLadGlue + 0.5*ladGlueThickness + 0.5*busThickness; |
| 7708d5f3 |
3568 | Double_t yBus = 0.5*(fullWidth - busWidth) + 0.075; // Hardcode fix of a small overlap |
| 54c9a3d9 |
3569 | Double_t zBus = -0.5*busLength - sepBusCenter; |
| 3570 | if (!isRight) zBus = -zBus; |
| 3571 | TGeoTranslation *trBus = new TGeoTranslation(xBus, yBus, zBus); |
| 3572 | |
| 3573 | TGeoTranslation *trLadGlue = new TGeoTranslation(xLadGlue, 0.0, zBus); |
| 3574 | |
| 3575 | // create the container |
| 3576 | TGeoVolumeAssembly *container = 0; |
| 3577 | if (idxCentral+idxSide==5) { |
| 3578 | container = new TGeoVolumeAssembly("ITSSPDhalf-Stave1"); |
| 3579 | } else { |
| 3580 | container = new TGeoVolumeAssembly("ITSSPDhalf-Stave0"); |
| 3581 | } // end if |
| 3582 | |
| 3583 | // add to container all objects |
| 3584 | container->AddNode(grndVol, 1, grndTrans); |
| 3585 | // ladders are inserted in different order to respect numbering scheme |
| 3586 | // which is inverted when going from outer to inner layer |
| 3587 | container->AddNode(ladder, idxCentral+1, trLadIn); |
| 3588 | container->AddNode(ladder, idxSide+1, trLadOut); |
| 3589 | container->AddNode(ladderGlue, 1, trLadGlue); |
| 3590 | container->AddNode(mcm, 1, trMCM); |
| 3591 | container->AddNode(bus, 1, trBus); |
| 3592 | |
| 3593 | // since the clips are placed in correspondence of two pt1000s, |
| 3594 | // their position is computed here, but they are not added by default |
| 3595 | // it will be the StavesInSector method which will decide to add them |
| 3596 | // anyway, to recovery some size informations on the clip, it must be |
| 3597 | // created |
| 3598 | TArrayD clipSize; |
| 3ffa185f |
3599 | // TGeoVolume *clipDummy = CreateClip(clipSize, kTRUE, mgr); |
| 54c9a3d9 |
3600 | CreateClip(clipSize, kTRUE, mgr); |
| 3601 | // define clip movements (width direction) |
| 3602 | sizes[3] = xBus + 0.5*busThickness; |
| 3603 | sizes[4] = 0.5 * (fullWidth - busWidth) - clipSize[6] - fgkmm*0.48; |
| 3604 | sizes[5] = zBus + busSize[4]; |
| 3605 | sizes[6] = zBus + busSize[5]; |
| 3606 | |
| 3607 | return container; |
| 592651e2 |
3608 | } |
| 54c9a3d9 |
3609 | //______________________________________________________________________ |
| 3610 | TGeoVolumeAssembly* AliITSv11GeometrySPD::CreateStave(Int_t layer, |
| 3611 | TArrayD &sizes, TGeoManager *mgr) |
| 7855ea93 |
3612 | { |
| 54c9a3d9 |
3613 | // |
| 3614 | // This method uses all other ones which create pieces of the stave |
| 3615 | // and assemblies everything together, in order to return the whole |
| 3616 | // stave implementation, which is returned as a TGeoVolumeAssembly, |
| 3617 | // due to the presence of some parts which could generate fake overlaps |
| 3618 | // when put on the sector. |
| 3619 | // This assembly contains, going from bottom to top in the thickness |
| 3620 | // direction: |
| d0048cec |
3621 | // - the complete grounding foil, defined by the "CreateGroundingFoil" |
| 3622 | // method which already joins some glue and real groudning foil |
| 54c9a3d9 |
3623 | // layers for the whole stave (left + right); |
| d0048cec |
3624 | // - 4 ladders, which are sorted according to the ALICE numbering |
| 54c9a3d9 |
3625 | // scheme, which depends on the layer we are building this stave for; |
| 3626 | // - 2 MCMs (a left and a right one); |
| 3627 | // - 2 pixel buses (a left and a right one); |
| 3628 | // --- |
| 3629 | // Arguments: |
| d0048cec |
3630 | // - the layer number, which determines the displacement and naming |
| 54c9a3d9 |
3631 | // of sensitive volumes |
| d0048cec |
3632 | // - a TArrayD passed by reference which will contain the size |
| 54c9a3d9 |
3633 | // of virtual box containing the stave |
| 3634 | // - the TGeoManager |
| 3635 | // |
| 3636 | |
| 3637 | // create the container |
| 3638 | TGeoVolumeAssembly *container = new TGeoVolumeAssembly(Form( |
| 3639 | "ITSSPDlay%d-Stave",layer)); |
| 3640 | // define the indexes of the ladders in order to have the correct order |
| d0048cec |
3641 | // keeping in mind that the staves will be inserted as they are on layer |
| 3642 | // 2, while they are rotated around their local Y axis when inserted |
| 3643 | // on layer 1, so in this case they must be put in the "wrong" order |
| 3644 | // to turn out to be right at the end. The convention is: |
| 54c9a3d9 |
3645 | // -|Zmax| ------> |Zmax| |
| 3646 | // 3 2 1 0 |
| d0048cec |
3647 | // with respect to the "native" stave reference frame, "left" is in |
| 54c9a3d9 |
3648 | // the positive Z this leads the definition of these indexes: |
| 3649 | Int_t idxCentralL, idxSideL, idxCentralR, idxSideR; |
| 3650 | |
| 3651 | if (layer == 1) { |
| 3652 | idxSideL = 3; |
| 3653 | idxCentralL = 2; |
| 3654 | idxCentralR = 1; |
| 3655 | idxSideR = 0; |
| 3656 | } else { |
| 3657 | idxSideL = 0; |
| 3658 | idxCentralL = 1; |
| 3659 | idxCentralR = 2; |
| 3660 | idxSideR = 3; |
| 3661 | } // end if layer ==1 |
| d0048cec |
3662 | |
| 54c9a3d9 |
3663 | // create the two half-staves |
| 3664 | TArrayD sizeL, sizeR; |
| 3665 | TGeoVolumeAssembly *hstaveL = CreateHalfStave(kFALSE, layer, idxCentralL, |
| 3666 | idxSideL, sizeL,mgr); |
| 3667 | TGeoVolumeAssembly *hstaveR = CreateHalfStave(kTRUE, layer, idxCentralR, |
| 3668 | idxSideR, sizeR, mgr); |
| 3669 | // copy the size to the stave's one |
| 3670 | sizes.Set(9); |
| 3671 | sizes[0] = sizeL[0]; |
| 3672 | sizes[1] = sizeR[1] + sizeL[1]; |
| 3673 | sizes[2] = sizeL[2]; |
| 3674 | sizes[3] = sizeL[3]; |
| 3675 | sizes[4] = sizeL[4]; |
| 3676 | sizes[5] = sizeL[5]; |
| 3677 | sizes[6] = sizeL[6]; |
| 3678 | sizes[7] = sizeR[5]; |
| 3679 | sizes[8] = sizeR[6]; |
| 3680 | |
| 3681 | // add to container all objects |
| 3682 | container->AddNode(hstaveL, 1); |
| 3683 | container->AddNode(hstaveR, 1); |
| 3684 | |
| 3685 | return container; |
| bc3498f4 |
3686 | } |
| 54c9a3d9 |
3687 | //______________________________________________________________________ |
| bc3498f4 |
3688 | void AliITSv11GeometrySPD::SetAddStave(Bool_t *mask) |
| 3689 | { |
| 54c9a3d9 |
3690 | // |
| 3691 | // Define a mask which states qhich staves must be placed. |
| d0048cec |
3692 | // It is a string which must contain '0' or '1' depending if |
| 54c9a3d9 |
3693 | // a stave must be placed or not. |
| d0048cec |
3694 | // Each place is referred to one of the staves, so the first |
| 54c9a3d9 |
3695 | // six characters of the string will be checked. |
| 3696 | // |
| 3697 | Int_t i; |
| 3698 | |
| 3699 | for (i = 0; i < 6; i++) fAddStave[i] = mask[i]; |
| bc3498f4 |
3700 | } |
| 54c9a3d9 |
3701 | //______________________________________________________________________ |
| 3702 | void AliITSv11GeometrySPD::StavesInSector(TGeoVolume *moth, TGeoManager *mgr) |
| 3703 | { |
| 3704 | // |
| 3705 | // Unification of essentially two methods: |
| 3706 | // - the one which creates the sector structure |
| 3707 | // - the one which returns the complete stave |
| 3708 | // --- |
| 3709 | // For compatibility, this method requires the same arguments |
| 3710 | // asked by "CarbonFiberSector" method, which is recalled here. |
| 3711 | // Like this cited method, this one does not return any value, |
| 3712 | // but it inserts in the mother volume (argument 'moth') all the stuff |
| 3713 | // which composes the complete SPD sector. |
| 3714 | // --- |
| d0048cec |
3715 | // In the following, the stave numbering order used for arrays is the |
| 54c9a3d9 |
3716 | // same as defined in the GetSectorMountingPoints(): |
| 3717 | // /5 |
| 3718 | // /\/4 |
| 3719 | // 1\ \/3 |
| 3720 | // 0|___\/2 |
| 3721 | // --- |
| 3722 | // Arguments: see description of "CarbonFiberSector" method. |
| 3723 | // |
| 3724 | |
| d0048cec |
3725 | Double_t shift[6]; // shift from the innermost position in the |
| 3726 | // sector placement plane (where the stave |
| 3727 | // edge is in the point where the rounded |
| 54c9a3d9 |
3728 | // corner begins) |
| 3729 | |
| 3730 | shift[0] = fgkmm * -0.691; |
| 3731 | shift[1] = fgkmm * 5.041; |
| 3732 | shift[2] = fgkmm * 1.816; |
| 3733 | shift[3] = fgkmm * -0.610; |
| 3734 | shift[4] = fgkmm * -0.610; |
| 3735 | shift[5] = fgkmm * -0.610; |
| d0048cec |
3736 | |
| 3ffa185f |
3737 | // corrections after interaction with Andrea and CAD |
| 3738 | Double_t corrX[6] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0}; |
| 3739 | Double_t corrY[6] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0}; |
| d0048cec |
3740 | |
| 3ffa185f |
3741 | corrX[0] = 0.0046; |
| 3742 | corrX[1] = -0.0041; |
| 3743 | corrX[2] = corrX[3] = corrX[4] = corrX[5] = -0.0016; |
| d0048cec |
3744 | |
| 3ffa185f |
3745 | corrY[0] = -0.0007; |
| 3746 | corrY[1] = -0.0009; |
| 3747 | corrY[2] = corrY[3] = corrY[4] = corrY[5] = -0.0003; |
| d0048cec |
3748 | |
| 3ffa185f |
3749 | corrX[0] += 0.00026; |
| 3750 | corrY[0] += -0.00080; |
| d0048cec |
3751 | |
| 3ffa185f |
3752 | corrX[1] += 0.00018; |
| 3753 | corrY[1] += -0.00086; |
| d0048cec |
3754 | |
| 3ffa185f |
3755 | corrX[2] += 0.00020; |
| 3756 | corrY[2] += -0.00062; |
| d0048cec |
3757 | |
| 3ffa185f |
3758 | corrX[3] += 0.00017; |
| 3759 | corrY[3] += -0.00076; |
| d0048cec |
3760 | |
| 3ffa185f |
3761 | corrX[4] += 0.00016; |
| 3762 | corrY[4] += -0.00096; |
| d0048cec |
3763 | |
| 3ffa185f |
3764 | corrX[5] += 0.00018; |
| 3765 | corrY[5] += -0.00107; |
| d0048cec |
3766 | |
| 54c9a3d9 |
3767 | // create stave volumes (different for layer 1 and 2) |
| 3768 | TArrayD staveSizes1(9), staveSizes2(9), clipSize(5); |
| 3769 | Double_t &staveHeight = staveSizes1[2], &staveThickness = staveSizes1[0]; |
| 3770 | TGeoVolume *stave1 = CreateStave(1, staveSizes1, mgr); |
| 3771 | TGeoVolume *stave2 = CreateStave(2, staveSizes2, mgr); |
| 3772 | TGeoVolume *clip = CreateClip(clipSize, kFALSE, mgr); |
| 3773 | |
| 3774 | Double_t xL, yL; // leftmost edge of mounting point (XY projection) |
| 3775 | Double_t xR, yR; // rightmost edge of mounting point (XY projection) |
| 3776 | Double_t xM, yM; // middle point of the segment L-R |
| 3777 | Double_t dx, dy; // (xL - xR) and (yL - yR) |
| 3778 | Double_t widthLR; // width of the segment L-R |
| 3779 | Double_t angle; // stave rotation angle in degrees |
| d0048cec |
3780 | Double_t diffWidth; // difference between mounting plane width and |
| 54c9a3d9 |
3781 | // stave width (smaller) |
| 3782 | Double_t xPos, yPos; // final translation of the stave |
| 3783 | Double_t parMovement; // translation in the LR plane direction |
| d0048cec |
3784 | |
| 54c9a3d9 |
3785 | staveThickness += fgkGapHalfStave; |
| d0048cec |
3786 | |
| 54c9a3d9 |
3787 | // loop on staves |
| 3788 | Int_t i, iclip = 1; |
| 3789 | for (i = 0; i < 6; i++) { |
| 3790 | // in debug mode, if this stave is not required, it is skipped |
| 3791 | if (!fAddStave[i]) continue; |
| 3792 | // retrieve reference points |
| 3793 | GetSectorMountingPoints(i, xL, yL, xR, yR); |
| 3794 | xM = 0.5 * (xL + xR); |
| 3795 | yM = 0.5 * (yL + yR); |
| 3796 | dx = xL - xR; |
| 3797 | dy = yL - yR; |
| 3798 | angle = TMath::ATan2(dy, dx); |
| 3799 | widthLR = TMath::Sqrt(dx*dx + dy*dy); |
| 3800 | diffWidth = 0.5*(widthLR - staveHeight); |
| 3801 | // first, a movement along this plane must be done |
| 3802 | // by an amount equal to the width difference |
| 3803 | // and then the fixed shift must also be added |
| 3804 | parMovement = diffWidth + shift[i]; |
| d0048cec |
3805 | // due to stave thickness, another movement must be done |
| 54c9a3d9 |
3806 | // in the direction normal to the mounting plane |
| d0048cec |
3807 | // which is computed using an internal method, in a reference |
| 3808 | // frame where the LR segment has its middle point in the origin |
| 54c9a3d9 |
3809 | // and axes parallel to the master reference frame |
| 3810 | if (i == 0) { |
| d0048cec |
3811 | ParallelPosition(-0.5*staveThickness, -parMovement, angle, |
| 54c9a3d9 |
3812 | xPos, yPos); |
| 3813 | } // end if i==0 |
| 3814 | if (i == 1) { |
| d0048cec |
3815 | ParallelPosition( 0.5*staveThickness, -parMovement, angle, |
| 54c9a3d9 |
3816 | xPos, yPos); |
| 3817 | }else { |
| d0048cec |
3818 | ParallelPosition( 0.5*staveThickness, parMovement, angle, |
| 54c9a3d9 |
3819 | xPos, yPos); |
| 3820 | } // end if i==1 |
| 3821 | // then we go into the true reference frame |
| 3822 | xPos += xM; |
| 3823 | yPos += yM; |
| 3ffa185f |
3824 | xPos += corrX[i]; |
| 3825 | yPos += corrY[i]; |
| d0048cec |
3826 | // using the parameters found here, compute the |
| 54c9a3d9 |
3827 | // translation and rotation of this stave: |
| 3828 | TGeoRotation *rot = new TGeoRotation(*gGeoIdentity); |
| 3829 | if (i == 0 || i == 1) rot->RotateX(180.0); |
| 3830 | rot->RotateZ(90.0 + angle * TMath::RadToDeg()); |
| 3831 | TGeoCombiTrans *trans = new TGeoCombiTrans(xPos, yPos, 0.0, rot); |
| 3832 | if (i == 0 || i == 1) { |
| 3833 | moth->AddNode(stave1, i+1, trans); |
| 3834 | }else { |
| 3835 | moth->AddNode(stave2, i - 1, trans); |
| 3836 | if (i != 2) { |
| 3837 | // except in the case of stave #2, |
| 3838 | // clips must be added, and this is done directly on the sector |
| 3839 | Int_t j; |
| 4adcf390 |
3840 | //TArrayD clipSize; |
| 54c9a3d9 |
3841 | TGeoRotation *rotClip = new TGeoRotation(*gGeoIdentity); |
| 3842 | rotClip->RotateZ(-90.0); |
| 3843 | rotClip->RotateX(180.0); |
| 3844 | Double_t x = staveSizes2[3] + fgkGapHalfStave; |
| 3845 | Double_t y = staveSizes2[4]; |
| d0048cec |
3846 | Double_t z[4] = { staveSizes2[5], staveSizes2[6], |
| 54c9a3d9 |
3847 | staveSizes2[7], staveSizes2[8] }; |
| 3848 | for (j = 0; j < 4; j++) { |
| 3849 | TGeoCombiTrans *trClip = new TGeoCombiTrans(x, y, z[j], |
| 3850 | rotClip); |
| 3851 | *trClip = *trans * *trClip; |
| 3852 | moth->AddNode(clip, iclip++, trClip); |
| 3853 | } // end for j |
| 3854 | } // end if i!=2 |
| 3855 | } // end if i==0||i==1 else |
| 3856 | } // end for i |
| 592651e2 |
3857 | } |
| 54c9a3d9 |
3858 | //______________________________________________________________________ |
| bc3498f4 |
3859 | void AliITSv11GeometrySPD::ParallelPosition(Double_t dist1, Double_t dist2, |
| 54c9a3d9 |
3860 | Double_t phi, Double_t &x, Double_t &y) const |
| 3861 | { |
| 3862 | // |
| 3863 | // Performs the following steps: |
| d0048cec |
3864 | // 1 - finds a straight line parallel to the one passing through |
| 54c9a3d9 |
3865 | // the origin and with angle 'phi' with X axis(phi in RADIANS); |
| d0048cec |
3866 | // 2 - finds another line parallel to the previous one, with a |
| 54c9a3d9 |
3867 | // distance 'dist1' from it |
| d0048cec |
3868 | // 3 - takes a reference point in the second line in the intersection |
| 54c9a3d9 |
3869 | // between the normal to both lines passing through the origin |
| d0048cec |
3870 | // 4 - finds a point whith has distance 'dist2' from this reference, |
| 54c9a3d9 |
3871 | // in the second line (point 2) |
| 3872 | // ---- |
| d0048cec |
3873 | // According to the signs given to dist1 and dist2, the point is |
| 54c9a3d9 |
3874 | // found in different position w.r. to the origin |
| 3875 | // compute the point |
| 3876 | // |
| 3877 | Double_t cs = TMath::Cos(phi); |
| 3878 | Double_t sn = TMath::Sin(phi); |
| 3879 | |
| 3880 | x = dist2*cs - dist1*sn; |
| 3881 | y = dist1*cs + dist2*sn; |
| 592651e2 |
3882 | } |
| 54c9a3d9 |
3883 | //______________________________________________________________________ |
| 3884 | Double_t AliITSv11GeometrySPD::GetSPDSectorTranslation( |
| 3885 | Double_t x0,Double_t y0,Double_t x1,Double_t y1,Double_t r) const |
| 3886 | { |
| 3887 | // |
| 3888 | // Comutes the radial translation of a sector to give the |
| 3889 | // proper distance between SPD detectors and the beam pipe. |
| 3890 | // Units in are units out. |
| 3891 | // |
| 3892 | |
| 3893 | //Begin_Html |
| 3894 | /* |
| 3895 | <A HREF="http://www.physics.ohio-state.edu/HIRG/SoftWareDoc/SPD_Sector_Position.png"> |
| 3896 | Figure showing the geometry used in the computation below. </A> |
| 3897 | */ |
| 3898 | //End_Html |
| 3899 | |
| 3900 | // Inputs: |
| 3901 | // Double_t x0 Point x0 on Sector surface for the inner |
| 3902 | // most detector mounting |
| 3903 | // Double_t y0 Point y0 on Sector surface for the innor |
| 3904 | // most detector mounting |
| 3905 | // Double_t x1 Point x1 on Sector surface for the inner |
| 3906 | // most detector mounting |
| 3907 | // Double_t y1 Point y1 on Sector surface for the innor |
| 3908 | // most detector mounting |
| 3909 | // Double_t r The radial distance this mounting surface |
| 3910 | // should be from the center of the beam pipe. |
| 3911 | // Outputs: |
| 3912 | // none. |
| 3913 | // Return: |
| 3914 | // The distance the SPD sector should be displaced radialy. |
| 3915 | // |
| 3916 | Double_t a,b,c; |
| 3917 | |
| 3918 | a = x0-x1; |
| 3919 | if(a==0.0) return 0.0; |
| 3920 | a = (y0-y1)/a; |
| 3921 | b = TMath::Sqrt(1.0+a*a); |
| 3922 | c = y0-a*x0-r*b; |
| 3923 | return -c; |
| 3924 | } |
| 3925 | //______________________________________________________________________ |
| bc3498f4 |
3926 | void AliITSv11GeometrySPD::CreateFigure0(const Char_t *filepath, |
| 3927 | const Char_t *type, |
| 54c9a3d9 |
3928 | TGeoManager *mgr) const |
| 3929 | { |
| 3930 | // |
| bc3498f4 |
3931 | // Creates Figure 0 for the documentation of this class. In this |
| 3932 | // specific case, it creates the X,Y cross section of the SPD suport |
| 3933 | // section, center and ends. The output is written to a standard |
| 3934 | // file name to the path specificed. |
| 3935 | // Inputs: |
| 3936 | // const Char_t *filepath Path where the figure is to be drawn |
| 3937 | // const Char_t *type The type of file, default is gif. |
| 3938 | // TGeoManager *mgr The TGeoManager default gGeoManager |
| 3939 | // Output: |
| 3940 | // none. |
| 3941 | // Return: |
| 3942 | // none. |
| 54c9a3d9 |
3943 | // |
| bc3498f4 |
3944 | TGeoXtru *sA0,*sA1,*sB0,*sB1; |
| 3945 | //TPolyMarker *pmA,*pmB; |
| 3946 | TPolyLine plA0,plA1,plB0,plB1; |
| 3947 | TCanvas *canvas; |
| 3948 | TLatex txt; |
| 3949 | Double_t x=0.0,y=0.0; |
| 3950 | Int_t i,kNRadii=6; |
| 3951 | |
| 3952 | if(strcmp(filepath,"")){ |
| 3953 | Error("CreateFigure0","filepath=%s type=%s",filepath,type); |
| 3954 | } // end if |
| 3955 | // |
| 54c9a3d9 |
3956 | sA0 = (TGeoXtru*) mgr->GetVolume("ITSSPDCarbonFiberSupportSectorA0_1")-> |
| 3957 | GetShape(); |
| 3958 | sA1 = (TGeoXtru*) mgr->GetVolume("ITSSPDCarbonFiberSupportSectorAirA1_1")-> |
| 3959 | GetShape(); |
| 3960 | sB0 = (TGeoXtru*) mgr->GetVolume("ITSSPDCarbonFiberSupportSectorEndB0_1")-> |
| 3961 | GetShape(); |
| 3962 | sB1 = (TGeoXtru*) mgr->GetVolume("ITSSPDCarbonFiberSupportSectorEndAirB1_1" |
| 3963 | )->GetShape(); |
| bc3498f4 |
3964 | //pmA = new TPolyMarker(); |
| 3965 | //pmA.SetMarkerStyle(2); // + |
| 3966 | //pmA.SetMarkerColor(7); // light blue |
| 3967 | //pmB = new TPolyMarker(); |
| 3968 | //pmB.SetMarkerStyle(5); // X |
| 3969 | //pmB.SetMarkerColor(6); // purple |
| 3970 | plA0.SetPolyLine(sA0->GetNvert()); |
| 3971 | plA0.SetLineColor(1); // black |
| 3972 | plA0.SetLineStyle(1); |
| 3973 | plA1.SetPolyLine(sA1->GetNvert()); |
| 3974 | plA1.SetLineColor(2); // red |
| 3975 | plA1.SetLineStyle(1); |
| 3976 | plB0.SetPolyLine(sB0->GetNvert()); |
| 3977 | plB0.SetLineColor(3); // Green |
| 3978 | plB0.SetLineStyle(2); |
| 3979 | plB1.SetPolyLine(sB1->GetNvert()); |
| 3980 | plB1.SetLineColor(4); // Blue |
| 3981 | plB1.SetLineStyle(2); |
| 3982 | //for(i=0;i<kNRadii;i++) pmA.SetPoint(i,xyB1p[i][0],xyB1p[i][1]); |
| 3983 | //for(i=0;i<kNRadii;i++) pmB.SetPoint(i,xyB1p[i][0],xyB1p[i][1]); |
| 3984 | for(i=0;i<sA0->GetNvert();i++) plA0.SetPoint(i,sA0->GetX(i),sA0->GetY(i)); |
| 3985 | for(i=0;i<sA1->GetNvert();i++) plA1.SetPoint(i,sA1->GetX(i),sA1->GetY(i)); |
| 3986 | for(i=0;i<sB0->GetNvert();i++) plB0.SetPoint(i,sB0->GetX(i),sB0->GetY(i)); |
| 3987 | for(i=0;i<sB1->GetNvert();i++) plB1.SetPoint(i,sB1->GetX(i),sB1->GetY(i)); |
| 3988 | canvas = new TCanvas("AliITSv11GeometrySPDFig0","",1000,1000); |
| 3989 | canvas->Range(-3.,-3.,3.,3.); |
| 3990 | txt.SetTextSize(0.05); |
| 3991 | txt.SetTextAlign(33); |
| 3992 | txt.SetTextColor(1); |
| 3993 | txt.DrawLatex(2.9,2.9,"Section A-A outer Carbon Fiber surface"); |
| 3994 | txt.SetTextColor(2); |
| 3995 | txt.DrawLatex(2.9,2.5,"Section A-A Inner Carbon Fiber surface"); |
| 3996 | txt.SetTextColor(3); |
| 3997 | txt.DrawLatex(2.9,2.1,"Section E-E outer Carbon Fiber surface"); |
| 3998 | txt.SetTextColor(4); |
| 3999 | txt.DrawLatex(2.9,1.7,"Section E-E Inner Carbon Fiber surface"); |
| 4000 | plA0.Draw(); |
| 4001 | plA1.Draw(); |
| 4002 | plB0.Draw(); |
| 4003 | plB1.Draw(); |
| 4004 | //pmA.Draw(); |
| 4005 | //pmB.Draw(); |
| 4006 | // |
| 4007 | x = 1.0; |
| 4008 | y = -2.5; |
| 4009 | Char_t chr[3]; |
| 4010 | for(i=0;i<kNRadii;i++){ |
| 4011 | sprintf(chr,"%2d",i);txt.DrawLatex(x-0.1,y,chr); |
| 4012 | sprintf(chr,"%8.4f",5.000);txt.DrawLatex(x,y,chr); |
| 4013 | sprintf(chr,"%8.4f",5.000);txt.DrawLatex(x+0.5,y,chr); |
| 4014 | sprintf(chr,"%8.4f",5.000);txt.DrawLatex(x+1.0,y,chr); |
| 4015 | sprintf(chr,"%8.4f",5.000);txt.DrawLatex(x+1.5,y,chr); |
| 4016 | sprintf(chr,"%8.4f",5.000);txt.DrawLatex(x+2.0,y,chr); |
| 4017 | if(kTRUE) txt.DrawLatex(x+2.5,y,"A-A/E-E"); |
| 4018 | else txt.DrawLatex(x+2.5,y,"E-E"); |
| 4019 | } // end for i |
| 4020 | txt.DrawLatex(x,y,"x_{c} mm"); |
| 4021 | txt.DrawLatex(x+0.5,y,"y_{c} mm"); |
| 4022 | txt.DrawLatex(x+1.0,y,"R mm"); |
| 4023 | txt.DrawLatex(x+1.5,y,"#theta_{start}^{#circle}"); |
| 4024 | txt.DrawLatex(x+2.0,y,"#theta_{end}^{#circle}"); |
| 4025 | txt.DrawLatex(x+2.5,y,"Section"); |
| 4026 | // |
| 4027 | } |
| 54c9a3d9 |
4028 | //______________________________________________________________________ |
| 4029 | void AliITSv11GeometrySPD::PrintAscii(ostream *os) const |
| 4030 | { |
| 4031 | // |
| bc3498f4 |
4032 | // Print out class data values in Ascii Form to output stream |
| 4033 | // Inputs: |
| 4034 | // ostream *os Output stream where Ascii data is to be writen |
| 4035 | // Outputs: |
| 4036 | // none. |
| 4037 | // Return: |
| 4038 | // none. |
| 54c9a3d9 |
4039 | // |
| 4040 | Int_t i,j,k; |
| bc3498f4 |
4041 | #if defined __GNUC__ |
| 4042 | #if __GNUC__ > 2 |
| 4043 | ios::fmtflags fmt = cout.flags(); |
| 4044 | #else |
| 4045 | Int_t fmt; |
| 4046 | #endif |
| 4047 | #else |
| 4048 | #if defined __ICC || defined __ECC || defined __xlC__ |
| 4049 | ios::fmtflags fmt; |
| 4050 | #else |
| 4051 | Int_t fmt; |
| 4052 | #endif |
| 4053 | #endif |
| 54c9a3d9 |
4054 | |
| 4055 | *os<< fgkGapLadder <<" "<< fgkGapHalfStave<<" "<< 6 <<" "; |
| 4056 | for(i=0;i<6;i++) *os<< fAddStave[i] <<" "<<fSPDsectorX0.GetSize(); |
| 4057 | for(i=0;i<fSPDsectorX0.GetSize();i++) *os<< fSPDsectorX0.GetAt(i) << " "; |
| 4058 | for(i=0;i<fSPDsectorX0.GetSize();i++) *os<< fSPDsectorY0.GetAt(i) << " "; |
| 4059 | for(i=0;i<fSPDsectorX1.GetSize();i++) *os<< fSPDsectorX1.GetAt(i) << " "; |
| 4060 | for(i=0;i<fSPDsectorX1.GetSize();i++) *os<< fSPDsectorY1.GetAt(i) << " "; |
| 4061 | *os<<10<<" "<< 2 <<" " << 6 << " "<< 3 <<" "; |
| d0048cec |
4062 | for(k=0;k<10;k++)for(i=0;i<6;i++)for(j=0;j<3;j++) |
| 54c9a3d9 |
4063 | *os<<fTubeEndSector[k][0][i][j]<<" "; |
| d0048cec |
4064 | for(k=0;k<10;k++)for(i=0;i<6;i++)for(j=0;j<3;j++) |
| 54c9a3d9 |
4065 | *os<<fTubeEndSector[k][1][i][j]<<" "; |
| bc3498f4 |
4066 | os->flags(fmt); // reset back to old Formating. |
| 4067 | return; |
| 4068 | } |
| 4069 | // |
| 54c9a3d9 |
4070 | //______________________________________________________________________ |
| 4071 | void AliITSv11GeometrySPD::ReadAscii(istream* is) |
| 4072 | { |
| 4073 | // |
| bc3498f4 |
4074 | // Read in class data values in Ascii Form to output stream |
| 4075 | // Inputs: |
| 4076 | // istream *is Input stream where Ascii data is to be read in from |
| 4077 | // Outputs: |
| 4078 | // none. |
| 4079 | // Return: |
| 4080 | // none. |
| 54c9a3d9 |
4081 | // |
| 4082 | Int_t i,j,k,n; |
| 4083 | Double_t gapLadder,GapHalfStave; |
| 4084 | |
| 4085 | *is>>gapLadder>>GapHalfStave>>n; |
| 4086 | if(n!=6){ |
| 4087 | Warning("ReadAscii","fAddStave Array !=6 n=%d",n); |
| 4088 | return; |
| 4089 | } // end if |
| 4090 | for(i=0;i<n;i++) *is>>fAddStave[i]; |
| 4091 | *is>>n; |
| 4092 | fSPDsectorX0.Set(n); |
| 4093 | fSPDsectorY0.Set(n); |
| 4094 | fSPDsectorX1.Set(n); |
| 4095 | fSPDsectorY1.Set(n); |
| 4096 | for(i=0;i<n;i++) *is>>fSPDsectorX0[i]; |
| 4097 | for(i=0;i<n;i++) *is>>fSPDsectorY0[i]; |
| 4098 | for(i=0;i<n;i++) *is>>fSPDsectorX1[i]; |
| 4099 | for(i=0;i<n;i++) *is>>fSPDsectorY1[i]; |
| 4100 | *is>> i>>j>>n; |
| 4101 | if(i!=2||j!=6||n!=3){ |
| 4102 | Warning("ReadAscii","fTubeEndSector array wrong size [2][6][3]," |
| 4103 | "found [%d][%d][%d]",i,j,n); |
| 4104 | return; |
| 4105 | } // end if |
| d0048cec |
4106 | for(k=0;k<10;k++)for(i=0;i<6;i++)for(j=0;j<3;j++) |
| 54c9a3d9 |
4107 | *is>>fTubeEndSector[k][0][i][j]; |
| d0048cec |
4108 | for(k=0;k<10;k++)for(i=0;i<6;i++)for(j=0;j<3;j++) |
| 54c9a3d9 |
4109 | *is>>fTubeEndSector[k][1][i][j]; |
| 4110 | return; |
| bc3498f4 |
4111 | } |
| 4112 | // |
| 54c9a3d9 |
4113 | //______________________________________________________________________ |
| 4114 | ostream &operator<<(ostream &os,const AliITSv11GeometrySPD &s) |
| 4115 | { |
| 4116 | // |
| bc3498f4 |
4117 | // Standard output streaming function |
| 4118 | // Inputs: |
| 4119 | // ostream &os output steam |
| 4120 | // AliITSvPPRasymmFMD &s class to be streamed. |
| 4121 | // Output: |
| 4122 | // none. |
| 4123 | // Return: |
| 4124 | // ostream &os The stream pointer |
| 54c9a3d9 |
4125 | // |
| bc3498f4 |
4126 | s.PrintAscii(&os); |
| 4127 | return os; |
| 4128 | } |
| 4129 | // |
| 54c9a3d9 |
4130 | //______________________________________________________________________ |
| 4131 | istream &operator>>(istream &is,AliITSv11GeometrySPD &s) |
| 4132 | { |
| 4133 | // |
| bc3498f4 |
4134 | // Standard inputput streaming function |
| 4135 | // Inputs: |
| 4136 | // istream &is input steam |
| 4137 | // AliITSvPPRasymmFMD &s class to be streamed. |
| 4138 | // Output: |
| 4139 | // none. |
| 4140 | // Return: |
| 4141 | // ostream &os The stream pointer |
| 54c9a3d9 |
4142 | // |
| bc3498f4 |
4143 | s.ReadAscii(&is); |
| 4144 | return is; |
| 4145 | } |
| 4146 | // |
| 54c9a3d9 |
4147 | //______________________________________________________________________ |
| bc3498f4 |
4148 | Bool_t AliITSv11GeometrySPD::Make2DCrossSections(TPolyLine &a0,TPolyLine &a1, |
| 54c9a3d9 |
4149 | TPolyLine &b0,TPolyLine &b1,TPolyMarker &p)const |
| 4150 | { |
| 4151 | // |
| 297369a1 |
4152 | // Fill the objects with the points representing |
| 4153 | // a0 the outer carbon fiber SPD sector shape Cross Section A |
| 4154 | // a1 the inner carbon fiber SPD sector shape Cross Section A |
| 4155 | // b0 the outer carbon fiber SPD sector shape Cross Section B |
| 4156 | // b1 the inner carbon fiber SPD sector shape Cross Section B |
| 4157 | // |
| 4158 | // Inputs: |
| 4159 | // TPolyLine &a0 The outer carbon fiber SPD sector shape |
| 4160 | // TPolyLine &a1 The Inner carbon fiber SPD sector shape |
| 4161 | // TPolyLine &b0 The outer carbon fiber SPD sector shape |
| 4162 | // TPolyLine &b1 The Inner carbon fiber SPD sector shape |
| 4163 | // TPolyMarker &p The points where the ladders are to be placed |
| 4164 | // Outputs: |
| 4165 | // TPolyLine &a0 The shape filled with the points |
| 4166 | // TPolyLine &a1 The shape filled with the points |
| 4167 | // TPolyLine &b0 The shape filled with the points |
| 4168 | // TPolyLine &b1 The shape filled with the points |
| 4169 | // TPolyMarker &p The filled array of points |
| 4170 | // Return: |
| 4171 | // An error flag. |
| 54c9a3d9 |
4172 | // |
| 297369a1 |
4173 | Int_t n0,n1,i; |
| 4174 | Double_t x,y; |
| 4175 | TGeoVolume *a0V,*a1V,*b0V,*b1V; |
| 4176 | TGeoXtru *a0S,*a1S,*b0S,*b1S; |
| 4177 | TGeoManager *mgr = gGeoManager; |
| 4178 | |
| bc3498f4 |
4179 | a0V = mgr->GetVolume("ITS SPD Carbon fiber support Sector A0"); |
| 297369a1 |
4180 | a0S = dynamic_cast<TGeoXtru*>(a0V->GetShape()); |
| 4181 | n0 = a0S->GetNvert(); |
| 4182 | a0.SetPolyLine(n0+1); |
| d0048cec |
4183 | //for(i=0;i<fSPDsectorPoints0.GetSize();i++) |
| 297369a1 |
4184 | // printf("%d %d %d\n",i,fSPDsectorPoints0[i],fSPDsectorPoints1[i]); |
| 4185 | for(i=0;i<n0;i++){ |
| 4186 | x = a0S->GetX(i); |
| 54c9a3d9 |
4187 | y = a0S->GetY(i); |
| 4188 | //printf("%d %g %g\n",i,x,y); |
| 297369a1 |
4189 | a0.SetPoint(i,x,y); |
| 54c9a3d9 |
4190 | if(i==0) a0.SetPoint(n0,x,y); |
| 297369a1 |
4191 | } // end for i |
| 4192 | a1V = mgr->GetVolume("ITSSPDCarbonFiberSupportSectorAirA1"); |
| 4193 | a1S = dynamic_cast<TGeoXtru*>(a1V->GetShape()); |
| 4194 | n1 = a1S->GetNvert(); |
| 4195 | a1.SetPolyLine(n1+1); |
| 4196 | for(i=0;i<n1;i++){ |
| 4197 | x = a1S->GetX(i); |
| 54c9a3d9 |
4198 | y = a1S->GetY(i); |
| 297369a1 |
4199 | a1.SetPoint(i,x,y); |
| 54c9a3d9 |
4200 | if(i==0) a1.SetPoint(n1,x,y); |
| 297369a1 |
4201 | } // end for i |
| 4202 | // Cross Section B |
| 4203 | b0V = mgr->GetVolume("ITSSPDCarbonFiberSupportSectorEndB0"); |
| 4204 | b0S = dynamic_cast<TGeoXtru*>(b0V->GetShape()); |
| 4205 | n0 = b0S->GetNvert(); |
| 4206 | b0.SetPolyLine(n0+1); |
| 4207 | for(i=0;i<n0;i++){ |
| 4208 | x = b0S->GetX(i); |
| 54c9a3d9 |
4209 | y = b0S->GetY(i); |
| 297369a1 |
4210 | b0.SetPoint(i,x,y); |
| 54c9a3d9 |
4211 | if(i==0) b0.SetPoint(n0,x,y); |
| 297369a1 |
4212 | } // end for i |
| 4213 | b1V = mgr->GetVolume("ITSSPDCarbonFiberSupportSectorEndAirB1"); |
| 4214 | b1S = dynamic_cast<TGeoXtru*>(b1V->GetShape()); |
| 4215 | n1 = b1S->GetNvert(); |
| 4216 | b1.SetPolyLine(n1+1); |
| 4217 | for(i=0;i<n1;i++){ |
| 4218 | x = b1S->GetX(i); |
| 54c9a3d9 |
4219 | y = b1S->GetY(i); |
| 297369a1 |
4220 | b1.SetPoint(i,x,y); |
| 54c9a3d9 |
4221 | if(i==0) b1.SetPoint(n1,x,y); |
| 297369a1 |
4222 | } // end for i |
| 4223 | // |
| 4224 | Double_t x0,y0,x1,y1; |
| bc3498f4 |
4225 | p.SetPolyMarker(2*fSPDsectorX0.GetSize()); |
| 4226 | for(i=0;i<fSPDsectorX0.GetSize();i++){ |
| 54c9a3d9 |
4227 | GetSectorMountingPoints(i,x0,y0,x1,y1); |
| 4228 | p.SetPoint(2*i,x0,y0); |
| 4229 | p.SetPoint(2*i+1,x1,y1); |
| 297369a1 |
4230 | } // end for i |
| 4231 | return kTRUE; |
| 4232 | } |
git://git.uio.no / u / mrichter / AliRoot.git / blame