ITS/AliITSv11GeometrySupport.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 // This class Defines the Geometry for the ITS services and support cones
  17 // outside of the ceneteral volume (except for the Ceneteral support
  18 // cylinders. Other classes define the rest of the ITS. Specificaly the ITS
  19 // The SSD support cone,SSD Support centeral cylinder, SDD support cone,
  20 // The SDD cupport centeral cylinder, the SPD Thermal Sheald, The supports
  21 // and cable trays on both the RB26 (muon dump) and RB24 sides, and all of
  22 // the cabling from the ladders/stave ends out past the TPC.
  23
  24 /* $Id$ */
  25 // General Root includes
  26 #include <TMath.h>
  27 // Root Geometry includes
  28 //#include <AliLog.h>
  29 #include <TGeoManager.h>
  30 #include <TGeoVolume.h>
  31 #include <TGeoPcon.h>
  32 #include <TGeoCone.h>
  33 #include <TGeoTube.h> // contaings TGeoTubeSeg
  34 #include <TGeoArb8.h>
  35 #include <TGeoXtru.h>
  36 #include <TGeoCompositeShape.h>
  37 #include <TGeoMatrix.h>
  38 #include "AliITSv11GeometrySupport.h"
  39
  40 ClassImp(AliITSv11GeometrySupport)
  41
  42 #define SQ(A) (A)*(A)
  43
  44 //______________________________________________________________________
  45 void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,TGeoManager *mgr)
  46 {
  47 //
  48 // Creates the SPD thermal shield as a volume assembly
  49 // and adds it to the mother volume
  50 // (this is actually a merge of the previous SPDThermalSheald method
  51 // of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06 and the
  52 // CreateSPDThermalShield method of AliITSv11Hybrid)
  53 //
  54 // Input:
  55 //         moth : the TGeoVolume owing the volume structure
  56 //         mgr  : the GeoManager (default gGeoManager)
  57 // Output:
  58 //
  59 // Created:         ???          ???
  60 // Updated:      11 Dec 2007  Mario Sitta
  61 //
  62 // Technical data are taken from:  ALICE-Thermal Screen "Cone transition"
  63 // (thermal-screen1_a3.ps), "Cylinder" (thermal-screen2_a3.ps), "Half
  64 // assembly" (thermal-screen3_a3.ps), "Flange" (thermal-screen4_a3.ps)
  65
  66
  67   // Dimensions of the Central shield
  68   const Double_t kHalfLengthCentral  = 400.*fgkmm;
  69   const Double_t kThicknessCentral   = 0.4*fgkmm;
  70   const Double_t kInnerRadiusCentral = 8.1475*fgkcm;
  71   const Double_t kOuterRadiusCentral = 9.9255*fgkcm;
  72   const Double_t kInnerACentral = 3.1674*fgkcm;
  73   const Double_t kInnerBCentral = 2.023 *fgkcm;
  74   const Double_t kOuterACentral = 2.4374*fgkcm;
  75   const Double_t kOuterBCentral = 3.8162*fgkcm;
  76   // Dimensions of the EndCap shield
  77   const Double_t kHalfLengthEndCap  = 25.*fgkmm;
  78   const Double_t kThicknessEndCap   = 2.0*fgkmm;
  79   const Double_t kInnerRadiusEndCap = 8.0775*fgkcm;
  80   const Double_t kOuterRadiusEndCap = 9.9955*fgkcm;
  81   const Double_t kInnerAEndCap = 3.1453*fgkcm;
  82   const Double_t kInnerBEndCap = 2.0009*fgkcm;
  83   const Double_t kOuterAEndCap = 2.4596*fgkcm;
  84   const Double_t kOuterBEndCap = 3.8384*fgkcm;
  85   // Dimensions of the Cone shield
  86   const Double_t kHalfLengthCone  = 145.*fgkmm;
  87   const Double_t kThicknessCone   = 0.3*fgkmm;
  88   const Double_t kInnerRadialCone = 37.3*fgkcm;
  89   const Double_t kOuterRadialCone = 39.0*fgkcm;
  90   const Double_t kInnerACone = 14.2344*fgkcm;
  91   //  const Double_t kInnerBCone =  9.0915*fgkcm;
  92   const Double_t kOuterACone =  9.5058*fgkcm;
  93   //  const Double_t kOuterBCone = 14.8831*fgkcm;
  94   // Dimensions of the Flange's Ring and Wing
  95   const Double_t kHalfLengthRing  = 7.5*fgkmm;
  96   const Double_t kThicknessRing   = 0.3*fgkmm;
  97   const Double_t kInnerRadiusRing = 37.3*fgkcm;
  98   const Double_t kOuterRadiusRing = 42.0*fgkcm;
  99   const Double_t kOuterRadiusWing = 49.25*fgkcm;
 100   const Double_t kWideWing      = 6.0*fgkcm;
 101   const Double_t kThetaWing     = 45.0;
 102   // Common data
 103   const Double_t kTheta = 36.0*TMath::DegToRad();
 104   const Double_t kThicknessOmega = 0.3*fgkmm;
 105
 106   // Local variables
 107   Double_t x, y;
 108   Double_t xshld[24], yshld[24];
 109   Double_t xair[24] , yair[24];
 110   Double_t xomega[48], yomega[48];
 111   //  Double_t *xyarb8;
 112
 113   // The entire shield is made up of two half central shields
 114   // symmetric with respect to the XZ plane, four half end cap
 115   // shields, again symmetric with respect to the XZ plane, and four
 116   // half cones, symmetric with respect to the XZ plane too.
 117
 118   TGeoVolumeAssembly *vM = new TGeoVolumeAssembly("ITSspdThermalShield");
 119
 120   // The central half shield: a half tube of carbon fiber,
 121   // a similar but proportionally smaller half tube of air inside it,
 122   // and a Omega-shaped carbon fiber insert inside the air.
 123   // They are all XTru shapes
 124
 125   TGeoXtru *centralshape = new TGeoXtru(2);
 126
 127   CreateSPDThermalShape(kInnerACentral,kInnerBCentral,kInnerRadiusCentral,
 128                         kOuterACentral,kOuterBCentral,kOuterRadiusCentral,
 129                         kTheta,xshld,yshld);
 130
 131   centralshape->DefinePolygon(24,xshld,yshld);
 132   centralshape->DefineSection(0,-kHalfLengthCentral);
 133   centralshape->DefineSection(1, kHalfLengthCentral);
 134
 135   // Now rescale to get the air volume dimensions
 136     InsidePoint(xshld[23], yshld[23],
 137                 xshld[ 0], yshld[ 0],
 138                 xshld[ 1], yshld[ 1], kThicknessCentral,
 139                 xair[0], yair[0]);
 140   for (Int_t i=1; i<23; i++) {
 141     InsidePoint(xshld[i-1], yshld[i-1],
 142                 xshld[ i ], yshld[ i ],
 143                 xshld[i+1], yshld[i+1], kThicknessCentral,
 144                 xair[i], yair[i]);
 145   }
 146     InsidePoint(xshld[22], yshld[22],
 147                 xshld[23], yshld[23],
 148                 xshld[ 0], yshld[ 0], kThicknessCentral,
 149                 xair[23], yair[23]);
 150
 151   // Create the air shape
 152   TGeoXtru *centralairshape = new TGeoXtru(2);
 153
 154   centralairshape->DefinePolygon(24,xair,yair);
 155   centralairshape->DefineSection(0,-kHalfLengthCentral);
 156   centralairshape->DefineSection(1, kHalfLengthCentral);
 157
 158   // Create the Omega insert
 159   TGeoXtru *centralomegashape = new TGeoXtru(2);
 160
 161   CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
 162
 163   centralomegashape->DefinePolygon(48,xomega,yomega);
 164   centralomegashape->DefineSection(0,-kHalfLengthCentral);
 165   centralomegashape->DefineSection(1, kHalfLengthCentral);
 166
 167   // The end cap half shield: a half tube of carbon fiber,
 168   // a similar but proportionally smaller half tube of air inside it,
 169   // and a Omega-shaped carbon fiber insert inside the air.
 170   // They are all XTru shapes
 171
 172   TGeoXtru *endcapshape = new TGeoXtru(2);
 173
 174   CreateSPDThermalShape(kInnerAEndCap,kInnerBEndCap,kInnerRadiusEndCap,
 175                         kOuterAEndCap,kOuterBEndCap,kOuterRadiusEndCap,
 176                         kTheta,xshld,yshld);
 177
 178   endcapshape->DefinePolygon(24,xshld,yshld);
 179   endcapshape->DefineSection(0,-kHalfLengthEndCap);
 180   endcapshape->DefineSection(1, kHalfLengthEndCap);
 181
 182   // Now rescale to get the air volume dimensions
 183     InsidePoint(xshld[23], yshld[23],
 184                 xshld[ 0], yshld[ 0],
 185                 xshld[ 1], yshld[ 1], kThicknessEndCap,
 186                 xair[0], yair[0]);
 187   for (Int_t i=1; i<23; i++) {
 188     InsidePoint(xshld[i-1], yshld[i-1],
 189                 xshld[ i ], yshld[ i ],
 190                 xshld[i+1], yshld[i+1], kThicknessEndCap,
 191                 xair[i], yair[i]);
 192   }
 193     InsidePoint(xshld[22], yshld[22],
 194                 xshld[23], yshld[23],
 195                 xshld[ 0], yshld[ 0], kThicknessEndCap,
 196                 xair[23], yair[23]);
 197
 198   // Create the air shape
 199   TGeoXtru *endcapairshape = new TGeoXtru(2);
 200
 201   endcapairshape->DefinePolygon(24,xair,yair);
 202   endcapairshape->DefineSection(0,-kHalfLengthEndCap);
 203   endcapairshape->DefineSection(1, kHalfLengthEndCap);
 204
 205   // Create the Omega insert
 206   TGeoXtru *endcapomegashape = new TGeoXtru(2);
 207
 208   CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
 209
 210   endcapomegashape->DefinePolygon(48,xomega,yomega);
 211   endcapomegashape->DefineSection(0,-kHalfLengthEndCap);
 212   endcapomegashape->DefineSection(1, kHalfLengthEndCap);
 213
 214   // The cone half shield is more complex since there is no basic
 215   // TGeo shape to describe it correctly. So it is made of a series
 216   // of TGeoArb8 shapes filled with air, which all together make up the
 217   // the cone AND its internal insert. Part of the following code is
 218   // adapted from SPDThermalSheald method.
 219
 220   // Filled portions
 221   TGeoArb8 *sC1 = new TGeoArb8(kHalfLengthCone);
 222   TGeoArb8 *sC2 = new TGeoArb8(kHalfLengthCone);
 223
 224   CreateSPDThermalShape(kInnerACentral,kInnerBCentral,kInnerRadiusCentral,
 225                         kOuterACentral,kOuterBCentral,kOuterRadiusCentral,
 226                         kTheta,xshld,yshld);
 227
 228   sC1->SetVertex(0,xshld[12],yshld[12]);
 229   sC1->SetVertex(1,xshld[11],yshld[11]);
 230   sC1->SetVertex(2,xshld[ 0],yshld[ 0]);
 231   sC1->SetVertex(3,xshld[23],yshld[23]);
 232
 233   sC2->SetVertex(0,xshld[11],yshld[11]);
 234   sC2->SetVertex(1,xshld[10],yshld[10]);
 235   sC2->SetVertex(2,xshld[ 1],yshld[ 1]);
 236   sC2->SetVertex(3,xshld[ 0],yshld[ 0]);
 237
 238   // Drawings give only the radius, convert it to the apothegm
 239   Double_t kInnerRadiusCone = TMath::Sqrt(kInnerRadialCone*kInnerRadialCone
 240                                           - 0.25*kInnerACone*kInnerACone);
 241   Double_t kOuterRadiusCone = TMath::Sqrt(kOuterRadialCone*kOuterRadialCone
 242                                           - 0.25*kOuterACone*kOuterACone);
 243
 244   Double_t xco[4], yco[4], xci[4], yci[4];
 245
 246   for (Int_t i=0; i<2; i++) {
 247     Double_t th = i*kTheta*TMath::RadToDeg();
 248     xco[2*i  ] = kOuterRadiusCone*SinD(th) - 0.5*kOuterACone*CosD(th);
 249     yco[2*i  ] = kOuterRadiusCone*CosD(th) + 0.5*kOuterACone*SinD(th);
 250     xci[2*i  ] = kInnerRadiusCone*SinD(th) - 0.5*kInnerACone*CosD(th);
 251     yci[2*i  ] = kInnerRadiusCone*CosD(th) + 0.5*kInnerACone*SinD(th);
 252     xco[2*i+1] = kOuterRadiusCone*SinD(th) + 0.5*kOuterACone*CosD(th);
 253     yco[2*i+1] = kOuterRadiusCone*CosD(th) - 0.5*kOuterACone*SinD(th);
 254     xci[2*i+1] = kInnerRadiusCone*SinD(th) + 0.5*kInnerACone*CosD(th);
 255     yci[2*i+1] = kInnerRadiusCone*CosD(th) - 0.5*kInnerACone*SinD(th);
 256   }
 257
 258   sC1->SetVertex(4,xco[0],yco[0]);
 259   sC1->SetVertex(5,xco[1],yco[1]);
 260   sC1->SetVertex(6,xci[1],yci[1]);
 261   sC1->SetVertex(7,xci[0],yci[0]);
 262
 263   sC2->SetVertex(4,xco[1],yco[1]);
 264   sC2->SetVertex(5,xco[2],yco[2]);
 265   sC2->SetVertex(6,xci[2],yci[2]);
 266   sC2->SetVertex(7,xci[1],yci[1]);
 267
 268   // Air holes
 269   TGeoArb8 *sCh1 = new TGeoArb8(kHalfLengthCone);
 270   TGeoArb8 *sCh2 = new TGeoArb8(kHalfLengthCone);
 271
 272   for(Int_t i=0; i<4; i++){
 273     InsidePoint(sC1->GetVertices()[((i+3)%4)*2+0],
 274                 sC1->GetVertices()[((i+3)%4)*2+1],
 275                 sC1->GetVertices()[i*2+0],
 276                 sC1->GetVertices()[i*2+1],
 277                 sC1->GetVertices()[((i+1)%4)*2+0],
 278                 sC1->GetVertices()[((i+1)%4)*2+1],-kThicknessCone,x,y);
 279     sCh1->SetVertex(i,x,y);
 280
 281     InsidePoint(sC1->GetVertices()[((i+3)%4 +4)*2+0],
 282                 sC1->GetVertices()[((i+3)%4 +4)*2+1],
 283                 sC1->GetVertices()[(i+4)*2+0],
 284                 sC1->GetVertices()[(i+4)*2+1],
 285                 sC1->GetVertices()[((i+1)%4 +4)*2+0],
 286                 sC1->GetVertices()[((i+1)%4 +4)*2+1],-kThicknessCone,x,y);
 287     sCh1->SetVertex(i+4,x,y);
 288
 289     InsidePoint(sC2->GetVertices()[((i+3)%4)*2+0],
 290                 sC2->GetVertices()[((i+3)%4)*2+1],
 291                 sC2->GetVertices()[i*2+0],
 292                 sC2->GetVertices()[i*2+1],
 293                 sC2->GetVertices()[((i+1)%4)*2+0],
 294                 sC2->GetVertices()[((i+1)%4)*2+1],-kThicknessCone,x,y);
 295     sCh2->SetVertex(i,x,y);
 296
 297     InsidePoint(sC2->GetVertices()[((i+3)%4 +4)*2+0],
 298                 sC2->GetVertices()[((i+3)%4 +4)*2+1],
 299                 sC2->GetVertices()[(i+4)*2+0],
 300                 sC2->GetVertices()[(i+4)*2+1],
 301                 sC2->GetVertices()[((i+1)%4 +4)*2+0],
 302                 sC2->GetVertices()[((i+1)%4 +4)*2+1],-kThicknessCone,x,y);
 303     sCh2->SetVertex(i+4,x,y);
 304   }
 305
 306   // Finally the carbon fiber Ring with its Wings and their
 307   // stesalite inserts. They are Tube and TubeSeg shapes
 308
 309   TGeoTube *ringshape = new TGeoTube(kInnerRadiusRing,kOuterRadiusRing,
 310                                      kHalfLengthRing);
 311
 312   TGeoTube *ringinsertshape = new TGeoTube(kInnerRadiusRing+kThicknessRing,
 313                                            kOuterRadiusRing-kThicknessRing,
 314                                            kHalfLengthRing-kThicknessRing);
 315
 316   Double_t angleWideWing, angleWideWingThickness;
 317   angleWideWing = (kWideWing/kOuterRadiusWing)*TMath::RadToDeg();
 318   angleWideWingThickness = (kThicknessRing/kOuterRadiusWing)*TMath::RadToDeg();
 319
 320   TGeoTubeSeg *wingshape = new TGeoTubeSeg(kOuterRadiusRing,kOuterRadiusWing,
 321                                            kHalfLengthRing, 0, angleWideWing);
 322
 323   TGeoTubeSeg *winginsertshape = new TGeoTubeSeg(kOuterRadiusRing,
 324              kOuterRadiusWing-kThicknessRing, kHalfLengthRing-kThicknessRing,
 325              angleWideWingThickness, angleWideWing-angleWideWingThickness);
 326
 327
 328   // We have the shapes: now create the real volumes
 329
 330   TGeoMedium *medSPDcf  = mgr->GetMedium("ITS_SPD shield$");
 331   TGeoMedium *medSPDair = mgr->GetMedium("ITS_SPD AIR$");
 332   TGeoMedium *medSPDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite
 333
 334   TGeoVolume *centralshield = new TGeoVolume("SPDcentralshield",
 335                                              centralshape,medSPDcf);
 336   centralshield->SetVisibility(kTRUE);
 337   centralshield->SetLineColor(7);
 338   centralshield->SetLineWidth(1);
 339
 340   TGeoVolume *centralairshield = new TGeoVolume("SPDcentralairshield",
 341                                                 centralairshape,medSPDair);
 342   centralairshield->SetVisibility(kTRUE);
 343   centralairshield->SetLineColor(5); // Yellow
 344   centralairshield->SetLineWidth(1);
 345   centralairshield->SetFillColor(centralairshield->GetLineColor());
 346   centralairshield->SetFillStyle(4090); // 90% transparent
 347
 348   TGeoVolume *centralomega = new TGeoVolume("SPDcentralomega",
 349                                              centralomegashape,medSPDcf);
 350   centralomega->SetVisibility(kTRUE);
 351   centralomega->SetLineColor(7);
 352   centralomega->SetLineWidth(1);
 353
 354   centralairshield->AddNode(centralomega,1,0);
 355   centralshield->AddNode(centralairshield,1,0);
 356
 357   TGeoVolume *endcapshield = new TGeoVolume("SPDendcapshield",
 358                                              endcapshape,medSPDcf);
 359   endcapshield->SetVisibility(kTRUE);
 360   endcapshield->SetLineColor(7);
 361   endcapshield->SetLineWidth(1);
 362
 363   TGeoVolume *endcapairshield = new TGeoVolume("SPDendcapairshield",
 364                                                 endcapairshape,medSPDair);
 365   endcapairshield->SetVisibility(kTRUE);
 366   endcapairshield->SetLineColor(5); // Yellow
 367   endcapairshield->SetLineWidth(1);
 368   endcapairshield->SetFillColor(endcapairshield->GetLineColor());
 369   endcapairshield->SetFillStyle(4090); // 90% transparent
 370
 371   TGeoVolume *endcapomega = new TGeoVolume("SPDendcapomega",
 372                                            endcapomegashape,medSPDcf);
 373   endcapomega->SetVisibility(kTRUE);
 374   endcapomega->SetLineColor(7);
 375   endcapomega->SetLineWidth(1);
 376
 377   endcapairshield->AddNode(endcapomega,1,0);
 378   endcapshield->AddNode(endcapairshield,1,0);
 379
 380   TGeoVolume *vC1 = new TGeoVolume("SPDconeshieldV1",sC1,medSPDcf);
 381   vC1->SetVisibility(kTRUE);
 382   vC1->SetLineColor(7);
 383   vC1->SetLineWidth(1);
 384
 385   TGeoVolume *vCh1 = new TGeoVolume("SPDconeshieldH1",sCh1,medSPDair);
 386
 387   vCh1->SetVisibility(kTRUE);
 388   vCh1->SetLineColor(5); // Yellow
 389   vCh1->SetLineWidth(1);
 390   vCh1->SetFillColor(vCh1->GetLineColor());
 391   vCh1->SetFillStyle(4090); // 90% transparent
 392
 393   vC1->AddNode(vCh1,1,0);
 394
 395   TGeoVolume *vC2 = new TGeoVolume("SPDconeshieldV2",sC2,medSPDcf);
 396
 397   vC2->SetVisibility(kTRUE);
 398   vC2->SetLineColor(7);
 399   vC2->SetLineWidth(1);
 400
 401   TGeoVolume *vCh2 = new TGeoVolume("SPDconeshieldH2",sCh2,medSPDair);
 402
 403   vCh2->SetVisibility(kTRUE);
 404   vCh2->SetLineColor(5); // Yellow
 405   vCh2->SetLineWidth(1);
 406   vCh2->SetFillColor(vCh2->GetLineColor());
 407   vCh2->SetFillStyle(4090); // 90% transparent
 408
 409   vC2->AddNode(vCh2,1,0);
 410
 411   TGeoVolume *ring = new TGeoVolume("SPDshieldring",ringshape,medSPDcf);
 412   ring->SetVisibility(kTRUE);
 413   ring->SetLineColor(7);
 414   ring->SetLineWidth(1);
 415
 416   TGeoVolume *ringinsert = new TGeoVolume("SPDshieldringinsert",
 417                                           ringinsertshape,medSPDste);
 418   ringinsert->SetVisibility(kTRUE);
 419   ringinsert->SetLineColor(3); // Green
 420 //  ringinsert->SetLineWidth(1);
 421   ringinsert->SetFillColor(ringinsert->GetLineColor());
 422   ringinsert->SetFillStyle(4010); // 10% transparent
 423
 424   ring->AddNode(ringinsert,1,0);
 425
 426   TGeoVolume *wing = new TGeoVolume("SPDshieldringwing",wingshape,medSPDcf);
 427   wing->SetVisibility(kTRUE);
 428   wing->SetLineColor(7);
 429   wing->SetLineWidth(1);
 430
 431   TGeoVolume *winginsert = new TGeoVolume("SPDshieldringinsert",
 432                                           winginsertshape,medSPDste);
 433   winginsert->SetVisibility(kTRUE);
 434   winginsert->SetLineColor(3); // Green
 435 //  winginsert->SetLineWidth(1);
 436   winginsert->SetFillColor(winginsert->GetLineColor());
 437   winginsert->SetFillStyle(4010); // 10% transparent
 438
 439   wing->AddNode(winginsert,1,0);
 440
 441
 442   // Add all volumes in the assembly
 443   vM->AddNode(centralshield,1,0);
 444   vM->AddNode(centralshield,2,new TGeoRotation("",180,0,0));
 445
 446   vM->AddNode(endcapshield,1,
 447               new TGeoTranslation(0,0, kHalfLengthCentral+kHalfLengthEndCap));
 448   vM->AddNode(endcapshield,2,
 449               new TGeoTranslation(0,0,-kHalfLengthCentral-kHalfLengthEndCap));
 450   vM->AddNode(endcapshield,3,new TGeoCombiTrans(
 451               0, 0, kHalfLengthCentral+kHalfLengthEndCap,
 452               new TGeoRotation("",180,0,0)     ) );
 453   vM->AddNode(endcapshield,4,new TGeoCombiTrans(
 454               0, 0,-kHalfLengthCentral-kHalfLengthEndCap,
 455               new TGeoRotation("",180,0,0)     ) );
 456
 457   for (Int_t i=0; i<10; i++) {
 458     Double_t thetaC12 = kTheta*TMath::RadToDeg();
 459     vM->AddNode(vC1,2*i+1, new TGeoCombiTrans(
 460                0, 0,  kHalfLengthCentral+2*kHalfLengthEndCap+kHalfLengthCone,
 461                new TGeoRotation("",0,  0,i*thetaC12)   ) );
 462     vM->AddNode(vC1,2*i+2, new TGeoCombiTrans(
 463                0, 0, -kHalfLengthCentral-2*kHalfLengthEndCap-kHalfLengthCone,
 464                new TGeoRotation("",0,180,i*thetaC12)   ) );
 465     vM->AddNode(vC2,2*i+1, new TGeoCombiTrans(
 466                0, 0,  kHalfLengthCentral+2*kHalfLengthEndCap+kHalfLengthCone,
 467                new TGeoRotation("",0,  0,i*thetaC12)   ) );
 468     vM->AddNode(vC2,2*i+2, new TGeoCombiTrans(
 469                0, 0, -kHalfLengthCentral-2*kHalfLengthEndCap-kHalfLengthCone,
 470                new TGeoRotation("",0,180,i*thetaC12)   ) );
 471   }
 472
 473   vM->AddNode(ring,1,new TGeoTranslation(0, 0,
 474               kHalfLengthCentral+2*kHalfLengthEndCap+2*kHalfLengthCone
 475              +kHalfLengthRing));
 476   vM->AddNode(ring,2,new TGeoTranslation(0, 0,
 477              -kHalfLengthCentral-2*kHalfLengthEndCap-2*kHalfLengthCone
 478              -kHalfLengthRing));
 479
 480   for (Int_t i=0; i<4; i++) {
 481     Double_t thetaW = kThetaWing*(2*i+1) - angleWideWing/2.;
 482     vM->AddNode(wing,2*i+1,new TGeoCombiTrans(0, 0,
 483               kHalfLengthCentral+2*kHalfLengthEndCap+2*kHalfLengthCone
 484              +kHalfLengthRing, new TGeoRotation("",thetaW,0,0)  ));
 485     vM->AddNode(wing,2*i+2,new TGeoCombiTrans(0, 0,
 486              -kHalfLengthCentral-2*kHalfLengthEndCap-2*kHalfLengthCone
 487              -kHalfLengthRing, new TGeoRotation("",thetaW,0,0)  ));
 488   }
 489
 490   // Some debugging if requested
 491   if(GetDebug(1)){
 492     vM->PrintNodes();
 493     vM->InspectShape();
 494   }
 495
 496   // Finally put the entire shield in the mother volume
 497   moth->AddNode(vM,1,0);
 498
 499   return;
 500 }
 501
 502 //______________________________________________________________________
 503 void AliITSv11GeometrySupport::CreateSPDThermalShape(
 504      Double_t ina, Double_t inb, Double_t inr,
 505      Double_t oua, Double_t oub, Double_t our,
 506      Double_t   t, Double_t *x , Double_t *y )
 507 {
 508 //
 509 // Creates the proper sequence of X and Y coordinates to determine
 510 // the base XTru polygon for the SPD thermal shapes
 511 //
 512 // Input:
 513 //        ina, inb : inner shape sides
 514 //        inr      : inner radius
 515 //        oua, oub : outer shape sides
 516 //        our      : outer radius
 517 //        t        : theta angle
 518 //
 519 // Output:
 520 //        x, y : coordinate vectors [24]
 521 //
 522 // Created:      14 Nov 2007  Mario Sitta
 523 // Updated:      11 Dec 2007  Mario Sitta
 524 //
 525   Double_t xlocal[6],ylocal[6];
 526
 527   //Create the first inner quadrant (X > 0)
 528   FillSPDXtruShape(ina,inb,inr,t,xlocal,ylocal);
 529   for (Int_t i=0; i<6; i++) {
 530     x[i] = xlocal[i];
 531     y[i] = ylocal[i];
 532   }
 533
 534   // Then reflex on the second quadrant (X < 0)
 535   for (Int_t i=0; i<6; i++) {
 536     x[23-i] = -x[i];
 537     y[23-i] =  y[i];
 538   }
 539
 540   // Now create the first outer quadrant (X > 0)
 541   FillSPDXtruShape(oua,oub,our,t,xlocal,ylocal);
 542   for (Int_t i=0; i<6; i++) {
 543     x[11-i] = xlocal[i];
 544     y[11-i] = ylocal[i];
 545   }
 546
 547   // Finally reflex on the second quadrant (X < 0)
 548   for (Int_t i=0; i<6; i++) {
 549     x[12+i] = -x[11-i];
 550     y[12+i] =  y[11-i];
 551   }
 552
 553   return;
 554 }
 555
 556 //______________________________________________________________________
 557 void AliITSv11GeometrySupport::CreateSPDOmegaShape(
 558                              Double_t *xin, Double_t *yin, Double_t  d,
 559                              Double_t   *x, Double_t *y)
 560 {
 561 //
 562 // Creates the proper sequence of X and Y coordinates to determine
 563 // the SPD Omega XTru polygon
 564 //
 565 // Input:
 566 //        xin, yin : coordinates of the air volume
 567 //        d        : Omega shape thickness
 568 //        t        : theta angle
 569 //
 570 // Output:
 571 //        x, y     : coordinate vectors [48]
 572 //
 573 // Created:      17 Nov 2007  Mario Sitta
 574 // Updated:      11 Dec 2007  Mario Sitta
 575 // Updated:      20 Feb 2009  Mario Sitta       New algorithm (the old one
 576 //                                              gives erroneous vertexes)
 577 //
 578
 579   // This vector contains the index of those points which coincide
 580   // with the corresponding points in the air shape
 581   Int_t indexAir2Omega[12] = {1, 2, 5, 6, 9, 10, 11, 15, 16, 19, 20, 23};
 582
 583   // First fill those vertexes corresponding to
 584   // the edges aligned to the air shape edges
 585   for (Int_t j=0; j<12; j++) {
 586     x[*(indexAir2Omega+j)] = xin[j];
 587     y[*(indexAir2Omega+j)] = yin[j];
 588   }
 589
 590   // Now get the coordinates of the first inner point
 591   PointFromParallelLines(x[23],y[23],x[1],y[1],d,x[0],y[0]);
 592
 593   // Knowing this, the second internal point can be determined
 594   InsidePoint(x[0],y[0],x[1],y[1],x[2],y[2],d,x[22],y[22]);
 595
 596   // The third point is now computable
 597   ReflectPoint(x[1],y[1],x[2],y[2],x[22],y[22],x[21],y[21]);
 598
 599   // Repeat this logic
 600   InsidePoint(x[21],y[21],x[20],y[20],x[19],y[19],-d,x[3],y[3]);
 601
 602   ReflectPoint(x[20],y[20],x[19],y[19],x[3],y[3],x[4],y[4]);
 603
 604   InsidePoint(x[4],y[4],x[5],y[5],x[6],y[6],d,x[18],y[18]);
 605
 606   ReflectPoint(x[5],y[5],x[6],y[6],x[18],y[18],x[17],y[17]);
 607
 608   InsidePoint(x[17],y[17],x[16],y[16],x[15],y[15],-d,x[7],y[7]);
 609
 610   ReflectPoint(x[16],y[16],x[15],y[15],x[7],y[7],x[8],y[8]);
 611
 612   InsidePoint(x[8],y[8],x[9],y[9],x[10],y[10],d,x[14],y[14]);
 613
 614   // These need to be fixed explicitly
 615   x[12] = x[11];
 616   y[12] = y[11] + d;
 617   x[13] = x[10] + d;
 618   y[13] = y[12];
 619
 620   // Finally reflect on the negative side
 621   for (Int_t i=0; i<24; i++) {
 622     x[24+i] = -x[23-i];
 623     y[24+i] =  y[23-i];
 624   }
 625
 626   // Wow ! We've finished
 627   return;
 628 }
 629
 630 //______________________________________________________________________
 631 void AliITSv11GeometrySupport::FillSPDXtruShape(Double_t a, Double_t b,
 632                                                 Double_t r, Double_t t,
 633                                                 Double_t *x, Double_t *y)
 634 {
 635 //
 636 // Creates the partial sequence of X and Y coordinates to determine
 637 // the lateral part of the SPD thermal shield
 638 //
 639 // Input:
 640 //        a, b : shape sides
 641 //        r    : radius
 642 //        t    : theta angle
 643 //
 644 // Output:
 645 //        x, y : coordinate vectors [6]
 646 //
 647 // Created:      14 Nov 2007  Mario Sitta
 648 //
 649   x[0] = a/2;
 650   y[0] = r;
 651
 652   x[1] = x[0] + b * TMath::Cos(t/2);
 653   y[1] = y[0] - b * TMath::Sin(t/2);
 654
 655   x[2] = x[1] + a * TMath::Cos(t);
 656   y[2] = y[1] - a * TMath::Sin(t);
 657
 658   x[3] = x[2] + b * TMath::Cos(3*t/2);
 659   y[3] = y[2] - b * TMath::Sin(3*t/2);
 660
 661   x[4] = x[3] + a * TMath::Cos(2*t);
 662   y[4] = y[3] - a * TMath::Sin(2*t);
 663
 664   x[5] = x[4];
 665   y[5] = 0.;
 666
 667   return;
 668 }
 669
 670 //______________________________________________________________________
 671 void AliITSv11GeometrySupport::PointFromParallelLines(Double_t x1, Double_t y1,
 672                               Double_t x2, Double_t y2, Double_t d,
 673                               Double_t &x, Double_t &y)
 674 {
 675 //
 676 // Determines the X and Y of the first internal point of the Omega shape
 677 // (i.e. the coordinates of a point given two parallel lines passing by
 678 // two points and placed at a known distance)
 679 //
 680 // Input:
 681 //        x1, y1 : first point
 682 //        x2, y2 : second point
 683 //        d      : distance between the two lines
 684 //
 685 // Output:
 686 //        x, y   : coordinate of the point
 687 //
 688 // Created:      22 Feb 2009  Mario Sitta
 689 //
 690 //Begin_Html
 691 /*
 692 <img src="ITS/doc/PointFromParallelLines.gif">
 693 */
 694 //End_Html
 695
 696   // The slope of the paralles lines at a distance d
 697   Double_t m;
 698
 699   // The parameters of the solving equation
 700   // a x^2 - 2 b x + c = 0
 701   Double_t a = (x1 - x2)*(x1 - x2) - d*d;
 702   Double_t b = (x1 - x2)*(y1 - y2);
 703   Double_t c = (y1 - y2)*(y1 - y2) - d*d;
 704
 705   // (Delta4 is Delta/4 because we use the reduced formula)
 706   Double_t Delta4 = b*b - a*c;
 707
 708   // Compute the slope of the two parallel lines
 709   // (one of the two possible slopes, the one with the smaller
 710   // absolute value is needed)
 711   if (Delta4 < 0) { // Should never happen with our data, but just to be sure
 712     x = -1;         // x is expected positive, so this flags an error
 713     return;
 714   } else
 715     m = (b + TMath::Sqrt(Delta4))/a;  // b is negative with our data
 716
 717   // Finally compute the coordinates of the point
 718   x = x2 + (y1 - y2 - d)/m;
 719   y = y1 - d;
 720
 721   // Done
 722   return;
 723 }
 724
 725 //______________________________________________________________________
 726 void AliITSv11GeometrySupport::ReflectPoint(Double_t x1, Double_t y1,
 727                                             Double_t x2, Double_t y2,
 728                                             Double_t x3, Double_t y3,
 729                                             Double_t &x, Double_t &y)
 730 {
 731 //
 732 // Given two points (x1,y1) and (x2,y2), determines the point (x,y)
 733 // lying on the line parallel to the line passing by these points,
 734 // at a distance d and passing by the point (x3,y3), which is symmetric to
 735 // the third point with respect to the axis of the segment delimited by
 736 // the two first points.
 737 //
 738 // Input:
 739 //        x1, y1 : first point
 740 //        x2, y2 : second point
 741 //        x3, y3 : third point
 742 //        d      : distance between the two lines
 743 //
 744 // Output:
 745 //        x, y   : coordinate of the reflected point
 746 //
 747 // Created:      22 Feb 2009  Mario Sitta
 748 //
 749 //Begin_Html
 750 /*
 751 <img src="ITS/doc/ReflectPoint.gif">
 752 */
 753 //End_Html
 754
 755   // The slope of the line passing by the first two points
 756   Double_t k = (y2 - y1)/(x2 - x1);
 757
 758   // The middle point of the segment 1-2
 759   Double_t xK = (x1 + x2)/2.;
 760   Double_t yK = (y1 + y2)/2.;
 761
 762   // The intercept between the axis of the segment 1-2 and the line
 763   // passing by 3 and parallel to the line passing by 1-2
 764   Double_t xH = (k*k*x3 + k*(yK - y3) + xK)/(k*k + 1);
 765   Double_t yH = k*(xH - x3) + y3;
 766
 767   // The point symmetric to 3 with respect to H
 768   x = 2*xH - x3;
 769   y = 2*yH - y3;
 770
 771   // Done
 772   return;
 773 }
 774
 775 //______________________________________________________________________
 776 void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
 777 {
 778 //
 779 // Creates the SDD support cone and cylinder geometry as a
 780 // volume assembly and adds it to the mother volume
 781 // (part of this code is taken or anyway inspired to SDDCone method
 782 // of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
 783 //
 784 // Input:
 785 //         moth : the TGeoVolume owing the volume structure
 786 //         mgr  : the GeoManager (default gGeoManager)
 787 // Output:
 788 //
 789 // Created:         ???       Bjorn S. Nilsen
 790 // Updated:      18 Feb 2008  Mario Sitta
 791 // Updated:      25 Jul 2008  Mario Sitta   SDDCarbonFiberCone simpler
 792 //
 793 // Technical data are taken from:  "Supporto Generale Settore SDD"
 794 // (technical drawings ALR-0816/1-B), "Supporto Globale Settore SDD"
 795 // (technical drawings ALR-0816/2A, ALR-0816/2B, ALR-0816/2C, ALR-0816/2D),
 796 // private communication with B. Giraudo
 797
 798   // Dimensions of the Central cylinder and flanges
 799   const Double_t kCylinderHalfLength = (790.0/2)*fgkmm;
 800   const Double_t kCylinderInnerR     = (210.0/2)*fgkmm;
 801   const Double_t kCylinderOuterR     = (231.0/2)*fgkmm;
 802   const Double_t kFlangeHalfLength   = ( 15.0/2)*fgkmm;
 803   const Double_t kFlangeInnerR       = (210.5/2)*fgkmm;
 804   const Double_t kFlangeOuterR       = (230.5/2)*fgkmm;
 805   const Double_t kInsertoHalfLength  =
 806                                      kCylinderHalfLength - 2*kFlangeHalfLength;
 807 //  const Double_t kCFThickness        = kFlangeInnerR - kCylinderInnerR;
 808   const Double_t kBoltDiameter       =       6.0*fgkmm; // M6 screw
 809   const Double_t kBoltDepth          =       6.0*fgkmm; // In the flange
 810   const Double_t kBoltRadius         = (220.0/2)*fgkmm; // Radius in flange
 811   const Double_t kThetaBolt          =      30.0*fgkDegree;
 812   const Int_t    kNBolts             = (Int_t)(360.0/kThetaBolt);
 813   // Dimensions of the Cone
 814   const Double_t kConeROutMin        = (540.0/2)*fgkmm;
 815   const Double_t kConeROutMax        = (560.0/2)*fgkmm;
 816   const Double_t kConeRCurv          =      10.0*fgkmm; // Radius of curvature
 817   const Double_t kConeRinMin         = (210.0/2)*fgkmm;
 818 //  const Double_t kConeRinMax         = (216.0/2)*fgkmm;
 819   const Double_t kConeRinCylinder    = (231.0/2)*fgkmm;
 820   const Double_t kConeZCylinder      =     192.0*fgkmm;
 821   const Double_t kConeZOuterMilled   =      23.0*fgkmm;
 822   const Double_t kConeDZin           =      15.0*fgkmm; // ???
 823   const Double_t kConeThickness      =      10.0*fgkmm; // Rohacell + Carb.Fib.
 824   const Double_t kConeTheta          =      45.0*fgkDegree; // SDD cone angle
 825   const Double_t kSinConeTheta       =
 826                                      TMath::Sin(kConeTheta*TMath::DegToRad());
 827   const Double_t kCosConeTheta       =
 828                                      TMath::Cos(kConeTheta*TMath::DegToRad());
 829   const Double_t kTanConeTheta       =
 830                                      TMath::Tan(kConeTheta*TMath::DegToRad());
 831   // Dimensions of the Cone Inserts
 832   const Double_t kConeCFThickness       = 1.5*fgkmm; // Carbon fiber thickness
 833   // Dimensions of the Cone Holes
 834   const Double_t kHole1RMin          = (450.0/2)*fgkmm;
 835   const Double_t kHole1RMax          = (530.0/2)*fgkmm;
 836   const Double_t kHole2RMin          = (280.0/2)*fgkmm;
 837   const Double_t kHole2RMax          = (375.0/2)*fgkmm;
 838   const Double_t kHole1Phi           =      25.0*fgkDegree;
 839   const Double_t kHole2Phi           =      50.0*fgkDegree;
 840   const Double_t kHole3RMin          =     205.0*fgkmm;
 841   const Double_t kHole3DeltaR        =        15*fgkmm;
 842   const Double_t kHole3Width         =        30*fgkmm;
 843   const Int_t    kNHole3             =         6      ;
 844   const Double_t kHole4RMin          =     116.0*fgkmm;
 845   const Double_t kHole4DeltaR        =        15*fgkmm;
 846   const Double_t kHole4Width         =        30*fgkmm;
 847   //  const Int_t    kNHole4             =         3      ;
 848
 849   // Local variables
 850   Double_t x, y, z, t, dza, rmin, rmax;
 851
 852
 853   // Recover the needed materials
 854   TGeoMedium *medSDDcf  = mgr->GetMedium("ITS_SDD C (M55J)$");
 855   TGeoMedium *medSDDair = mgr->GetMedium("ITS_SDD AIR$");
 856   TGeoMedium *medSDDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite
 857   TGeoMedium *medSDDroh = mgr->GetMedium("ITS_ROHACELL$");
 858   TGeoMedium *medSDDss  = mgr->GetMedium("ITS_INOX$");
 859
 860   // First define the geometrical shapes
 861
 862   // Central cylinder with its internal foam and the lateral flanges:
 863   // a carbon fiber Tube which contains a rohacell Tube and two
 864   // stesalite Tube's
 865   TGeoTube *cylindershape = new TGeoTube(kCylinderInnerR,kCylinderOuterR,
 866                                          kCylinderHalfLength);
 867
 868   TGeoTube *insertoshape = new TGeoTube(kFlangeInnerR,kFlangeOuterR,
 869                                         kInsertoHalfLength);
 870
 871   TGeoTube *flangeshape = new TGeoTube(kFlangeInnerR,kFlangeOuterR,
 872                                        kFlangeHalfLength);
 873
 874   // The flange bolt: it is a Tube
 875   TGeoTube *boltshape = new TGeoTube(0.0, 0.5*kBoltDiameter, 0.5*kBoltDepth);
 876
 877   // Debug if requested
 878   if (GetDebug(1)) {
 879     cylindershape->InspectShape();
 880     insertoshape->InspectShape();
 881     flangeshape->InspectShape();
 882     boltshape->InspectShape();
 883   }
 884
 885
 886   // We have the shapes: now create the real volumes
 887
 888   TGeoVolume *cfcylinder = new TGeoVolume("SDDCarbonFiberCylinder",
 889                                           cylindershape,medSDDcf);
 890   cfcylinder->SetVisibility(kTRUE);
 891   cfcylinder->SetLineColor(4); // Blue
 892   cfcylinder->SetLineWidth(1);
 893   cfcylinder->SetFillColor(cfcylinder->GetLineColor());
 894   cfcylinder->SetFillStyle(4000); // 0% transparent
 895
 896   TGeoVolume *foamcylinder = new TGeoVolume("SDDFoamCylinder",
 897                                             insertoshape,medSDDroh);
 898   foamcylinder->SetVisibility(kTRUE);
 899   foamcylinder->SetLineColor(3); // Green
 900   foamcylinder->SetLineWidth(1);
 901   foamcylinder->SetFillColor(foamcylinder->GetLineColor());
 902   foamcylinder->SetFillStyle(4050); // 50% transparent
 903
 904   TGeoVolume *flangecylinder = new TGeoVolume("SDDFlangeCylinder",
 905                                               flangeshape,medSDDste);
 906   flangecylinder->SetVisibility(kTRUE);
 907   flangecylinder->SetLineColor(2); // Red
 908   flangecylinder->SetLineWidth(1);
 909   flangecylinder->SetFillColor(flangecylinder->GetLineColor());
 910   flangecylinder->SetFillStyle(4050); // 50% transparent
 911
 912   TGeoVolume *bolt = new TGeoVolume("SDDFlangeBolt",boltshape,medSDDss);
 913   bolt->SetVisibility(kTRUE);
 914   bolt->SetLineColor(1);  // Black
 915   bolt->SetLineWidth(1);
 916   bolt->SetFillColor(bolt->GetLineColor());
 917   bolt->SetFillStyle(4050); // 50% transparent
 918
 919   // Mount up the cylinder
 920   for(Int_t i=0; i<kNBolts; i++){
 921     t = kThetaBolt*i;
 922     x = kBoltRadius*TMath::Cos(t);
 923     y = kBoltRadius*TMath::Sin(t);
 924     z = kFlangeHalfLength-kBoltDepth;
 925     flangecylinder->AddNode(bolt, i+1, new TGeoTranslation("",x,y,z));
 926   }
 927
 928   cfcylinder->AddNode(foamcylinder,1,0);
 929   cfcylinder->AddNode(flangecylinder,1,
 930               new TGeoTranslation(0, 0, kInsertoHalfLength+kFlangeHalfLength));
 931   cfcylinder->AddNode(flangecylinder,2,new TGeoCombiTrans(
 932               0, 0, -kInsertoHalfLength-kFlangeHalfLength,
 933               new TGeoRotation("",0,180,0)     ) );
 934
 935
 936   // SDD Support Cone with its internal inserts: a carbon fiber Pcon
 937   // with holes which contains a stesalite Pcon which on turn contains a
 938   // rohacell Pcon
 939
 940   dza = kConeThickness/kSinConeTheta-(kConeROutMax-kConeROutMin)/kTanConeTheta;
 941
 942   TGeoPcon *coneshape = new TGeoPcon(0.0, 360.0, 10);
 943
 944   coneshape->Z(0)     = 0.0;
 945   coneshape->Rmin(0)  = kConeROutMin;
 946   coneshape->Rmax(0)  = kConeROutMax;
 947
 948   coneshape->Z(1)     = kConeZOuterMilled - dza;
 949   coneshape->Rmin(1)  = coneshape->GetRmin(0);
 950   coneshape->Rmax(1)  = coneshape->GetRmax(0);
 951
 952   coneshape->Z(2)     = kConeZOuterMilled;
 953   coneshape->Rmax(2)  = coneshape->GetRmax(0);
 954
 955   RadiusOfCurvature(kConeRCurv,0.,coneshape->GetZ(1),
 956                     coneshape->GetRmin(1),kConeTheta,z,rmin);
 957   coneshape->Z(3)     = z;
 958   coneshape->Rmin(3)  = rmin;
 959
 960   coneshape->Rmin(2)  = RminFrom2Points(coneshape,3,1,coneshape->GetZ(2));
 961
 962   RadiusOfCurvature(kConeRCurv,0.,coneshape->GetZ(2),
 963                     coneshape->GetRmax(2),kConeTheta,z,rmax);
 964   coneshape->Z(4)     = z;
 965   coneshape->Rmax(4)  = rmax;
 966   coneshape->Rmin(4)  = RminFromZpCone(coneshape,3,kConeTheta,
 967                                        coneshape->GetZ(4),0.0);
 968
 969   coneshape->Rmax(3)  = RmaxFrom2Points(coneshape,4,2,coneshape->GetZ(3));
 970
 971   coneshape->Z(6)     = kConeZCylinder - kConeDZin;
 972
 973   RadiusOfCurvature(kConeRCurv,90.0,coneshape->GetZ(6),0.0,
 974                     90.0-kConeTheta,z,rmin);
 975   coneshape->Z(5)     = z;
 976   coneshape->Rmin(5)  = RminFromZpCone(coneshape,3,kConeTheta,z);
 977   coneshape->Rmax(5)  = RmaxFromZpCone(coneshape,4,kConeTheta,z);
 978
 979   RadiusOfCurvature(kConeRCurv,90.-kConeTheta,
 980                     0.0,coneshape->Rmin(5),90.0,z,rmin);
 981   coneshape->Rmin(6)  = rmin;
 982   coneshape->Rmax(6)  = RmaxFromZpCone(coneshape,4,kConeTheta,
 983                                        coneshape->GetZ(6));
 984
 985   coneshape->Z(7)     = coneshape->GetZ(6);
 986   coneshape->Rmin(7)  = kConeRinMin;
 987   coneshape->Rmax(7)  = coneshape->GetRmax(6);
 988
 989   coneshape->Rmin(8)  = kConeRinMin;
 990
 991   RadiusOfCurvature(kConeRCurv,90.0,kConeZCylinder,kConeRinCylinder,
 992                     90.0-kConeTheta,z,rmax);
 993   coneshape->Z(8)     = z;
 994   coneshape->Rmax(8)  = rmax;
 995
 996   coneshape->Z(9)     = kConeZCylinder;
 997   coneshape->Rmin(9)  = kConeRinMin;
 998   coneshape->Rmax(9)  = kConeRinCylinder;
 999
1000
1001   // SDD Cone Insert: another Pcon
1002   Double_t x0, y0, x1, y1, x2, y2;
1003   TGeoPcon *coneinsertshape = new TGeoPcon(0.0, 360.0, 9);
1004
1005   coneinsertshape->Z(0)    = coneshape->GetZ(0) + kConeCFThickness;
1006   coneinsertshape->Rmin(0) = coneshape->GetRmin(0) + kConeCFThickness;
1007   coneinsertshape->Rmax(0) = coneshape->GetRmax(0) - kConeCFThickness;
1008
1009   x0 = coneshape->GetZ(0); y0 = coneshape->GetRmin(0);
1010   x1 = coneshape->GetZ(1); y1 = coneshape->GetRmin(1);
1011   x2 = coneshape->GetZ(2); y2 = coneshape->GetRmin(2);
1012   InsidePoint(x0, y0, x1, y1, x2, y2,  kConeCFThickness, z, rmin);
1013   coneinsertshape->Z(1)    = z;
1014   coneinsertshape->Rmin(1) = rmin;
1015   coneinsertshape->Rmax(1) = coneinsertshape->GetRmax(0);
1016
1017   x0 = coneshape->GetZ(1); y0 = coneshape->GetRmax(1);
1018   x1 = coneshape->GetZ(2); y1 = coneshape->GetRmax(2);
1019   x2 = coneshape->GetZ(3); y2 = coneshape->GetRmax(3);
1020   InsidePoint(x0, y0, x1, y1, x2, y2, -kConeCFThickness, z, rmax);
1021   coneinsertshape->Z(2)    = z;
1022   coneinsertshape->Rmax(2) = rmax;
1023
1024   x0 = coneshape->GetZ(2); y0 = coneshape->GetRmin(2);
1025   x1 = coneshape->GetZ(3); y1 = coneshape->GetRmin(3);
1026   x2 = coneshape->GetZ(4); y2 = coneshape->GetRmin(4);
1027   InsidePoint(x0, y0, x1, y1, x2, y2,  kConeCFThickness, z, rmin);
1028   coneinsertshape->Z(3)    = z;
1029   coneinsertshape->Rmin(3) = rmin;
1030
1031   x0 = coneinsertshape->GetZ(1); y0 = coneinsertshape->GetRmin(1);
1032   x1 = coneinsertshape->GetZ(3); y1 = coneinsertshape->GetRmin(3);
1033   coneinsertshape->Rmin(2) = Yfrom2Points(x0, y0, x1, y1,
1034                                           coneinsertshape->Z(2));
1035
1036   x0 = coneshape->GetZ(3); y0 = coneshape->GetRmax(3);
1037   x1 = coneshape->GetZ(4); y1 = coneshape->GetRmax(4);
1038   x2 = coneshape->GetZ(5); y2 = coneshape->GetRmax(5);
1039   InsidePoint(x0, y0, x1, y1, x2, y2, -kConeCFThickness, z, rmax);
1040   coneinsertshape->Z(4)    = z;
1041   coneinsertshape->Rmax(4) = rmax;
1042
1043   x0 = coneinsertshape->GetZ(2); y0 = coneinsertshape->GetRmax(2);
1044   x1 = coneinsertshape->GetZ(4); y1 = coneinsertshape->GetRmax(4);
1045   coneinsertshape->Rmax(3) = Yfrom2Points(x0, y0, x1, y1,
1046                                           coneinsertshape->Z(3));
1047
1048   x0 = coneshape->GetZ(4); y0 = coneshape->GetRmin(4);
1049   x1 = coneshape->GetZ(5); y1 = coneshape->GetRmin(5);
1050   x2 = coneshape->GetZ(6); y2 = coneshape->GetRmin(6);
1051   InsidePoint(x0, y0, x1, y1, x2, y2,  kConeCFThickness, z, rmin);
1052   coneinsertshape->Z(5)    = z;
1053   coneinsertshape->Rmin(5) = rmin;
1054   coneinsertshape->Rmax(5) = coneinsertshape->GetRmax(4) -
1055           kTanConeTheta*(coneinsertshape->GetZ(5) - coneinsertshape->GetZ(4));
1056
1057   x0 = coneinsertshape->GetZ(3); y0 = coneinsertshape->GetRmin(3);
1058   x1 = coneinsertshape->GetZ(5); y1 = coneinsertshape->GetRmin(5);
1059   coneinsertshape->Rmin(4) = Yfrom2Points(x0, y0, x1, y1,
1060                                           coneinsertshape->Z(4));
1061
1062   x0 = coneshape->GetZ(5); y0 = coneshape->GetRmin(5);
1063   x1 = coneshape->GetZ(6); y1 = coneshape->GetRmin(6);
1064   x2 = coneshape->GetZ(7); y2 = coneshape->GetRmin(7);
1065   InsidePoint(x0, y0, x1, y1, x2, y2,  kConeCFThickness, z, rmin);
1066   coneinsertshape->Z(6)    = z;
1067   coneinsertshape->Rmin(6) = rmin;
1068   coneinsertshape->Rmax(6) = coneinsertshape->GetRmax(4) -
1069           kTanConeTheta*(coneinsertshape->GetZ(6) - coneinsertshape->GetZ(4));
1070
1071   coneinsertshape->Z(7)    = coneinsertshape->GetZ(6);
1072   coneinsertshape->Rmin(7) = coneshape->GetRmin(7) + kConeCFThickness;
1073   coneinsertshape->Rmax(7) = coneinsertshape->GetRmax(6);
1074
1075   coneinsertshape->Z(8)    = coneshape->GetZ(9) - kConeCFThickness;
1076   coneinsertshape->Rmin(8) = coneinsertshape->GetRmin(7);
1077   coneinsertshape->Rmax(8) = coneinsertshape->GetRmax(4) -
1078           kTanConeTheta*(coneinsertshape->GetZ(8) - coneinsertshape->GetZ(4));
1079
1080   // SDD Cone Foam: another Pcon
1081   TGeoPcon *conefoamshape = new TGeoPcon(0.0, 360.0, 4);
1082
1083   RadiusOfCurvature(kConeRCurv+kConeCFThickness,0.0,coneinsertshape->GetZ(1),
1084                     coneinsertshape->GetRmin(1),kConeTheta,z,rmin);
1085
1086   conefoamshape->Z(0)    = z;
1087   conefoamshape->Rmin(0) = rmin;
1088   conefoamshape->Rmax(0) = conefoamshape->GetRmin(0);
1089
1090   conefoamshape->Z(1)    = conefoamshape->GetZ(0)+
1091                          (kConeThickness-2.0*kConeCFThickness)/kSinConeTheta;
1092   conefoamshape->Rmin(1) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1093                                           conefoamshape->GetZ(1));
1094   conefoamshape->Rmax(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1095                                           conefoamshape->GetZ(1));
1096
1097   conefoamshape->Z(2)    = coneshape->GetZ(5)-kConeCFThickness;
1098   conefoamshape->Rmin(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1099                                           conefoamshape->GetZ(2));
1100   conefoamshape->Rmax(2) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1101                                           conefoamshape->GetZ(2));
1102
1103   conefoamshape->Z(3)    = coneinsertshape->GetZ(5)+
1104                          (kConeThickness-2.0*kConeCFThickness)*kCosConeTheta;
1105   conefoamshape->Rmax(3) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1106                                           conefoamshape->GetZ(3));
1107   conefoamshape->Rmin(3) = conefoamshape->GetRmax(3);
1108
1109   // SDD Cone Holes: Pcon's
1110   // A single hole volume gives an overlap with coneinsert, so
1111   // three contiguous volumes are created: one to be put in the cone foam
1112   // and two in the cone carbon fiber envelope
1113   TGeoPcon *hole1shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1114
1115   hole1shape->Rmin(0) = kHole1RMax;
1116   hole1shape->Rmax(0) = hole1shape->GetRmin(0);
1117   hole1shape->Z(0)    = ZFromRminpCone(conefoamshape,0,kConeTheta,
1118                                        hole1shape->GetRmin(0));
1119
1120   hole1shape->Rmax(1) = hole1shape->GetRmax(0);
1121   hole1shape->Z(1)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
1122                                        hole1shape->GetRmax(1));
1123   hole1shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
1124                                        hole1shape->GetZ(1));
1125
1126   hole1shape->Rmin(2) = kHole1RMin;
1127   hole1shape->Z(2)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
1128                                        hole1shape->GetRmin(2));
1129   hole1shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
1130                                        hole1shape->GetZ(2));
1131
1132   hole1shape->Rmin(3) = hole1shape->GetRmin(2);
1133   hole1shape->Rmax(3) = hole1shape->GetRmin(3);
1134   hole1shape->Z(3)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
1135                                        hole1shape->GetRmax(3));
1136
1137   TGeoPcon *hole11shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1138
1139   hole11shape->Rmin(0) = kHole1RMax;
1140   hole11shape->Rmax(0) = hole11shape->GetRmin(0);
1141   hole11shape->Z(0)    = ZFromRminpCone(coneshape,3,kConeTheta,
1142                                         hole11shape->GetRmin(0));
1143
1144   hole11shape->Rmax(1) = hole11shape->GetRmax(0);
1145   hole11shape->Z(1)    = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1146                                         hole11shape->GetRmax(1));
1147   hole11shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
1148                                         hole11shape->GetZ(1));
1149
1150   hole11shape->Rmin(2) = kHole1RMin;
1151   hole11shape->Z(2)    = ZFromRminpCone(coneshape,3,kConeTheta,
1152                                         hole11shape->GetRmin(2));
1153   hole11shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1154                                         hole11shape->GetZ(2));
1155
1156   hole11shape->Rmin(3) = hole11shape->GetRmin(2);
1157   hole11shape->Rmax(3) = hole11shape->GetRmin(3);
1158   hole11shape->Z(3)    = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1159                                         hole11shape->GetRmax(3));
1160
1161   TGeoPcon *hole12shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1162
1163   hole12shape->Rmin(0) = kHole1RMax;
1164   hole12shape->Rmax(0) = hole12shape->GetRmin(0);
1165   hole12shape->Z(0)    = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1166                                         hole12shape->GetRmin(0));
1167
1168   hole12shape->Rmax(1) = hole12shape->GetRmax(0);
1169   hole12shape->Z(1)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
1170                                         hole12shape->GetRmax(1));
1171   hole12shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1172                                         hole12shape->GetZ(1));
1173
1174   hole12shape->Rmin(2) = kHole1RMin;
1175   hole12shape->Z(2)    = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1176                                         hole12shape->GetRmin(2));
1177   hole12shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
1178                                         hole12shape->GetZ(2));
1179
1180   hole12shape->Rmin(3) = hole12shape->GetRmin(2);
1181   hole12shape->Rmax(3) = hole12shape->GetRmin(3);
1182   hole12shape->Z(3)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
1183                                         hole12shape->GetRmax(3));
1184
1185   //
1186   TGeoPcon *hole2shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
1187
1188   hole2shape->Rmin(0) = kHole2RMax;
1189   hole2shape->Rmax(0) = hole2shape->GetRmin(0);
1190   hole2shape->Z(0)    = ZFromRminpCone(conefoamshape,0,kConeTheta,
1191                                        hole2shape->GetRmin(0));
1192
1193   hole2shape->Rmax(1) = hole2shape->GetRmax(0);
1194   hole2shape->Z(1)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
1195                                        hole2shape->GetRmax(1));
1196   hole2shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
1197                                        hole2shape->GetZ(1));
1198
1199   hole2shape->Rmin(2) = kHole2RMin;
1200   hole2shape->Z(2)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
1201                                        hole2shape->GetRmin(2));
1202   hole2shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
1203                                        hole2shape->GetZ(2));
1204
1205   hole2shape->Rmin(3) = hole2shape->GetRmin(2);
1206   hole2shape->Rmax(3) = hole2shape->GetRmin(3);
1207   hole2shape->Z(3)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
1208                                        hole2shape->GetRmax(3));
1209
1210   TGeoPcon *hole21shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
1211
1212   hole21shape->Rmin(0) = kHole2RMax;
1213   hole21shape->Rmax(0) = hole21shape->GetRmin(0);
1214   hole21shape->Z(0)    = ZFromRminpCone(coneshape,3,kConeTheta,
1215                                         hole21shape->GetRmin(0));
1216
1217   hole21shape->Rmax(1) = hole21shape->GetRmax(0);
1218   hole21shape->Z(1)    = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1219                                         hole21shape->GetRmax(1));
1220   hole21shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
1221                                         hole21shape->GetZ(1));
1222
1223   hole21shape->Rmin(2) = kHole2RMin;
1224   hole21shape->Z(2)    = ZFromRminpCone(coneshape,3,kConeTheta,
1225                                         hole21shape->GetRmin(2));
1226   hole21shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1227                                         hole21shape->GetZ(2));
1228
1229   hole21shape->Rmin(3) = hole21shape->GetRmin(2);
1230   hole21shape->Rmax(3) = hole21shape->GetRmin(3);
1231   hole21shape->Z(3)    = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1232                                         hole21shape->GetRmax(3));
1233
1234   TGeoPcon *hole22shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
1235
1236   hole22shape->Rmin(0) = kHole2RMax;
1237   hole22shape->Rmax(0) = hole22shape->GetRmin(0);
1238   hole22shape->Z(0)    = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1239                                         hole22shape->GetRmin(0));
1240
1241   hole22shape->Rmax(1) = hole22shape->GetRmax(0);
1242   hole22shape->Z(1)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
1243                                         hole22shape->GetRmax(1));
1244   hole22shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1245                                         hole22shape->GetZ(1));
1246
1247   hole22shape->Rmin(2) = kHole2RMin;
1248   hole22shape->Z(2)    = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1249                                         hole22shape->GetRmin(2));
1250   hole22shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
1251                                         hole22shape->GetZ(2));
1252
1253   hole22shape->Rmin(3) = hole22shape->GetRmin(2);
1254   hole22shape->Rmax(3) = hole22shape->GetRmin(3);
1255   hole22shape->Z(3)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
1256                                         hole22shape->GetRmax(3));
1257
1258   //
1259   Double_t holePhi;
1260   holePhi = (kHole3Width/kHole3RMin)*TMath::RadToDeg();
1261
1262   TGeoPcon *hole3shape = new TGeoPcon(-holePhi/2., holePhi, 4);
1263
1264   hole3shape->Rmin(0) = kHole3RMin + kHole3DeltaR;
1265   hole3shape->Rmax(0) = hole3shape->GetRmin(0);
1266   hole3shape->Z(0)    = ZFromRminpCone(conefoamshape,0,kConeTheta,
1267                                        hole3shape->GetRmin(0));
1268
1269   hole3shape->Rmax(1) = hole3shape->GetRmax(0);
1270   hole3shape->Z(1)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
1271                                        hole3shape->GetRmax(1));
1272   hole3shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
1273                                        hole3shape->GetZ(1));
1274
1275   hole3shape->Rmin(2) = kHole3RMin;
1276   hole3shape->Z(2)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
1277                                        hole3shape->GetRmin(2));
1278   hole3shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
1279                                        hole3shape->GetZ(2));
1280
1281   hole3shape->Rmin(3) = hole3shape->GetRmin(2);
1282   hole3shape->Rmax(3) = hole3shape->GetRmin(3);
1283   hole3shape->Z(3)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
1284                                        hole3shape->GetRmax(3));
1285
1286   TGeoPcon *hole31shape = new TGeoPcon(-holePhi/2., holePhi, 4);
1287
1288   hole31shape->Rmin(0) = kHole3RMin + kHole3DeltaR;
1289   hole31shape->Rmax(0) = hole31shape->GetRmin(0);
1290   hole31shape->Z(0)    = ZFromRminpCone(coneshape,3,kConeTheta,
1291                                         hole31shape->GetRmin(0));
1292
1293   hole31shape->Rmax(1) = hole31shape->GetRmax(0);
1294   hole31shape->Z(1)    = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1295                                         hole31shape->GetRmax(1));
1296   hole31shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
1297                                         hole31shape->GetZ(1));
1298
1299   hole31shape->Rmin(2) = kHole3RMin;
1300   hole31shape->Z(2)    = ZFromRminpCone(coneshape,3,kConeTheta,
1301                                         hole31shape->GetRmin(2));
1302   hole31shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1303                                         hole31shape->GetZ(2));
1304
1305   hole31shape->Rmin(3) = hole31shape->GetRmin(2);
1306   hole31shape->Rmax(3) = hole31shape->GetRmin(3);
1307   hole31shape->Z(3)    = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1308                                         hole31shape->GetRmax(3));
1309
1310   TGeoPcon *hole32shape = new TGeoPcon(-holePhi/2., holePhi, 4);
1311
1312   hole32shape->Rmin(0) = kHole3RMin + kHole3DeltaR;
1313   hole32shape->Rmax(0) = hole32shape->GetRmin(0);
1314   hole32shape->Z(0)    = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1315                                         hole32shape->GetRmin(0));
1316
1317   hole32shape->Rmax(1) = hole32shape->GetRmax(0);
1318   hole32shape->Z(1)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
1319                                         hole32shape->GetRmax(1));
1320   hole32shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1321                                         hole32shape->GetZ(1));
1322
1323   hole32shape->Rmin(2) = kHole3RMin;
1324   hole32shape->Z(2)    = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1325                                         hole32shape->GetRmin(2));
1326   hole32shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
1327                                         hole32shape->GetZ(2));
1328
1329   hole32shape->Rmin(3) = hole32shape->GetRmin(2);
1330   hole32shape->Rmax(3) = hole32shape->GetRmin(3);
1331   hole32shape->Z(3)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
1332                                         hole32shape->GetRmax(3));
1333
1334   //
1335   holePhi = (kHole4Width/kHole4RMin)*TMath::RadToDeg();
1336
1337   TGeoPcon *hole4shape = new TGeoPcon(-holePhi/2., holePhi, 4);
1338
1339   hole4shape->Rmin(0) = kHole4RMin + kHole4DeltaR;
1340   hole4shape->Rmax(0) = hole4shape->GetRmin(0);
1341   hole4shape->Z(0)    = ZFromRminpCone(coneshape,3,kConeTheta,
1342                                        hole4shape->GetRmin(0));
1343
1344   hole4shape->Rmax(1) = hole4shape->GetRmax(0);
1345   hole4shape->Z(1)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
1346                                        hole4shape->GetRmax(1));
1347   hole4shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
1348                                        hole4shape->GetZ(1));
1349
1350   hole4shape->Rmin(2) = kHole4RMin;
1351   hole4shape->Z(2)    = ZFromRminpCone(coneshape,3,kConeTheta,
1352                                        hole4shape->GetRmin(2));
1353   hole4shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
1354                                        hole4shape->GetZ(2));
1355
1356   hole4shape->Rmin(3) = hole4shape->GetRmin(2);
1357   hole4shape->Rmax(3) = hole4shape->GetRmin(3);
1358   hole4shape->Z(3)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
1359                                        hole4shape->GetRmax(3));
1360
1361   // Debug if requested
1362   if (GetDebug(1)) {
1363     coneshape->InspectShape();
1364     coneinsertshape->InspectShape();
1365     conefoamshape->InspectShape();
1366     hole1shape->InspectShape();
1367     hole2shape->InspectShape();
1368     hole3shape->InspectShape();
1369     hole4shape->InspectShape();
1370   }
1371
1372
1373   // We have the shapes: now create the real volumes
1374
1375   TGeoVolume *cfcone = new TGeoVolume("SDDCarbonFiberCone",
1376                                       coneshape,medSDDcf);
1377   cfcone->SetVisibility(kTRUE);
1378   cfcone->SetLineColor(4); // Blue
1379   cfcone->SetLineWidth(1);
1380   cfcone->SetFillColor(cfcone->GetLineColor());
1381   cfcone->SetFillStyle(4000); // 0% transparent
1382
1383   TGeoVolume *cfconeinsert = new TGeoVolume("SDDCarbonFiberConeInsert",
1384                                             coneinsertshape,medSDDste);
1385   cfconeinsert->SetVisibility(kTRUE);
1386   cfconeinsert->SetLineColor(2); // Red
1387   cfconeinsert->SetLineWidth(1);
1388   cfconeinsert->SetFillColor(cfconeinsert->GetLineColor());
1389   cfconeinsert->SetFillStyle(4050); // 50% transparent
1390
1391   TGeoVolume *cfconefoam = new TGeoVolume("SDDCarbonFiberConeFoam",
1392                                           conefoamshape,medSDDroh);
1393   cfconefoam->SetVisibility(kTRUE);
1394   cfconefoam->SetLineColor(7); // Light blue
1395   cfconefoam->SetLineWidth(1);
1396   cfconefoam->SetFillColor(cfconefoam->GetLineColor());
1397   cfconefoam->SetFillStyle(4050); // 50% transparent
1398
1399   TGeoVolume *hole1 = new TGeoVolume("SDDCableHole1",
1400                                      hole1shape,medSDDair);
1401   hole1->SetVisibility(kTRUE);
1402   hole1->SetLineColor(5); // Yellow
1403   hole1->SetLineWidth(1);
1404   hole1->SetFillColor(hole1->GetLineColor());
1405   hole1->SetFillStyle(4090); // 90% transparent
1406
1407   TGeoVolume *hole11 = new TGeoVolume("SDDCableHole11",
1408                                       hole11shape,medSDDair);
1409   hole11->SetVisibility(kTRUE);
1410   hole11->SetLineColor(5); // Yellow
1411   hole11->SetLineWidth(1);
1412   hole11->SetFillColor(hole11->GetLineColor());
1413   hole11->SetFillStyle(4090); // 90% transparent
1414
1415   TGeoVolume *hole12 = new TGeoVolume("SDDCableHole12",
1416                                       hole12shape,medSDDair);
1417   hole12->SetVisibility(kTRUE);
1418   hole12->SetLineColor(5); // Yellow
1419   hole12->SetLineWidth(1);
1420   hole12->SetFillColor(hole12->GetLineColor());
1421   hole12->SetFillStyle(4090); // 90% transparent
1422
1423   TGeoVolume *hole2 = new TGeoVolume("SDDCableHole2",
1424                                      hole2shape,medSDDair);
1425   hole2->SetVisibility(kTRUE);
1426   hole2->SetLineColor(5); // Yellow
1427   hole2->SetLineWidth(1);
1428   hole2->SetFillColor(hole2->GetLineColor());
1429   hole2->SetFillStyle(4090); // 90% transparent
1430
1431   TGeoVolume *hole21 = new TGeoVolume("SDDCableHole21",
1432                                       hole21shape,medSDDair);
1433   hole21->SetVisibility(kTRUE);
1434   hole21->SetLineColor(5); // Yellow
1435   hole21->SetLineWidth(1);
1436   hole21->SetFillColor(hole21->GetLineColor());
1437   hole21->SetFillStyle(4090); // 90% transparent
1438
1439   TGeoVolume *hole22 = new TGeoVolume("SDDCableHole22",
1440                                       hole22shape,medSDDair);
1441   hole22->SetVisibility(kTRUE);
1442   hole22->SetLineColor(5); // Yellow
1443   hole22->SetLineWidth(1);
1444   hole22->SetFillColor(hole22->GetLineColor());
1445   hole22->SetFillStyle(4090); // 90% transparent
1446
1447   TGeoVolume *hole3 = new TGeoVolume("SDDCableHole3",
1448                                      hole3shape,medSDDair);
1449   hole3->SetVisibility(kTRUE);
1450   hole3->SetLineColor(5); // Yellow
1451   hole3->SetLineWidth(1);
1452   hole3->SetFillColor(hole3->GetLineColor());
1453   hole3->SetFillStyle(4090); // 90% transparent
1454
1455   TGeoVolume *hole31 = new TGeoVolume("SDDCableHole31",
1456                                       hole31shape,medSDDair);
1457   hole31->SetVisibility(kTRUE);
1458   hole31->SetLineColor(5); // Yellow
1459   hole31->SetLineWidth(1);
1460   hole31->SetFillColor(hole31->GetLineColor());
1461   hole31->SetFillStyle(4090); // 90% transparent
1462
1463   TGeoVolume *hole32 = new TGeoVolume("SDDCableHole32",
1464                                       hole32shape,medSDDair);
1465   hole32->SetVisibility(kTRUE);
1466   hole32->SetLineColor(5); // Yellow
1467   hole32->SetLineWidth(1);
1468   hole32->SetFillColor(hole32->GetLineColor());
1469   hole32->SetFillStyle(4090); // 90% transparent
1470
1471   TGeoVolume *hole4 = new TGeoVolume("SDDCableHole4",
1472                                      hole4shape,medSDDair);
1473   hole4->SetVisibility(kTRUE);
1474   hole4->SetLineColor(5); // Yellow
1475   hole4->SetLineWidth(1);
1476   hole4->SetFillColor(hole4->GetLineColor());
1477   hole4->SetFillStyle(4090); // 90% transparent
1478
1479   // Mount up a cone
1480   cfconeinsert->AddNode(cfconefoam,1,0);
1481
1482   for (Int_t i=0; i<12; i++) {
1483     Double_t phiH = i*30.0;
1484     cfconefoam->AddNode(hole1 , i+1, new TGeoRotation("", 0, 0, phiH));
1485         cfcone->AddNode(hole11, i+1, new TGeoRotation("", 0, 0, phiH));
1486         cfcone->AddNode(hole12, i+1, new TGeoRotation("", 0, 0, phiH));
1487   }
1488
1489   for (Int_t i=0; i<6; i++) {
1490     Double_t phiH = i*60.0;
1491     cfconefoam->AddNode(hole2 , i+1, new TGeoRotation("", 0, 0, phiH));
1492         cfcone->AddNode(hole21, i+1, new TGeoRotation("", 0, 0, phiH));
1493         cfcone->AddNode(hole22, i+1, new TGeoRotation("", 0, 0, phiH));
1494   }
1495
1496   for (Int_t i=0; i<kNHole3; i++) {
1497     Double_t phiH0 = 360./(Double_t)kNHole3;
1498     Double_t phiH  = i*phiH0 + 0.5*phiH0;
1499     cfconefoam->AddNode(hole3 , i+1, new TGeoRotation("", phiH, 0, 0));
1500         cfcone->AddNode(hole31, i+1, new TGeoRotation("", phiH, 0, 0));
1501         cfcone->AddNode(hole32, i+1, new TGeoRotation("", phiH, 0, 0));
1502   }
1503
1504   cfcone->AddNode(cfconeinsert,1,0);
1505
1506 /*
1507   for (Int_t i=0; i<kNHole4; i++) {
1508     Double_t phiH0 = 360./(Double_t)kNHole4;
1509     Double_t phiH  = i*phiH0 + 0.25*phiH0;
1510     cfcone->AddNode(hole4, i+1, new TGeoRotation("", phiH, 0, 0));
1511   }
1512 */
1513   // Finally put everything in the mother volume
1514   moth->AddNode(cfcylinder,1,0);
1515
1516   z = coneshape->Z(9);
1517   moth->AddNode(cfcone,1,new TGeoTranslation(0, 0, -z - kCylinderHalfLength));
1518   moth->AddNode(cfcone,2,new TGeoCombiTrans (0, 0,  z + kCylinderHalfLength,
1519                          new TGeoRotation("", 0, 180, 0)                   ));
1520
1521
1522   return;
1523 }
1524
1525 //______________________________________________________________________
1526 void AliITSv11GeometrySupport::SSDCone(TGeoVolume *moth,TGeoManager *mgr)
1527 {
1528 //
1529 // Creates the SSD support cone and cylinder geometry. as a
1530 // volume assembly and adds it to the mother volume
1531 // (part of this code is taken or anyway inspired to SSDCone method
1532 // of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
1533 //
1534 // Input:
1535 //         moth : the TGeoVolume owing the volume structure
1536 //         mgr  : the GeoManager (default gGeoManager)
1537 // Output:
1538 //
1539 // Created:         ???       Bjorn S. Nilsen
1540 // Updated:      08 Mar 2008  Mario Sitta
1541 //
1542 // Technical data are taken from:  "ITS Supporto Generale" (technical
1543 // drawings ALR3-0743/1, ALR3-0743/1A and ALR3-0743/1B), "Supporto Generale
1544 // Settore SSD" (technical drawings ALR3-0743/2A and ALR3-0743/2E), private
1545 // communication with B. Giraudo
1546 //
1547 // Updated:      11 Apr 2008  Mario Sitta
1548 // Measures from drawings give overlaps with SPD thermal shield wings,
1549 // so the terminal part of the SSD cone was reduced
1550
1551   // Dimensions of the Central cylinder and flanges
1552   const Double_t kCylinderHalfLength   = (1144.0/2) *fgkmm;
1553   const Double_t kCylinderOuterRadius  = ( 595.0/2) *fgkmm;
1554   const Double_t kCylinderThickness    =        0.6 *fgkmm;
1555   const Double_t kFoamHalfLength       = (1020.0/2) *fgkmm;
1556   const Double_t kFoamThickness        =        5.0 *fgkmm;
1557   const Double_t kFlangeHalfLength     =
1558                                       (kCylinderHalfLength-kFoamHalfLength)/2.;
1559   const Double_t kFlangeInnerRadius    = ( 563.0/2) *fgkmm;
1560   // Dimensions of the Cone
1561   const Double_t kConeROuterMin        = ( 957.0/2) *fgkmm;
1562   const Double_t kConeROuterMax        = ( 997.0/2) *fgkmm;
1563   const Double_t kConeRInnerMin        = ( 564.0/2) *fgkmm;
1564   const Double_t kConeRCurv1           =       10.0 *fgkmm;
1565   const Double_t kConeRCurv2           =       25.0 *fgkmm;
1566   const Double_t kConeCent1RCurv2      = ( 578.0/2) *fgkmm;
1567   const Double_t kConeCent2RCurv2      = ( 592.0/2) *fgkmm;
1568 //  const Double_t kConeZOuterRing       =       47.0 *fgkmm;
1569 //  const Double_t kConeZOuterRingInside =       30.25*fgkmm;
1570 //  const Double_t kConeZInnerRing       =      161.5 *fgkmm;
1571 //  const Double_t kConeZLength          =      176.5 *fgkmm;
1572   const Double_t kConeZOuterRing       =       38.5 *fgkmm;
1573   const Double_t kConeZOuterRingInside =       22.2 *fgkmm;
1574   const Double_t kConeZInnerRing       =      153.0 *fgkmm;
1575   const Double_t kConeZLength          =      168.0 *fgkmm;
1576   const Double_t kConeZPosition        = kConeZLength + kCylinderHalfLength;
1577   const Double_t kConeThickness        =       13.0 *fgkmm; // Cone thickness
1578   const Double_t kConeTheta            =       39.1 *fgkDegree; // Cone angle
1579   const Double_t kSinConeTheta         =
1580                                       TMath::Sin(kConeTheta*TMath::DegToRad());
1581   const Double_t kCosConeTheta         =
1582                                       TMath::Cos(kConeTheta*TMath::DegToRad());
1583   // Dimensions of the Foam cores
1584   const Double_t kConeFoam1Length      =      112.3 *fgkmm;
1585   const Double_t kConeFoam2Length      =       58.4 *fgkmm;
1586   // Dimensions of the Cone Holes
1587   const Double_t kCoolingHoleWidth     =       40.0 *fgkmm;
1588   const Double_t kCoolingHoleHight     =       30.0 *fgkmm;
1589   const Double_t kCoolingHoleRmin      =      350.0 *fgkmm;
1590   const Double_t kCoolingHolePhi       =       45.0 *fgkDegree;
1591   const Double_t kMountingHoleWidth    =       20.0 *fgkmm;
1592   const Double_t kMountingHoleHight    =       20.0 *fgkmm;
1593   const Double_t kMountingHoleRmin     =      317.5 *fgkmm;
1594   const Double_t kMountingHolePhi      =       60.0 *fgkDegree;
1595   const Double_t kCableHoleRin         = ( 800.0/2) *fgkmm;
1596   const Double_t kCableHoleRout        = ( 920.0/2) *fgkmm;
1597   const Double_t kCableHoleWidth       =      200.0 *fgkmm;
1598 //  const Double_t kCableHoleAngle       =       42.0 *fgkDegree;
1599   // Dimensions of the Cone Wings
1600   const Double_t kWingRmax             =      527.5 *fgkmm;
1601   const Double_t kWingWidth            =       70.0 *fgkmm;
1602   const Double_t kWingHalfThick        = (  10.0/2) *fgkmm;
1603   const Double_t kThetaWing            =       45.0 *fgkDegree;
1604   // Dimensions of the SSD-SDD Mounting Brackets
1605   const Double_t kBracketRmin          = ( 541.0/2) *fgkmm;// See SDD ROutMin
1606   const Double_t kBracketRmax          = ( 585.0/2) *fgkmm;
1607   const Double_t kBracketHalfLength    = (   4.0/2) *fgkmm;
1608   const Double_t kBracketPhi           = (70.*fgkmm/kBracketRmax)*fgkRadian;
1609   // Common data
1610   const Double_t kCFThickness          =        0.75*fgkmm; //Carb. fib. thick.
1611
1612
1613   // Local variables
1614   Double_t rmin1, rmin2, rmax, z;
1615
1616   //
1617   //Begin_Html
1618   /*
1619     <img src="picts/ITS/file_name.gif">
1620     <P>
1621     <FONT FACE'"TIMES">
1622     ITS SSD central support and thermal shield cylinder.
1623     </FONT>
1624     </P>
1625   */
1626   //End_Html
1627   //
1628
1629   // Central cylinder with its internal foam and the lateral flanges:
1630   // a carbon fiber Pcon which contains a rohacell Tube and two
1631   // stesalite Cone's
1632   TGeoPcon *externalcylshape = new TGeoPcon(0,360,4);
1633
1634   rmax  = kCylinderOuterRadius;
1635   rmin1 = kFlangeInnerRadius - kCylinderThickness;
1636   rmin2 = rmax - 2*kCylinderThickness - kFoamThickness;
1637   externalcylshape->DefineSection(0,-kCylinderHalfLength,rmin1,rmax);
1638   externalcylshape->DefineSection(1,-kFoamHalfLength    ,rmin2,rmax);
1639   externalcylshape->DefineSection(2, kFoamHalfLength    ,rmin2,rmax);
1640   externalcylshape->DefineSection(3, kCylinderHalfLength,rmin1,rmax);
1641
1642   rmax  = kCylinderOuterRadius - kCylinderThickness;
1643   rmin1 = rmax - kFoamThickness;
1644   TGeoTube *foamshape = new TGeoTube(rmin1,rmax,kFoamHalfLength);
1645
1646   rmax  = kCylinderOuterRadius - kCylinderThickness;
1647   rmin1 = rmax - kFoamThickness;
1648   rmin2 = kFlangeInnerRadius;
1649   TGeoCone *flangeshape = new TGeoCone(kFlangeHalfLength,
1650                                        rmin1,rmax,rmin2,rmax);
1651
1652
1653   // We have the shapes: now create the real volumes
1654
1655   TGeoMedium *medSSDcf  = mgr->GetMedium("ITS_SSD C (M55J)$");
1656   TGeoMedium *medSSDair = mgr->GetMedium("ITS_SSD AIR$");
1657   TGeoMedium *medSSDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite
1658   TGeoMedium *medSSDroh = mgr->GetMedium("ITS_ROHACELL$");
1659   TGeoMedium *medSSDal  = mgr->GetMedium("ITS_ALUMINUM$");
1660
1661   TGeoVolume *cfcylinder = new TGeoVolume("SSDexternalcylinder",
1662                                            externalcylshape,medSSDcf);
1663   cfcylinder->SetVisibility(kTRUE);
1664   cfcylinder->SetLineColor(4); // blue
1665   cfcylinder->SetLineWidth(1);
1666   cfcylinder->SetFillColor(cfcylinder->GetLineColor());
1667   cfcylinder->SetFillStyle(4000); // 0% transparent
1668
1669   TGeoVolume *foamcylinder = new TGeoVolume("SSDfoamcylinder",
1670                                             foamshape,medSSDroh);
1671   foamcylinder->SetVisibility(kTRUE);
1672   foamcylinder->SetLineColor(3); // green
1673   foamcylinder->SetLineWidth(1);
1674   foamcylinder->SetFillColor(foamcylinder->GetLineColor());
1675   foamcylinder->SetFillStyle(4050); // 50% transparent
1676
1677   TGeoVolume *flangecylinder = new TGeoVolume("SSDflangecylinder",
1678                                               flangeshape,medSSDste);
1679   flangecylinder->SetVisibility(kTRUE);
1680   flangecylinder->SetLineColor(2); // red
1681   flangecylinder->SetLineWidth(1);
1682   flangecylinder->SetFillColor(flangecylinder->GetLineColor());
1683   flangecylinder->SetFillStyle(4050); // 50% transparent
1684
1685   // Mount up the cylinder
1686   cfcylinder->AddNode(foamcylinder,1,0);
1687   cfcylinder->AddNode(flangecylinder,1,
1688               new TGeoTranslation(0, 0, kFoamHalfLength+kFlangeHalfLength));
1689   cfcylinder->AddNode(flangecylinder,2,new TGeoCombiTrans(
1690               0, 0, -kFoamHalfLength-kFlangeHalfLength,
1691               new TGeoRotation("",0,180,0)     ) );
1692
1693
1694   // The whole Cone as an assembly
1695   TGeoVolumeAssembly *vC = new TGeoVolumeAssembly("ITSssdCone");
1696
1697
1698   // SSD Support Cone with its internal inserts: a carbon fiber Pcon
1699   // with holes which contains a stesalite Pcon which on turn contains a
1700   // rohacell Pcon
1701   TGeoPcon *coneshape = new TGeoPcon(0.0, 360.0, 12);
1702
1703   coneshape->Z(0)     = 0.0;
1704   coneshape->Rmin(0)  = kConeROuterMin;
1705   coneshape->Rmax(0)  = kConeROuterMax;
1706
1707   coneshape->Z(1)     = kConeZOuterRingInside - kConeRCurv1;
1708   coneshape->Rmin(1)  = coneshape->GetRmin(0);
1709   coneshape->Rmax(1)  = coneshape->GetRmax(0);
1710
1711   coneshape->Z(2)     = kConeZOuterRingInside;
1712   coneshape->Rmin(2)  = coneshape->GetRmin(1) - kConeRCurv1;
1713   coneshape->Rmax(2)  = coneshape->GetRmax(0);
1714
1715   coneshape->Z(3)     = coneshape->GetZ(2);
1716   coneshape->Rmax(3)  = coneshape->GetRmax(0);
1717
1718   coneshape->Z(4)     = kConeZOuterRing - kConeRCurv1;
1719   coneshape->Rmax(4)  = coneshape->GetRmax(0);
1720
1721   coneshape->Z(5)     = kConeZOuterRing;
1722   coneshape->Rmax(5)  = coneshape->GetRmax(4) - kConeRCurv1;
1723
1724   coneshape->Z(6)     = coneshape->GetZ(5);
1725
1726   RadiusOfCurvature(kConeRCurv2,90.0,kConeZInnerRing,kConeCent1RCurv2,
1727                     90.0-kConeTheta,z,rmin1);
1728   coneshape->Z(7)     = z;
1729   coneshape->Rmin(7)  = rmin1;
1730
1731   coneshape->Rmin(3)  = RminFromZpCone(coneshape,7,90.-kConeTheta,
1732                                        coneshape->GetZ(3));
1733
1734   coneshape->Rmin(4)  = RminFrom2Points(coneshape,3,7,coneshape->GetZ(4));
1735
1736   coneshape->Rmin(5)  = RminFrom2Points(coneshape,3,7,coneshape->GetZ(5));
1737
1738   coneshape->Rmin(6) = coneshape->GetRmin(5);
1739
1740   coneshape->Z(8)     = kConeZInnerRing;
1741   coneshape->Rmin(8)  = kConeCent1RCurv2;
1742
1743   coneshape->Z(9)     = coneshape->GetZ(8);
1744   coneshape->Rmin(9)  = kConeRInnerMin;
1745
1746   RadiusOfCurvature(kConeRCurv2,90.0,kConeZLength,kConeCent2RCurv2,
1747                     90.0-kConeTheta,z,rmax);
1748
1749   coneshape->Z(10)    = z;
1750   coneshape->Rmin(10) = coneshape->GetRmin(9);
1751   coneshape->Rmax(10) = rmax;
1752
1753   coneshape->Rmax(6)  = RmaxFromZpCone(coneshape,10,90.-kConeTheta,
1754                                        coneshape->GetZ(6));
1755
1756   coneshape->Rmax(7)  = RmaxFrom2Points(coneshape,6,10,coneshape->GetZ(7));
1757
1758   coneshape->Rmax(8)  = RmaxFrom2Points(coneshape,6,10,coneshape->GetZ(8));
1759
1760   coneshape->Rmax(9)  = coneshape->GetRmax(8);
1761
1762   coneshape->Z(11)    = kConeZLength;
1763   coneshape->Rmin(11) = coneshape->GetRmin(10);
1764   coneshape->Rmax(11) = kConeCent2RCurv2;
1765
1766   // SSD Cone Insert: another Pcon
1767   Double_t x0, y0, x1, y1, x2, y2;
1768   TGeoPcon *coneinsertshape = new TGeoPcon(0.0,360.0,12);
1769
1770   coneinsertshape->Z(0)     = coneshape->GetZ(0) + kCFThickness;
1771   coneinsertshape->Rmin(0)  = coneshape->GetRmin(0) + kCFThickness;
1772   coneinsertshape->Rmax(0)  = coneshape->GetRmax(0) - kCFThickness;
1773
1774   x0 = coneshape->GetZ(0); y0 = coneshape->GetRmin(0);
1775   x1 = coneshape->GetZ(1); y1 = coneshape->GetRmin(1);
1776   x2 = coneshape->GetZ(2); y2 = coneshape->GetRmin(2);
1777   InsidePoint(x0, y0, x1, y1, x2, y2,  kCFThickness, z, rmin1);
1778   coneinsertshape->Z(1)     = z;
1779   coneinsertshape->Rmin(1)  = rmin1;
1780   coneinsertshape->Rmax(1)  = coneinsertshape->GetRmax(0);
1781
1782   x0 = coneshape->GetZ(1); y0 = coneshape->GetRmin(1);
1783   x1 = coneshape->GetZ(2); y1 = coneshape->GetRmin(2);
1784   x2 = coneshape->GetZ(3); y2 = coneshape->GetRmin(3);
1785   InsidePoint(x0, y0, x1, y1, x2, y2,  kCFThickness, z, rmin1);
1786   coneinsertshape->Z(2)     = z;
1787   coneinsertshape->Rmin(2)  = rmin1;
1788   coneinsertshape->Rmax(2)  = coneinsertshape->GetRmax(1);
1789
1790   x0 = coneshape->GetZ(2); y0 = coneshape->GetRmin(2);
1791   x1 = coneshape->GetZ(3); y1 = coneshape->GetRmin(3);
1792   x2 = coneshape->GetZ(4); y2 = coneshape->GetRmin(4);
1793   InsidePoint(x0, y0, x1, y1, x2, y2,  kCFThickness, z, rmin1);
1794   coneinsertshape->Z(3)     = z;
1795   coneinsertshape->Rmin(3)  = rmin1;
1796   coneinsertshape->Rmax(3)  = coneinsertshape->GetRmax(2);
1797
1798   x0 = coneshape->GetZ(3); y0 = coneshape->GetRmax(3);
1799   x1 = coneshape->GetZ(4); y1 = coneshape->GetRmax(4);
1800   x2 = coneshape->GetZ(5); y2 = coneshape->GetRmax(5);
1801   InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
1802   coneinsertshape->Z(4)     = z;
1803   coneinsertshape->Rmax(4)  = rmax;
1804
1805   x0 = coneshape->GetZ(4); y0 = coneshape->GetRmax(4);
1806   x1 = coneshape->GetZ(5); y1 = coneshape->GetRmax(5);
1807   x2 = coneshape->GetZ(6); y2 = coneshape->GetRmax(6);
1808   InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
1809   coneinsertshape->Z(5)     = z;
1810   coneinsertshape->Rmax(5)  = rmax;
1811
1812   x0 = coneshape->GetZ(5); y0 = coneshape->GetRmax(5);
1813   x1 = coneshape->GetZ(6); y1 = coneshape->GetRmax(6);
1814   x2 = coneshape->GetZ(7); y2 = coneshape->GetRmax(7);
1815   InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
1816   coneinsertshape->Z(6)     = z;
1817   coneinsertshape->Rmax(6)  = rmax;
1818
1819   x0 = coneshape->GetZ(6); y0 = coneshape->GetRmin(6);
1820   x1 = coneshape->GetZ(7); y1 = coneshape->GetRmin(7);
1821   x2 = coneshape->GetZ(8); y2 = coneshape->GetRmin(8);
1822   InsidePoint(x0, y0, x1, y1, x2, y2,  kCFThickness, z, rmin1);
1823   coneinsertshape->Z(7)     = z;
1824   coneinsertshape->Rmin(7)  = rmin1;
1825
1826   coneinsertshape->Rmin(4)  = RminFrom2Points(coneinsertshape,3,7,
1827                                               coneinsertshape->GetZ(4));
1828
1829   coneinsertshape->Rmin(5)  = RminFrom2Points(coneinsertshape,3,7,
1830                                               coneinsertshape->GetZ(5));
1831
1832   coneinsertshape->Rmin(6)  = coneinsertshape->GetRmin(5);
1833
1834   x0 = coneshape->GetZ(7); y0 = coneshape->GetRmin(7);
1835   x1 = coneshape->GetZ(8); y1 = coneshape->GetRmin(8);
1836   x2 = coneshape->GetZ(9); y2 = coneshape->GetRmin(9);
1837   InsidePoint(x0, y0, x1, y1, x2, y2,  kCFThickness, z, rmin1);
1838   coneinsertshape->Z(8)     = z;
1839   coneinsertshape->Rmin(8)  = rmin1;
1840
1841   x0 = coneshape->GetZ( 8); y0 = coneshape->GetRmin( 8);
1842   x1 = coneshape->GetZ( 9); y1 = coneshape->GetRmin( 9);
1843   x2 = coneshape->GetZ(10); y2 = coneshape->GetRmin(10);
1844   InsidePoint(x0, y0, x1, y1, x2, y2,  kCFThickness, z, rmin1);
1845   coneinsertshape->Z(9)     = z;
1846   coneinsertshape->Rmin(9)  = rmin1;
1847
1848   x0 = coneshape->GetZ( 9); y0 = coneshape->GetRmax( 9);
1849   x1 = coneshape->GetZ(10); y1 = coneshape->GetRmax(10);
1850   x2 = coneshape->GetZ(11); y2 = coneshape->GetRmax(11);
1851   InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
1852   coneinsertshape->Z(10)    = z;
1853   coneinsertshape->Rmax(10) = rmax;
1854   coneinsertshape->Rmin(10) = coneinsertshape->GetRmin(9);
1855
1856   coneinsertshape->Rmax(7)  = RmaxFrom2Points(coneinsertshape,6,10,
1857                                               coneinsertshape->GetZ(7));
1858
1859   coneinsertshape->Rmax(8)  = RmaxFrom2Points(coneinsertshape,6,10,
1860                                               coneinsertshape->GetZ(8));
1861
1862   coneinsertshape->Rmax(9)  = coneinsertshape->GetRmax(8);
1863
1864   x0 = coneshape->GetZ(10); y0 = coneshape->GetRmax(10);
1865   x1 = coneshape->GetZ(11); y1 = coneshape->GetRmax(11);
1866   x2 = coneshape->GetZ(11); y2 = coneshape->GetRmin(11);
1867   InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
1868   coneinsertshape->Z(11)    = z;
1869   coneinsertshape->Rmax(11) = rmax;
1870   coneinsertshape->Rmin(11) = coneinsertshape->GetRmin(10);
1871
1872   // SSD Cone Foams: two other Pcon's
1873   TGeoPcon *conefoam1shape = new TGeoPcon(0.0, 360.0, 4);
1874
1875   conefoam1shape->Z(0)    = coneinsertshape->GetZ(3);
1876   conefoam1shape->Rmin(0) = coneinsertshape->GetRmin(3);
1877   conefoam1shape->Rmax(0) = conefoam1shape->GetRmin(0);
1878
1879   conefoam1shape->Rmax(1) = conefoam1shape->GetRmax(0);
1880   conefoam1shape->Z(1)    = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
1881                                            conefoam1shape->GetRmax(1));
1882   conefoam1shape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
1883                                            conefoam1shape->GetZ(1));
1884
1885   Double_t t = kConeThickness - 2*kCFThickness;
1886   conefoam1shape->Rmin(2) = conefoam1shape->GetRmax(0) -
1887                            (kConeFoam1Length*kCosConeTheta - t*kSinConeTheta);
1888   conefoam1shape->Z(2)    = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
1889                                            conefoam1shape->GetRmin(2));
1890   conefoam1shape->Rmax(2) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
1891                                            conefoam1shape->GetZ(2));
1892
1893   conefoam1shape->Rmin(3) = conefoam1shape->GetRmin(2);
1894   conefoam1shape->Rmax(3) = conefoam1shape->GetRmin(3);
1895   conefoam1shape->Z(3)    = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
1896                                            conefoam1shape->GetRmax(3));
1897
1898   TGeoPcon *conefoam2shape = new TGeoPcon(0.0, 360.0, 4);
1899
1900   conefoam2shape->Z(3)    = coneinsertshape->GetZ(10);
1901   conefoam2shape->Rmin(3) = coneinsertshape->GetRmax(10);
1902   conefoam2shape->Rmax(3) = conefoam2shape->GetRmin(3);
1903
1904   conefoam2shape->Rmin(2) = conefoam2shape->GetRmin(3);
1905   conefoam2shape->Z(2)    = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
1906                                            conefoam2shape->GetRmin(2));
1907   conefoam2shape->Rmax(2) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
1908                                            conefoam2shape->GetZ(2));
1909
1910   conefoam2shape->Rmin(0) = conefoam2shape->GetRmax(2) +
1911                            (kConeFoam2Length*kCosConeTheta - t*kSinConeTheta);
1912   conefoam2shape->Rmax(0) = conefoam2shape->GetRmin(0);
1913   conefoam2shape->Z(0)    = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
1914                                            conefoam2shape->GetRmin(0));
1915
1916   conefoam2shape->Rmax(1) = conefoam2shape->GetRmax(0);
1917   conefoam2shape->Z(1)    = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
1918                                            conefoam2shape->GetRmax(1));
1919   conefoam2shape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
1920                                            conefoam2shape->GetZ(1));
1921
1922   // SSD Cone Holes: Pcon's
1923   // A single hole volume gives an overlap with coneinsert, so
1924   // three contiguous volumes are created: one to be put in coneinsert
1925   // and two in the cone carbon fiber envelope
1926   Double_t holePhi;
1927   holePhi = (kCoolingHoleWidth/kCoolingHoleRmin)*TMath::RadToDeg();
1928
1929   TGeoPcon *coolingholeshape = new TGeoPcon(-holePhi/2., holePhi, 4);
1930
1931   coolingholeshape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight;
1932   coolingholeshape->Rmax(0) = coolingholeshape->GetRmin(0);
1933   coolingholeshape->Z(0)    = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
1934                                              coolingholeshape->GetRmin(0));
1935
1936   coolingholeshape->Rmax(1) = coolingholeshape->GetRmax(0);
1937   coolingholeshape->Z(1)    = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
1938                                              coolingholeshape->GetRmax(1));
1939   coolingholeshape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
1940                                              coolingholeshape->GetZ(1));
1941
1942   coolingholeshape->Rmin(2) = kCoolingHoleRmin;
1943   coolingholeshape->Z(2)    = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
1944                                              coolingholeshape->GetRmin(2));
1945   coolingholeshape->Rmax(2) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
1946                                              coolingholeshape->GetZ(2));
1947
1948   coolingholeshape->Rmin(3) = coolingholeshape->GetRmin(2);
1949   coolingholeshape->Rmax(3) = coolingholeshape->GetRmin(3);
1950   coolingholeshape->Z(3)    = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
1951                                              coolingholeshape->GetRmax(3));
1952
1953   TGeoPcon *coolinghole2shape = new TGeoPcon(-holePhi/2., holePhi, 4);
1954
1955   coolinghole2shape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight;
1956   coolinghole2shape->Rmax(0) = coolinghole2shape->GetRmin(0);
1957   coolinghole2shape->Z(0)    = ZFromRminpCone(coneshape,3,90.-kConeTheta,
1958                                               coolinghole2shape->GetRmin(0));
1959
1960   coolinghole2shape->Rmax(1) = coolinghole2shape->GetRmax(0);
1961   coolinghole2shape->Z(1)    = coolingholeshape->GetZ(0);
1962   coolinghole2shape->Rmin(1) = RminFromZpCone(coneshape,3,90.-kConeTheta,
1963                                               coolinghole2shape->GetZ(1));
1964
1965   coolinghole2shape->Rmin(2) = kCoolingHoleRmin;
1966   coolinghole2shape->Z(2)    = ZFromRminpCone(coneshape,3,90.-kConeTheta,
1967                                               coolinghole2shape->GetRmin(2));
1968   coolinghole2shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
1969                                               coolinghole2shape->GetZ(2));
1970
1971   coolinghole2shape->Rmin(3) = coolinghole2shape->GetRmin(2);
1972   coolinghole2shape->Rmax(3) = coolinghole2shape->GetRmin(3);
1973   coolinghole2shape->Z(3)    = coolingholeshape->GetZ(2);
1974
1975   TGeoPcon *coolinghole3shape = new TGeoPcon(-holePhi/2., holePhi, 4);
1976
1977   coolinghole3shape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight;
1978   coolinghole3shape->Rmax(0) = coolinghole3shape->GetRmin(0);
1979   coolinghole3shape->Z(0)    = coolingholeshape->GetZ(1);
1980
1981   coolinghole3shape->Rmax(1) = coolinghole3shape->GetRmax(0);
1982   coolinghole3shape->Z(1)    = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
1983                                               coolinghole3shape->GetRmax(1));
1984   coolinghole3shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
1985                                               coolinghole3shape->GetZ(1));
1986
1987   coolinghole3shape->Rmin(2) = kCoolingHoleRmin;
1988   coolinghole3shape->Z(2)    = coolingholeshape->GetZ(3);
1989   coolinghole3shape->Rmax(2) = RmaxFromZpCone(coneshape,7,90.-kConeTheta,
1990                                               coolinghole3shape->GetZ(2));
1991
1992   coolinghole3shape->Rmin(3) = coolinghole3shape->GetRmin(2);
1993   coolinghole3shape->Rmax(3) = coolinghole3shape->GetRmin(3);
1994   coolinghole3shape->Z(3)    = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
1995                                               coolinghole3shape->GetRmax(3));
1996
1997   //
1998   holePhi = (kMountingHoleWidth/kMountingHoleRmin)*TMath::RadToDeg();
1999
2000   TGeoPcon *mountingholeshape = new TGeoPcon(-holePhi/2., holePhi, 4);
2001
2002   mountingholeshape->Rmin(0) = kMountingHoleRmin + kMountingHoleHight;
2003   mountingholeshape->Rmax(0) = mountingholeshape->GetRmin(0);
2004   mountingholeshape->Z(0)    = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
2005                                               mountingholeshape->GetRmin(0));
2006
2007   mountingholeshape->Rmin(1) = kMountingHoleRmin;
2008   mountingholeshape->Rmax(1) = mountingholeshape->GetRmax(0);
2009   mountingholeshape->Z(1)    = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
2010                                               mountingholeshape->GetRmin(1));
2011
2012   mountingholeshape->Rmin(2) = mountingholeshape->GetRmin(1);
2013   mountingholeshape->Rmax(2) = mountingholeshape->GetRmax(1);
2014   mountingholeshape->Z(2)    = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
2015                                               mountingholeshape->GetRmax(2));
2016
2017   mountingholeshape->Rmin(3) = mountingholeshape->GetRmin(2);
2018   mountingholeshape->Rmax(3) = mountingholeshape->GetRmin(3);
2019   mountingholeshape->Z(3)    = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
2020                                               mountingholeshape->GetRmax(3));
2021
2022   TGeoPcon *mountinghole2shape = new TGeoPcon(-holePhi/2., holePhi, 4);
2023
2024   mountinghole2shape->Rmin(0) = kMountingHoleRmin + kMountingHoleHight;
2025   mountinghole2shape->Rmax(0) = mountingholeshape->GetRmin(0);
2026   mountinghole2shape->Z(0)    = ZFromRminpCone(coneshape,3,90.-kConeTheta,
2027                                                mountinghole2shape->GetRmin(0));
2028
2029   mountinghole2shape->Rmax(1) = mountinghole2shape->GetRmax(0);
2030   mountinghole2shape->Z(1)    = mountingholeshape->Z(0);
2031   mountinghole2shape->Rmin(1) = RminFromZpCone(coneshape,3,90.-kConeTheta,
2032                                                mountinghole2shape->GetZ(1));
2033
2034   mountinghole2shape->Rmin(2) = kMountingHoleRmin;
2035   mountinghole2shape->Z(2)    = ZFromRminpCone(coneshape,3,90.-kConeTheta,
2036                                                mountinghole2shape->GetRmin(2));
2037   mountinghole2shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
2038                                                mountinghole2shape->GetZ(2));
2039
2040   mountinghole2shape->Rmin(3) = mountinghole2shape->Rmin(2);
2041   mountinghole2shape->Rmax(3) = mountinghole2shape->Rmin(3);
2042   mountinghole2shape->Z(3)    = mountingholeshape->Z(1);
2043
2044   TGeoPcon *mountinghole3shape = new TGeoPcon(-holePhi/2., holePhi, 4);
2045
2046   mountinghole3shape->Rmin(0) = kMountingHoleRmin + kMountingHoleHight;
2047   mountinghole3shape->Rmax(0) = mountingholeshape->GetRmin(0);
2048   mountinghole3shape->Z(0)    = mountingholeshape->GetZ(2);
2049
2050   mountinghole3shape->Rmax(1) = mountinghole3shape->GetRmax(0);
2051   mountinghole3shape->Z(1)    = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
2052                                                mountinghole3shape->GetRmax(1));
2053   mountinghole3shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
2054                                                mountinghole3shape->GetZ(1));
2055
2056   mountinghole3shape->Rmin(2) = kMountingHoleRmin;
2057   mountinghole3shape->Z(2)    = mountingholeshape->Z(3);
2058   mountinghole3shape->Rmax(2) = RmaxFromZpCone(coneshape,7,90.-kConeTheta,
2059                                                mountinghole3shape->GetZ(2));
2060
2061   mountinghole3shape->Rmin(3) = mountinghole3shape->Rmin(2);
2062   mountinghole3shape->Rmax(3) = mountinghole3shape->Rmin(3);
2063   mountinghole3shape->Z(3)    = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
2064                                                mountinghole3shape->GetRmax(3));
2065
2066   // The Cable Hole is even more complicated, a Composite Shape
2067   // is unavoidable here (gosh!)
2068   TGeoPcon *coneshapecopy = new TGeoPcon("conecopy",0.0, 360.0, 12);
2069
2070   for (Int_t i=0; i<12; i++) {
2071     coneshapecopy->Rmin(i) = coneshape->GetRmin(i);
2072     coneshapecopy->Rmax(i) = coneshape->GetRmax(i);
2073     coneshapecopy->Z(i)    = coneshape->GetZ(i);
2074   }
2075
2076   holePhi = (kCableHoleWidth/kCableHoleRout)*TMath::RadToDeg();
2077   TGeoConeSeg *chCS = new TGeoConeSeg("chCS", 0.5*kConeZLength,
2078                                       kCableHoleRin, kCableHoleRout,
2079                                       kCableHoleRin, kCableHoleRout,
2080                                       -0.5*holePhi, 0.5*holePhi);
2081
2082   TGeoCompositeShape *cableholeshape = new TGeoCompositeShape(
2083                                            "SSDCableHoleShape",
2084                                            "conecopy*chCS");
2085
2086   if(GetDebug(1)){
2087     chCS->InspectShape();
2088     cableholeshape->InspectShape();
2089   }
2090
2091   // SSD Cone Wings: Tube and TubeSeg shapes
2092   Double_t angleWideWing, angleWideWingThickness;
2093   angleWideWing = (kWingWidth/kWingRmax)*TMath::RadToDeg();
2094   angleWideWingThickness = (kCFThickness/kWingRmax)*TMath::RadToDeg();
2095
2096   TGeoTubeSeg *wingshape = new TGeoTubeSeg(kConeROuterMax, kWingRmax,
2097                                            kWingHalfThick,
2098                                            0, angleWideWing);
2099
2100   TGeoTubeSeg *winginsertshape = new TGeoTubeSeg(kConeROuterMax,
2101                                  kWingRmax-kCFThickness,
2102                                  kWingHalfThick-kCFThickness,
2103                                  angleWideWingThickness,
2104                                  angleWideWing-angleWideWingThickness);
2105
2106   // SDD support plate, SSD side (Mounting Bracket): a TubeSeg
2107   TGeoTubeSeg *bracketshape = new TGeoTubeSeg(kBracketRmin, kBracketRmax,
2108                             kBracketHalfLength, -kBracketPhi/2, kBracketPhi/2);
2109
2110
2111   // We have the shapes: now create the real volumes
2112
2113   TGeoVolume *cfcone = new TGeoVolume("SSDCarbonFiberCone",
2114                                       coneshape,medSSDcf);
2115   cfcone->SetVisibility(kTRUE);
2116   cfcone->SetLineColor(4); // Blue
2117   cfcone->SetLineWidth(1);
2118   cfcone->SetFillColor(cfcone->GetLineColor());
2119   cfcone->SetFillStyle(4000); // 0% transparent
2120
2121   TGeoVolume *cfconeinsert = new TGeoVolume("SSDCarbonFiberConeInsert",
2122                                             coneinsertshape,medSSDste);
2123   cfconeinsert->SetVisibility(kTRUE);
2124   cfconeinsert->SetLineColor(2); // Red
2125   cfconeinsert->SetLineWidth(1);
2126   cfconeinsert->SetFillColor(cfconeinsert->GetLineColor());
2127   cfconeinsert->SetFillStyle(4050); // 50% transparent
2128
2129   TGeoVolume *cfconefoam1 = new TGeoVolume("SSDCarbonFiberConeFoam1",
2130                                             conefoam1shape,medSSDroh);
2131   cfconefoam1->SetVisibility(kTRUE);
2132   cfconefoam1->SetLineColor(3); // Green
2133   cfconefoam1->SetLineWidth(1);
2134   cfconefoam1->SetFillColor(cfconefoam1->GetLineColor());
2135   cfconefoam1->SetFillStyle(4050); // 50% transparent
2136
2137   TGeoVolume *cfconefoam2 = new TGeoVolume("SSDCarbonFiberConeFoam2",
2138                                             conefoam2shape,medSSDroh);
2139   cfconefoam2->SetVisibility(kTRUE);
2140   cfconefoam2->SetLineColor(3); // Green
2141   cfconefoam2->SetLineWidth(1);
2142   cfconefoam2->SetFillColor(cfconefoam2->GetLineColor());
2143   cfconefoam2->SetFillStyle(4050); // 50% transparent
2144
2145   TGeoVolume *coolinghole = new TGeoVolume("SSDCoolingHole",
2146                                            coolingholeshape,medSSDair);
2147   coolinghole->SetVisibility(kTRUE);
2148   coolinghole->SetLineColor(5); // Yellow
2149   coolinghole->SetLineWidth(1);
2150   coolinghole->SetFillColor(coolinghole->GetLineColor());
2151   coolinghole->SetFillStyle(4090); // 90% transparent
2152
2153   TGeoVolume *coolinghole2 = new TGeoVolume("SSDCoolingHole2",
2154                                             coolinghole2shape,medSSDair);
2155   coolinghole2->SetVisibility(kTRUE);
2156   coolinghole2->SetLineColor(5); // Yellow
2157   coolinghole2->SetLineWidth(1);
2158   coolinghole2->SetFillColor(coolinghole2->GetLineColor());
2159   coolinghole2->SetFillStyle(4090); // 90% transparent
2160
2161   TGeoVolume *coolinghole3 = new TGeoVolume("SSDCoolingHole3",
2162                                             coolinghole3shape,medSSDair);
2163   coolinghole3->SetVisibility(kTRUE);
2164   coolinghole3->SetLineColor(5); // Yellow
2165   coolinghole3->SetLineWidth(1);
2166   coolinghole3->SetFillColor(coolinghole3->GetLineColor());
2167   coolinghole3->SetFillStyle(4090); // 90% transparent
2168
2169   TGeoVolume *mountinghole = new TGeoVolume("SSDMountingHole",
2170                                             mountingholeshape,medSSDair);
2171   mountinghole->SetVisibility(kTRUE);
2172   mountinghole->SetLineColor(5); // Yellow
2173   mountinghole->SetLineWidth(1);
2174   mountinghole->SetFillColor(mountinghole->GetLineColor());
2175   mountinghole->SetFillStyle(4090); // 90% transparent
2176
2177   TGeoVolume *mountinghole2 = new TGeoVolume("SSDMountingHole2",
2178                                              mountinghole2shape,medSSDair);
2179   mountinghole2->SetVisibility(kTRUE);
2180   mountinghole2->SetLineColor(5); // Yellow
2181   mountinghole2->SetLineWidth(1);
2182   mountinghole2->SetFillColor(mountinghole2->GetLineColor());
2183   mountinghole2->SetFillStyle(4090); // 90% transparent
2184
2185   TGeoVolume *mountinghole3 = new TGeoVolume("SSDMountingHole3",
2186                                              mountinghole3shape,medSSDair);
2187   mountinghole3->SetVisibility(kTRUE);
2188   mountinghole3->SetLineColor(5); // Yellow
2189   mountinghole3->SetLineWidth(1);
2190   mountinghole3->SetFillColor(mountinghole3->GetLineColor());
2191   mountinghole3->SetFillStyle(4090); // 90% transparent
2192
2193   TGeoVolume *wing = new TGeoVolume("SSDWing",wingshape,medSSDcf);
2194   wing->SetVisibility(kTRUE);
2195   wing->SetLineColor(4); // Blue
2196   wing->SetLineWidth(1);
2197   wing->SetFillColor(wing->GetLineColor());
2198   wing->SetFillStyle(4000); // 0% transparent
2199
2200   TGeoVolume *cablehole = new TGeoVolume("SSDCableHole",
2201                                          cableholeshape,medSSDair);
2202   cablehole->SetVisibility(kTRUE);
2203   cablehole->SetLineColor(5); // Yellow
2204   cablehole->SetLineWidth(1);
2205   cablehole->SetFillColor(cablehole->GetLineColor());
2206   cablehole->SetFillStyle(4090); // 90% transparent
2207
2208   TGeoVolume *winginsert = new TGeoVolume("SSDWingInsert",
2209                                           winginsertshape,medSSDste);
2210   winginsert->SetVisibility(kTRUE);
2211   winginsert->SetLineColor(2); // Red
2212   winginsert->SetLineWidth(1);
2213   winginsert->SetFillColor(winginsert->GetLineColor());
2214   winginsert->SetFillStyle(4050); // 50% transparent
2215
2216   TGeoVolume *bracket = new TGeoVolume("SSDMountingBracket",
2217                                        bracketshape,medSSDal);
2218   bracket->SetVisibility(kTRUE);
2219   bracket->SetLineColor(6); // Purple
2220   bracket->SetLineWidth(1);
2221   bracket->SetFillColor(bracket->GetLineColor());
2222   bracket->SetFillStyle(4000); // 0% transparent
2223
2224   // Mount up a cone
2225   for (Int_t i=0; i<(Int_t)(360./kMountingHolePhi); i++) {
2226     Double_t phiH = i*kMountingHolePhi + 0.5*kMountingHolePhi;
2227     cfconefoam2->AddNode(mountinghole,i+1, new TGeoRotation("", phiH, 0, 0));
2228   }
2229
2230   for (Int_t i=0; i<(Int_t)(360./kCoolingHolePhi); i++) {
2231     Double_t phiH = i*kCoolingHolePhi + 0.5*kCoolingHolePhi;
2232     cfconeinsert->AddNodeOverlap(coolinghole,i+1, new TGeoRotation("", phiH, 0, 0));
2233   }
2234
2235   cfconeinsert->AddNode(cfconefoam1,1,0);
2236   cfconeinsert->AddNode(cfconefoam2,1,0);
2237
2238   cfcone->AddNode(cfconeinsert,1,0);
2239
2240   for (Int_t i=0; i<(Int_t)(360./kCoolingHolePhi); i++) {
2241     Double_t phiH = i*kCoolingHolePhi + 0.5*kCoolingHolePhi;
2242     cfcone->AddNode(coolinghole2,i+1, new TGeoRotation("", phiH, 0, 0));
2243     cfcone->AddNode(coolinghole3,i+1, new TGeoRotation("", phiH, 0, 0));
2244     cfcone->AddNodeOverlap(cablehole,i+1, new TGeoRotation("", phiH, 0, 0));
2245   }
2246
2247   for (Int_t i=0; i<(Int_t)(360./kMountingHolePhi); i++) {
2248     Double_t phiH = i*kMountingHolePhi + 0.5*kMountingHolePhi;
2249     cfcone->AddNode(mountinghole2,i+1, new TGeoRotation("", phiH, 0, 0));
2250     cfcone->AddNode(mountinghole3,i+1, new TGeoRotation("", phiH, 0, 0));
2251   }
2252
2253   wing->AddNode(winginsert,1,0);
2254
2255   // Add all volumes in the Cone assembly
2256   vC->AddNode(cfcone,1,new TGeoTranslation(0,0,-kConeZPosition));
2257
2258   for (Int_t i=0; i<4; i++) {
2259     Double_t thetaW = kThetaWing + 90.*i + angleWideWing/2.;
2260     vC->AddNode(wing, i+1, new TGeoCombiTrans(0, 0, -kConeZPosition+kWingHalfThick,
2261                            new TGeoRotation("",thetaW,180,0)));
2262   }
2263
2264   Double_t zBracket = kConeZPosition - coneshape->GetZ(9) +
2265                       2*bracketshape->GetDz();
2266   for (Int_t i=0; i<3; i++) {
2267     Double_t thetaB = 60 + 120.*i;
2268     vC->AddNode(bracket, i+1, new TGeoCombiTrans(0, 0, -zBracket,
2269                               new TGeoRotation("",thetaB,0,0)));
2270   }
2271
2272   // Finally put everything in the mother volume
2273   moth->AddNode(cfcylinder,1,0);
2274
2275   moth->AddNode(vC, 1, 0 );
2276   moth->AddNode(vC, 2, new TGeoRotation("",180, 180, 0) );
2277
2278   // Some debugging if requested
2279   if(GetDebug(1)){
2280     vC->PrintNodes();
2281     vC->InspectShape();
2282   }
2283
2284   return;
2285 }
2286
2287 //______________________________________________________________________
2288 void AliITSv11GeometrySupport::ServicesCableSupport(TGeoVolume *moth,
2289                                                     TGeoManager *mgr){
2290 //
2291 // Creates the cable trays which are outside the ITS support cones
2292 // but still inside the TPC
2293 // This is now a stearing routine, the actual work is done by three
2294 // specialized methods to avoid a really huge unique method
2295 //
2296 // Input:
2297 //         moth : the TGeoVolume owing the volume structure
2298 //         mgr  : the GeoManager (default gGeoManager)
2299 // Output:
2300 //
2301 // Created:      15 Nov 2009  Mario Sitta
2302 //
2303
2304   TraySupportsSideA(moth, mgr);
2305
2306   ServicesCableSupportSPD(moth, mgr);
2307   ServicesCableSupportSDD(moth, mgr);
2308   ServicesCableSupportSSD(moth, mgr);
2309
2310   return;
2311 }
2312
2313 //______________________________________________________________________
2314 void AliITSv11GeometrySupport::TraySupportsSideA(TGeoVolume *moth,
2315                                                  TGeoManager *mgr){
2316 //
2317 // Creates the structure supporting the ITS cable trays on Side A
2318 //
2319 // Input:
2320 //         moth : the TGeoVolume owing the volume structure
2321 //         mgr  : the GeoManager (default gGeoManager)
2322 // Output:
2323 //
2324 // Created:      14 Dec 2009  Mario Sitta
2325 // Updated:      26 Feb 2010  Mario Sitta
2326 //
2327 // Technical data are taken from AutoCAD drawings, L.Simonetti technical
2328 // drawings and other (oral) information given by F.Tosello
2329 //
2330
2331   // Dimensions and positions of the A-Side Cable Tray Support Ring
2332   // (0872/G/A/01)
2333   const Double_t kSuppRingYTrans      =  110.00 *fgkmm;
2334   const Double_t kSuppRingZTrans      =(1011.00+435.00) *fgkmm;
2335   const Double_t kSuppForwYTrans      =  185.00 *fgkmm;
2336
2337   const Double_t kExtSuppRingSpace1   =   33.00 *fgkmm;
2338   const Double_t kExtSuppRingSpace2   =   45.00 *fgkmm;
2339   const Double_t kExtSuppRingSpcAbov  =   30.00 *fgkmm;
2340   const Double_t kExtSuppRingBase     =  491.50 *fgkmm;
2341   const Double_t kExtSuppRingInward   =   35.00 *fgkmm;
2342   const Double_t kExtSuppRingRmax     =  540.00 *fgkmm;
2343   const Double_t kExtSuppRingRint1    =  465.00 *fgkmm;
2344   const Double_t kExtSuppRingRint2    =  467.00 *fgkmm;
2345   const Double_t kExtSuppRingInnerHi  =  450.00 *fgkmm;
2346   const Double_t kExtSuppRingInWide   =  100.00 *fgkmm;
2347   const Double_t kExtSuppRingR7       =    7.00 *fgkmm;
2348   const Double_t kExtSuppRingR5       =    5.00 *fgkmm;
2349   const Double_t kExtSuppRingThick    =   20.00 *fgkmm;
2350
2351   const Double_t kExtSuppRingSpcAng   =   10.50 *TMath::DegToRad();
2352   const Double_t kExtSuppRingPartPhi  =   15.00 *TMath::DegToRad();
2353   const Double_t kExtSuppRingIntAng   =    7.00 *TMath::DegToRad();
2354   const Double_t kExtSuppRingBaseAng  =   75.00 *TMath::DegToRad();
2355   const Double_t kExtSuppRingR7Ang    =  100.00 *TMath::DegToRad(); // Guessed
2356
2357   const Int_t    kExtSuppRingNPtsArc  =   10; // N.points to approximate arc
2358
2359   const Double_t kIntSuppRingThick1   =   15.00 *fgkmm;
2360   const Double_t kIntSuppRingThick2   =   13.00 *fgkmm;
2361   const Double_t kIntSuppRingInward   =   24.00 *fgkmm;
2362   const Double_t kIntSuppRingThick    =   20.00 *fgkmm;
2363
2364   const Double_t kSuppCylHeight       =  340.00 *fgkmm;
2365   const Double_t kSuppCylRint         =  475.00 *fgkmm;
2366   const Double_t kSuppCylRext         =  478.00 *fgkmm;
2367   const Double_t kSuppCylDispl        =  137.70 *fgkmm;
2368
2369   const Double_t kSuppSpacerHeight    =   30.00 *fgkmm;
2370   const Double_t kSuppSpacerThick     =   10.00 *fgkmm;
2371
2372   const Double_t kSuppSpacerAngle     =   15.00;  // Degrees
2373
2374   const Double_t kSuppForwRingRint1   =  500.00 *fgkmm;
2375   const Double_t kSuppForwRingRint2   =  540.00 *fgkmm;
2376   const Double_t kSuppForwRingRext    =  560.00 *fgkmm;
2377   const Double_t kSuppForwRingThikAll =   50.00 *fgkmm;
2378   const Double_t kSuppForwRingThikInt =   20.00 *fgkmm;
2379
2380   // (0872/G/B/01)
2381   const Double_t kSuppForwConeRmin    =  558.00 *fgkmm;
2382   const Double_t kSuppForwConeRmax    =  681.00 *fgkmm;
2383   const Double_t kSuppForwConeLen1    =  318.00 *fgkmm;
2384   const Double_t kSuppForwConeLen2    =  662.00 *fgkmm;
2385   const Double_t kSuppForwConeThick   =    3.00 *fgkmm;
2386
2387   const Double_t kSuppBackRingPlacTop =   90.00 *fgkmm;
2388   const Double_t kSuppBackRingPlacSid =   50.00 *fgkmm;
2389   const Double_t kSuppBackRingHeight  =  760.00 *fgkmm;
2390   const Double_t kSuppBackRingRext    =  760.00 *fgkmm;
2391   const Double_t kSuppBackRingRint    =  685.00 *fgkmm;
2392 //  const Double_t kSuppBackRingRint2   =  675.00 *fgkmm;
2393   const Double_t kSuppBackRingR10     =   10.00 *fgkmm;
2394   const Double_t kSuppBackRingBase    =  739.00 *fgkmm;
2395   const Double_t kSuppBackRingThikAll =   50.00 *fgkmm;
2396   const Double_t kSuppBackRingThick1  =   20.00 *fgkmm;
2397   const Double_t kSuppBackRingThick2  =   20.00 *fgkmm;
2398
2399 //  const Double_t kSuppBackRingPlacAng =   10.00 *TMath::DegToRad();
2400   const Double_t kSuppBackRingPlacAng =   10.25 *TMath::DegToRad();//Fix ovlp.
2401   const Double_t kSuppBackRing2ndAng1 =   78.40 *TMath::DegToRad();
2402   const Double_t kSuppBackRing2ndAng2 =   45.00 *TMath::DegToRad();
2403
2404   const Int_t    kSuppBackRingNPtsArc =   10; // N.points to approximate arc
2405
2406   // (0872/G/C/01)
2407   const Double_t kRearSuppZTransGlob  =(1011.00+9315.00-6040.00) *fgkmm;
2408   const Double_t kBackRodZTrans       = 2420.00 *fgkmm;
2409
2410   const Double_t kBackRodLength       = 1160.00 *fgkmm;
2411   const Double_t kBackRodThickLen     =   20.00 *fgkmm;
2412   const Double_t kBackRodDiameter     =   20.00 *fgkmm;
2413
2414   const Double_t kSuppRearRingRint    =  360.00 *fgkmm;
2415   const Double_t kSuppRearRingRext1   =  410.00 *fgkmm;
2416   const Double_t kSuppRearRingRext2   =  414.00 *fgkmm;
2417   const Double_t kSuppRearRingHeight  =  397.00 *fgkmm;
2418   const Double_t kSuppRearRingTopWide =  111.87 *fgkmm;
2419   const Double_t kSuppRearRingBase    =  451.50 *fgkmm;
2420   const Double_t kSuppRearRingBaseHi  =   58.00 *fgkmm;
2421   const Double_t kSuppRearRingSideHi  =   52.00 *fgkmm;
2422   const Double_t kSuppRearRingInside  =   40.00 *fgkmm;
2423   const Double_t kSuppRearRingInsideHi=   12.00 *fgkmm;
2424   const Double_t kSuppRearRingThick   =   20.00 *fgkmm;
2425   const Double_t kSuppRearRingXRodHole=  441.50 *fgkmm;
2426   const Double_t kSuppRearRingYRodHole=   42.00 *fgkmm;
2427
2428   const Double_t kSuppRearRing1stAng  =   22.00 *TMath::DegToRad();
2429   const Double_t kSuppRearRingStepAng =   15.00 *TMath::DegToRad();
2430
2431   const Int_t    kSuppRearRingNPtsArc =   10; // N.points to approximate arc
2432
2433
2434   // Local variables
2435   Double_t xprof[2*(15+kExtSuppRingNPtsArc)],yprof[2*(15+kExtSuppRingNPtsArc)];
2436   Double_t slp1, slp2, phi, xm, ym;
2437   Double_t xloc, yloc, zloc, rmin, rmax, deltaR;
2438   Int_t npoints;
2439
2440
2441   // The whole support as an assembly
2442   TGeoVolumeAssembly *trayASuppStruct = new TGeoVolumeAssembly("ITSsuppSideAStructure");
2443
2444
2445   // First create all needed shapes
2446
2447   // The External Ring (part of 0872/G/A/01): a really complex Xtru
2448   TGeoXtru *extSuppRing = new TGeoXtru(2);
2449
2450   // First the upper notch...
2451   xprof[ 0] = kExtSuppRingSpace1;
2452   yprof[ 0] = kExtSuppRingInnerHi + kExtSuppRingSpcAbov;
2453
2454   slp1 = TMath::Tan(TMath::Pi()/2 - kExtSuppRingSpcAng);
2455   IntersectCircle(slp1, xprof[0], yprof[0], kExtSuppRingRmax, 0., 0.,
2456                   xprof[5], yprof[5], xm, ym); // Ignore dummy xm,ym
2457
2458   xprof[ 4] = xprof[5];
2459   yprof[ 4] = yprof[5] - kExtSuppRingR5/TMath::Tan(kExtSuppRingSpcAng);
2460   xprof[ 3] = xprof[4] - kExtSuppRingR5*(1 - TMath::Cos(TMath::Pi()/6));
2461   yprof[ 3] = yprof[4] - kExtSuppRingR5*(    TMath::Sin(TMath::Pi()/6));
2462   xprof[ 2] = xprof[4] - kExtSuppRingR5*(1 - TMath::Cos(TMath::Pi()/3));
2463   yprof[ 2] = yprof[4] - kExtSuppRingR5*(    TMath::Sin(TMath::Pi()/3));
2464   xprof[ 1] = xprof[4] - kExtSuppRingR5;
2465   yprof[ 1] = yprof[4] - kExtSuppRingR5;
2466
2467   Int_t indx = 5+kExtSuppRingNPtsArc;
2468   // ...then the external arc, approximated with segments,...
2469   xprof[indx] = kExtSuppRingBase;
2470   yprof[indx] = TMath::Sqrt(kExtSuppRingRmax*kExtSuppRingRmax -
2471                             kExtSuppRingBase*kExtSuppRingBase);
2472   Double_t alphamin = TMath::ASin(kExtSuppRingSpace2/kExtSuppRingRmax);
2473   Double_t alphamax = TMath::Pi()/2 -
2474                     TMath::ASin(yprof[5+kExtSuppRingNPtsArc]/kExtSuppRingRmax);
2475
2476   for (Int_t jp = 1; jp < kExtSuppRingNPtsArc; jp++) {
2477     Double_t alpha = jp*(alphamax-alphamin)/kExtSuppRingNPtsArc;
2478     xprof[5+jp] = kExtSuppRingRmax*TMath::Sin(alpha);
2479     yprof[5+jp] = kExtSuppRingRmax*TMath::Cos(alpha);
2480   }
2481   // ...and finally the interior profile
2482   xprof[indx+1] = kExtSuppRingBase;
2483   yprof[indx+1] = kSuppRingYTrans;
2484   xprof[indx+2] = xprof[indx+1] - kExtSuppRingInward;
2485   yprof[indx+2] = yprof[indx+1];
2486
2487   phi  = TMath::Pi()/2 - 4*kExtSuppRingPartPhi - kExtSuppRingIntAng;
2488   slp1 = TMath::Tan(TMath::Pi() - kExtSuppRingBaseAng);
2489   slp2 = TMath::Tan(TMath::Pi()/2 + phi);
2490   xm   = kExtSuppRingRint2*TMath::Cos(phi);
2491   ym   = kExtSuppRingRint2*TMath::Sin(phi);
2492   IntersectLines(slp1, xprof[indx+2], yprof[indx+2], slp2, xm, ym,
2493                  xprof[indx+3], yprof[indx+3]);
2494
2495   slp1 = slp2;
2496   phi += kExtSuppRingPartPhi;
2497   slp2 = TMath::Tan(TMath::Pi()/2 + phi);
2498   xm   = kExtSuppRingRint1*TMath::Cos(phi);
2499   ym   = kExtSuppRingRint1*TMath::Sin(phi);
2500   IntersectLines(slp1, xprof[indx+3], yprof[indx+3], slp2, xm, ym,
2501                  xprof[indx+4], yprof[indx+4]);
2502
2503   slp1 = slp2;
2504   phi += kExtSuppRingPartPhi;
2505   slp2 = TMath::Tan(TMath::Pi()/2 + phi);
2506   xm   = kExtSuppRingRint2*TMath::Cos(phi);
2507   ym   = kExtSuppRingRint2*TMath::Sin(phi);
2508   IntersectLines(slp1, xprof[indx+4], yprof[indx+4], slp2, xm, ym,
2509                  xprof[indx+5], yprof[indx+5]);
2510
2511   slp1 = slp2;
2512   phi += kExtSuppRingPartPhi;
2513   slp2 = TMath::Tan(TMath::Pi()/2 + phi);
2514   xm   = kExtSuppRingRint1*TMath::Cos(phi);
2515   ym   = kExtSuppRingRint1*TMath::Sin(phi);
2516   IntersectLines(slp1, xprof[indx+5], yprof[indx+5], slp2, xm, ym,
2517                  xprof[indx+6], yprof[indx+6]);
2518
2519   xprof[indx+9] = kExtSuppRingInWide;
2520   yprof[indx+9] = kExtSuppRingInnerHi;
2521   xprof[indx+8] = xprof[indx+9] +
2522                   (1 - TMath::Cos(kExtSuppRingR7Ang/2))*kExtSuppRingR7;
2523   yprof[indx+8] = yprof[indx+9] +
2524                   (    TMath::Sin(kExtSuppRingR7Ang/2))*kExtSuppRingR7;
2525   xprof[indx+7] = xprof[indx+9] +
2526                   (1 + TMath::Cos(kExtSuppRingR7Ang  ))*kExtSuppRingR7;
2527   yprof[indx+7] = yprof[indx+9] +
2528                   (    TMath::Sin(kExtSuppRingR7Ang  ))*kExtSuppRingR7;
2529   // Gosh, we did the right side! now reflex on the left side
2530   npoints = (sizeof(xprof)/sizeof(Double_t))/2;
2531   for (Int_t jp = 0; jp < npoints; jp++) {
2532     xprof[npoints+jp] = -xprof[npoints-1-jp];
2533     yprof[npoints+jp] =  yprof[npoints-1-jp];
2534   }
2535   // wow! now the actual Xtru
2536   extSuppRing->DefinePolygon(2*npoints, xprof, yprof);
2537   extSuppRing->DefineSection(0,0);
2538   extSuppRing->DefineSection(1,kExtSuppRingThick);
2539
2540   // The Internal Ring (part of 0872/G/A/01): another complex Xtru
2541   TGeoXtru *intSuppRing = new TGeoXtru(2);
2542
2543   // First the external profile...
2544   npoints = 0;
2545
2546   slp1 = 0;
2547   phi  = TMath::Pi()/2 - kExtSuppRingPartPhi - kExtSuppRingIntAng;
2548   slp2 = TMath::Tan(TMath::Pi()/2 + phi);
2549   xm   = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Cos(phi);
2550   ym   = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Sin(phi);
2551   IntersectLines(slp1,  0, kExtSuppRingInnerHi+kExtSuppRingSpcAbov,
2552                  slp2, xm, ym,
2553                  xprof[npoints], yprof[npoints]);
2554   npoints++;
2555
2556   slp1 = slp2;
2557   phi -= kExtSuppRingPartPhi;
2558   slp2 = TMath::Tan(TMath::Pi()/2 + phi);
2559   xm   = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Cos(phi);
2560   ym   = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Sin(phi);
2561   IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
2562                  slp2, xm, ym,
2563                  xprof[npoints], yprof[npoints]);
2564   npoints++;
2565
2566   slp1 = slp2;
2567   phi -= kExtSuppRingPartPhi;
2568   slp2 = TMath::Tan(TMath::Pi()/2 + phi);
2569   xm   = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Cos(phi);
2570   ym   = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Sin(phi);
2571   IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
2572                  slp2, xm, ym,
2573                  xprof[npoints], yprof[npoints]);
2574   npoints++;
2575
2576   slp1 = slp2;
2577   phi -= kExtSuppRingPartPhi;
2578   slp2 = TMath::Tan(TMath::Pi()/2 + phi);
2579   xm   = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Cos(phi);
2580   ym   = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Sin(phi);
2581   IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
2582                  slp2, xm, ym,
2583                  xprof[npoints], yprof[npoints]);
2584   npoints++;
2585
2586   xprof[npoints] = kExtSuppRingBase-kIntSuppRingInward;
2587   yprof[npoints] = Yfrom2Points(xprof[npoints-1], yprof[npoints-1], xm, ym,
2588                                 xprof[npoints]);
2589   npoints++;
2590
2591   xprof[npoints] = xprof[npoints-1];
2592   yprof[npoints] = kSuppRingYTrans;
2593   npoints++;
2594   // ...and then the interior profile, which is identical to extSuppRing one
2595   for (Int_t jp=0; jp < 8; jp++) {
2596     xprof[npoints] = extSuppRing->GetX(17+jp);
2597     yprof[npoints] = extSuppRing->GetY(17+jp);
2598     npoints++;
2599   }
2600   // We did the right side! now reflex on the left side
2601   for (Int_t jp = 0; jp < npoints; jp++) {
2602     xprof[npoints+jp] = -xprof[npoints-1-jp];
2603     yprof[npoints+jp] =  yprof[npoints-1-jp];
2604   }
2605   // And now the actual Xtru
2606   intSuppRing->DefinePolygon(2*npoints, xprof, yprof);
2607   intSuppRing->DefineSection(0,0);
2608   intSuppRing->DefineSection(1,kIntSuppRingThick);
2609
2610   // The intermediate cylinder (0872/G/A/03): a TubeSeg
2611   alphamin = TMath::ASin(kSuppCylDispl/kSuppCylRint)*TMath::RadToDeg();
2612   alphamax = 180 - alphamin;
2613   TGeoTubeSeg *interCylind = new TGeoTubeSeg(kSuppCylRint, kSuppCylRext,
2614                                      kSuppCylHeight/2, alphamin, alphamax);
2615
2616   // The spacer (0872/G/A/03): a simple Xtru
2617   TGeoXtru *suppSpacer = new TGeoXtru(2);
2618
2619   xprof[0] = kSuppSpacerHeight;
2620   yprof[0] = kSuppSpacerThick;
2621   xprof[1] = xprof[0];
2622   yprof[1] = 0;
2623   xprof[2] = 0;
2624   yprof[2] = 0;
2625   xprof[3] = kSuppSpacerThick*SinD(kSuppSpacerAngle);
2626   yprof[3] = yprof[0];
2627
2628   suppSpacer->DefinePolygon(4, xprof, yprof);
2629   suppSpacer->DefineSection(0,-kSuppCylHeight/2);
2630   suppSpacer->DefineSection(1, kSuppCylHeight/2);
2631
2632   // The forward ring (0872/G/B/02): a Pcon (slight oversimplification)
2633   Double_t rmean = (kSuppForwRingRint1+kSuppForwRingRext)/2;
2634   alphamin = TMath::ASin(kSuppForwYTrans/rmean)*TMath::RadToDeg();
2635   alphamax = 180 - alphamin;
2636
2637   TGeoPcon *forwardRing = new TGeoPcon(alphamin,alphamax-alphamin,4);
2638
2639   forwardRing->DefineSection(0,0,
2640                              kSuppForwRingRint1,kSuppForwRingRext);
2641   forwardRing->DefineSection(1,kSuppForwRingThikInt,
2642                              kSuppForwRingRint1,kSuppForwRingRext);
2643   forwardRing->DefineSection(2,kSuppForwRingThikInt,
2644                              kSuppForwRingRint2,kSuppForwRingRext);
2645   forwardRing->DefineSection(3,kSuppForwRingThikAll,
2646                              kSuppForwRingRint2,kSuppForwRingRext);
2647
2648   // The forward cone (0872/G/B/03): a TGeoPcon
2649   TGeoPcon *forwardCone = new TGeoPcon(alphamin,alphamax-alphamin,3);
2650
2651   forwardCone->DefineSection(0,0,
2652                              kSuppForwConeRmin-kSuppForwConeThick,
2653                              kSuppForwConeRmin);
2654   forwardCone->DefineSection(1,kSuppForwConeLen1,
2655                              kSuppForwConeRmin-kSuppForwConeThick,
2656                              kSuppForwConeRmin);
2657   forwardCone->DefineSection(2,kSuppForwConeLen1+kSuppForwConeLen2,
2658                              kSuppForwConeRmax-kSuppForwConeThick,
2659                              kSuppForwConeRmax);
2660
2661   // The first part of the Back Ring (part of 0872/G/B/01): a complex Xtru
2662   TGeoXtru *firstSuppBackRing = new TGeoXtru(2);
2663
2664   // First the external profile... (the arc is approximated with segments)
2665   npoints = 0;
2666
2667   xprof[npoints] = kSuppBackRingPlacTop;
2668   yprof[npoints] = kSuppBackRingHeight;
2669   npoints++;
2670
2671   alphamax = TMath::Pi()/2 - TMath::ASin(kSuppBackRingPlacTop/kSuppBackRingRext);
2672   alphamin = TMath::ASin((kSuppForwYTrans+kSuppBackRingPlacSid)/kSuppBackRingRext);
2673
2674   xprof[npoints] = xprof[npoints-1];
2675   yprof[npoints] = kSuppBackRingRext*TMath::Sin(alphamax);
2676   npoints++;
2677
2678   for (Int_t jp = 1; jp <= kSuppBackRingNPtsArc; jp++) {
2679     Double_t alpha = alphamax - jp*(alphamax-alphamin)/kSuppBackRingNPtsArc;
2680     xprof[npoints] = kSuppBackRingRext*TMath::Cos(alpha);
2681     yprof[npoints] = kSuppBackRingRext*TMath::Sin(alpha);
2682     npoints++;
2683   }
2684
2685   xprof[npoints] = kSuppBackRingBase -
2686                    kSuppBackRingPlacSid*TMath::Tan(kSuppBackRingPlacAng);
2687   yprof[npoints] = yprof[npoints-1];
2688   npoints++;
2689
2690   xprof[npoints] = kSuppBackRingBase;
2691   yprof[npoints] = kSuppForwYTrans;
2692   npoints++;
2693   // ...then the internal profile (the arc is approximated with segments)
2694   alphamin = TMath::ASin(kSuppForwYTrans/kSuppBackRingRint);
2695   alphamax = TMath::Pi()/2;
2696
2697   for (Int_t jp = 0; jp < kSuppBackRingNPtsArc; jp++) {
2698     Double_t alpha = alphamin + jp*(alphamax-alphamin)/kSuppBackRingNPtsArc;
2699     xprof[npoints] = kSuppBackRingRint*TMath::Cos(alpha);
2700     yprof[npoints] = kSuppBackRingRint*TMath::Sin(alpha);
2701     npoints++;
2702   }
2703
2704   xprof[npoints] = 0;
2705   yprof[npoints] = kSuppBackRingRint;
2706   npoints++;
2707   // We did the right side! now reflex on the left side (except last point)
2708   for (Int_t jp = 0; jp < npoints-1; jp++) {
2709     xprof[npoints+jp] = -xprof[npoints-jp-2];
2710     yprof[npoints+jp] =  yprof[npoints-jp-2];
2711   }
2712   // And now the actual Xtru
2713   firstSuppBackRing->DefinePolygon(2*npoints-1, xprof, yprof);
2714   firstSuppBackRing->DefineSection(0,0);
2715   firstSuppBackRing->DefineSection(1,kSuppBackRingThick1);
2716
2717   // The second part of the Back Ring (part of 0872/G/B/01): a Pcon
2718   // (slight oversimplification)
2719   alphamin = TMath::ASin(kSuppForwYTrans/kSuppBackRingRint)*TMath::RadToDeg();
2720   alphamax = 180 - alphamin;
2721
2722   TGeoPcon *secondSuppBackRing = new TGeoPcon(alphamin,alphamax-alphamin,6);
2723
2724   deltaR = kSuppBackRingThick2/TMath::Sin(kSuppBackRing2ndAng1);
2725   rmin = kSuppBackRingRint - kSuppBackRingThick1/TMath::Tan(kSuppBackRing2ndAng1);
2726   rmax = rmin + deltaR + kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1);
2727   secondSuppBackRing->DefineSection(0, 0, rmin, rmax);
2728
2729   zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1/3));
2730   rmax -= kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1/3);
2731   rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
2732   secondSuppBackRing->DefineSection(1, zloc, rmin, rmax);
2733
2734   zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1*2/3));
2735   rmax = secondSuppBackRing->GetRmax(0) - kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1*2/3);
2736   rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
2737   secondSuppBackRing->DefineSection(2, zloc, rmin, rmax);
2738
2739   zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1));
2740   rmax = secondSuppBackRing->GetRmax(0) - kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1);
2741   rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
2742   secondSuppBackRing->DefineSection(3, zloc, rmin, rmax);
2743
2744   slp1 = TMath::Tan(kSuppBackRing2ndAng2);
2745   slp2 = TMath::Tan(TMath::Pi()/2 + kSuppBackRing2ndAng1);
2746   IntersectLines(-slp1,kSuppBackRingThikAll,deltaR/2,
2747                   slp2,kSuppBackRingThikAll,deltaR,
2748                   xm, ym);
2749
2750   zloc = xm - kSuppBackRingThick1;
2751   rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
2752   rmax = rmin + deltaR;
2753   secondSuppBackRing->DefineSection(4, zloc, rmin, rmax);
2754
2755   zloc = kSuppBackRingThikAll - kSuppBackRingThick1;
2756   rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
2757   rmax = rmin + deltaR/2;
2758   secondSuppBackRing->DefineSection(5, zloc, rmin, rmax);
2759
2760   // The supporting rod: a Tube
2761   TGeoTube *suppRod = new TGeoTube(0, kBackRodDiameter/2,
2762                                    (kBackRodLength - kBackRodThickLen)/2);
2763
2764   // The Back Ring (0872/G/C/01): another complex Xtru
2765   TGeoXtru *suppRearRing = new TGeoXtru(2);
2766
2767   // First the external profile...
2768   npoints = 0;
2769
2770   xprof[npoints] = kSuppRearRingTopWide;
2771   yprof[npoints] = kSuppRearRingHeight;
2772   npoints++;
2773
2774   phi = kSuppRearRing1stAng;
2775   slp1 = TMath::Tan(TMath::Pi() - phi);
2776   phi += kSuppRearRingStepAng;
2777   slp2 = TMath::Tan(TMath::Pi() - phi);
2778   xm = kSuppRearRingRext2*TMath::Sin(phi);
2779   ym = kSuppRearRingRext2*TMath::Cos(phi);
2780   IntersectLines(slp1, kSuppRearRingTopWide, kSuppRearRingHeight,
2781                  slp2, xm, ym,
2782                  xprof[npoints], yprof[npoints]);
2783   npoints++;
2784
2785   slp1 = slp2;
2786   phi += kSuppRearRingStepAng;
2787   slp2 = TMath::Tan(TMath::Pi() - phi);
2788   xm = kSuppRearRingRext1*TMath::Sin(phi);
2789   ym = kSuppRearRingRext1*TMath::Cos(phi);
2790   IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
2791                  slp2, xm, ym,
2792                  xprof[npoints], yprof[npoints]);
2793   npoints++;
2794
2795   slp1 = slp2;
2796   phi += kSuppRearRingStepAng;
2797   slp2 = TMath::Tan(TMath::Pi() - phi);
2798   xm = kSuppRearRingRext2*TMath::Sin(phi);
2799   ym = kSuppRearRingRext2*TMath::Cos(phi);
2800   IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
2801                  slp2, xm, ym,
2802                  xprof[npoints], yprof[npoints]);
2803   npoints++;
2804
2805   slp1 = slp2;
2806   slp2 = 0;
2807   xm = kSuppRearRingBase;
2808   ym = kSuppRearRingBaseHi + kSuppRearRingSideHi;
2809   IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
2810                  slp2, xm, ym,
2811                  xprof[npoints], yprof[npoints]);
2812   npoints++;
2813
2814   xprof[npoints] = kSuppRearRingBase;
2815   yprof[npoints] = kSuppRearRingBaseHi + kSuppRearRingSideHi;
2816   npoints++;
2817   xprof[npoints] = xprof[npoints - 1];
2818   yprof[npoints] = kSuppRearRingBaseHi;
2819   npoints++;
2820   xprof[npoints] = xprof[npoints - 1] - kSuppRearRingInside;
2821   yprof[npoints] = yprof[npoints - 1];
2822   npoints++;
2823   xprof[npoints] = xprof[npoints - 1];
2824   yprof[npoints] = yprof[npoints - 1] + kSuppRearRingInsideHi;
2825   npoints++;
2826   // ...then the internal arc, approximated with segments,...
2827   xprof[npoints] = kSuppRearRingRint;
2828   yprof[npoints] = yprof[npoints - 1];
2829
2830   alphamin = TMath::ASin(kSuppRearRingBaseHi/kSuppRearRingRint);
2831   alphamax = TMath::Pi()/2;
2832
2833   for (Int_t jp = 1; jp < kSuppRearRingNPtsArc; jp++) {
2834     Double_t alpha = alphamin + jp*(alphamax-alphamin)/kSuppRearRingNPtsArc;
2835     xprof[npoints+jp] = kSuppRearRingRint*TMath::Cos(alpha);
2836     yprof[npoints+jp] = kSuppRearRingRint*TMath::Sin(alpha);
2837   }
2838
2839   xprof[npoints+kSuppRearRingNPtsArc] = 0;
2840   yprof[npoints+kSuppRearRingNPtsArc] = kSuppRearRingRint;
2841   // We did the right side! now reflex on the left side
2842   Int_t nTotalPoints = npoints+kSuppRearRingNPtsArc;
2843   for (Int_t jp = 0; jp < nTotalPoints; jp++) {
2844     xprof[nTotalPoints+1+jp] = -xprof[nTotalPoints-1-jp];
2845     yprof[nTotalPoints+1+jp] =  yprof[nTotalPoints-1-jp];
2846   }
2847
2848   // And now the actual Xtru
2849   suppRearRing->DefinePolygon(2*nTotalPoints+1, xprof, yprof);
2850   suppRearRing->DefineSection(0,0);
2851   suppRearRing->DefineSection(1,kSuppRearRingThick);
2852
2853
2854   // We have all shapes: now create the real volumes
2855   TGeoMedium *medAl = mgr->GetMedium("ITS_ANTICORODAL$");
2856
2857   TGeoVolume *sideAExtSuppRing = new TGeoVolume("ITSsuppSideAExtSuppRing",
2858                                                  extSuppRing, medAl);
2859
2860   sideAExtSuppRing->SetVisibility(kTRUE);
2861   sideAExtSuppRing->SetLineColor(kMagenta+1);
2862   sideAExtSuppRing->SetLineWidth(1);
2863   sideAExtSuppRing->SetFillColor(sideAExtSuppRing->GetLineColor());
2864   sideAExtSuppRing->SetFillStyle(4000); // 0% transparent
2865
2866   TGeoVolume *sideAIntSuppRing = new TGeoVolume("ITSsuppSideAIntSuppRing",
2867                                                  intSuppRing, medAl);
2868
2869   sideAIntSuppRing->SetVisibility(kTRUE);
2870   sideAIntSuppRing->SetLineColor(kMagenta+1);
2871   sideAIntSuppRing->SetLineWidth(1);
2872   sideAIntSuppRing->SetFillColor(sideAIntSuppRing->GetLineColor());
2873   sideAIntSuppRing->SetFillStyle(4000); // 0% transparent
2874
2875   TGeoVolume *sideASuppCyl = new TGeoVolume("ITSsuppSideASuppCyl",
2876                                             interCylind, medAl);
2877
2878   sideASuppCyl->SetVisibility(kTRUE);
2879   sideASuppCyl->SetLineColor(kMagenta+1);
2880   sideASuppCyl->SetLineWidth(1);
2881   sideASuppCyl->SetFillColor(sideASuppCyl->GetLineColor());
2882   sideASuppCyl->SetFillStyle(4000); // 0% transparent
2883
2884   TGeoVolume *sideASuppSpacer = new TGeoVolume("ITSsuppSideASuppSpacer",
2885                                                suppSpacer, medAl);
2886
2887   sideASuppSpacer->SetVisibility(kTRUE);
2888   sideASuppSpacer->SetLineColor(kMagenta+1);
2889   sideASuppSpacer->SetLineWidth(1);
2890   sideASuppSpacer->SetFillColor(sideASuppSpacer->GetLineColor());
2891   sideASuppSpacer->SetFillStyle(4000); // 0% transparent
2892
2893   TGeoVolume *sideASuppForwRing = new TGeoVolume("ITSsuppSideASuppForwRing",
2894                                                  forwardRing, medAl);
2895
2896   sideASuppForwRing->SetVisibility(kTRUE);
2897   sideASuppForwRing->SetLineColor(kMagenta+1);
2898   sideASuppForwRing->SetLineWidth(1);
2899   sideASuppForwRing->SetFillColor(sideASuppForwRing->GetLineColor());
2900   sideASuppForwRing->SetFillStyle(4000); // 0% transparent
2901
2902   TGeoVolume *sideASuppForwCone = new TGeoVolume("ITSsuppSideASuppForwCone",
2903                                                  forwardCone, medAl);
2904
2905   sideASuppForwCone->SetVisibility(kTRUE);
2906   sideASuppForwCone->SetLineColor(kMagenta+1);
2907   sideASuppForwCone->SetLineWidth(1);
2908   sideASuppForwCone->SetFillColor(sideASuppForwCone->GetLineColor());
2909   sideASuppForwCone->SetFillStyle(4000); // 0% transparent
2910
2911   TGeoVolume *sideAFirstSuppBackRing = new TGeoVolume("ITSsuppSideAFirstSuppBackRing",
2912                                                      firstSuppBackRing, medAl);
2913
2914   sideAFirstSuppBackRing->SetVisibility(kTRUE);
2915   sideAFirstSuppBackRing->SetLineColor(kMagenta+1);
2916   sideAFirstSuppBackRing->SetLineWidth(1);
2917   sideAFirstSuppBackRing->SetFillColor(sideAFirstSuppBackRing->GetLineColor());
2918   sideAFirstSuppBackRing->SetFillStyle(4000); // 0% transparent
2919
2920   TGeoVolume *sideASecondSuppBackRing = new TGeoVolume("ITSsuppSideASecondSuppBackRing",
2921                                                        secondSuppBackRing, medAl);
2922
2923   sideASecondSuppBackRing->SetVisibility(kTRUE);
2924   sideASecondSuppBackRing->SetLineColor(kMagenta+1);
2925   sideASecondSuppBackRing->SetLineWidth(1);
2926   sideASecondSuppBackRing->SetFillColor(sideASecondSuppBackRing->GetLineColor());
2927   sideASecondSuppBackRing->SetFillStyle(4000); // 0% transparent
2928
2929   TGeoVolume *sideASuppRod = new TGeoVolume("ITSsuppSideASuppRod",
2930                                             suppRod, medAl);
2931
2932   sideASuppRod->SetVisibility(kTRUE);
2933   sideASuppRod->SetLineColor(kMagenta+1);
2934   sideASuppRod->SetLineWidth(1);
2935   sideASuppRod->SetFillColor(sideASuppRod->GetLineColor());
2936   sideASuppRod->SetFillStyle(4000); // 0% transparent
2937
2938   TGeoVolume *sideASuppRearRing = new TGeoVolume("ITSsuppSideASuppRearRing",
2939                                                  suppRearRing, medAl);
2940
2941   sideASuppRearRing->SetVisibility(kTRUE);
2942   sideASuppRearRing->SetLineColor(kMagenta+1);
2943   sideASuppRearRing->SetLineWidth(1);
2944   sideASuppRearRing->SetFillColor(sideASuppRearRing->GetLineColor());
2945   sideASuppRearRing->SetFillStyle(4000); // 0% transparent
2946
2947
2948   // Now build up the support structure
2949   zloc = kSuppRingZTrans;
2950   trayASuppStruct->AddNode(sideAExtSuppRing, 1,
2951                            new TGeoTranslation(0, 0, zloc) );
2952   trayASuppStruct->AddNode(sideAExtSuppRing, 2,
2953                            new TGeoCombiTrans( 0, 0, zloc,
2954                                                new TGeoRotation("",180,0,0)));
2955
2956   zloc += kExtSuppRingThick;
2957   trayASuppStruct->AddNode(sideAIntSuppRing, 1,
2958                            new TGeoTranslation(0, 0, zloc) );
2959   trayASuppStruct->AddNode(sideAIntSuppRing, 2,
2960                            new TGeoCombiTrans( 0, 0, zloc,
2961                                                new TGeoRotation("",180,0,0)));
2962
2963   xloc = kExtSuppRingBase - kIntSuppRingInward;
2964   yloc = kSuppRingYTrans;
2965   zloc += (kIntSuppRingThick + kSuppCylHeight/2);
2966   trayASuppStruct->AddNode(sideASuppCyl, 1,
2967                            new TGeoTranslation(0, 0, zloc) );
2968   trayASuppStruct->AddNode(sideASuppCyl, 2,
2969                            new TGeoCombiTrans( 0, 0, zloc,
2970                                                new TGeoRotation("",180,0,0)));
2971   trayASuppStruct->AddNode(sideASuppSpacer, 1,
2972                            new TGeoCombiTrans( xloc, yloc, zloc,
2973                            new TGeoRotation("",90+kSuppSpacerAngle,0,0)));
2974   trayASuppStruct->AddNode(sideASuppSpacer, 2,
2975                            new TGeoCombiTrans(-xloc, yloc, zloc,
2976                            new TGeoRotation("",0,180,kSuppSpacerAngle-90)));
2977   trayASuppStruct->AddNode(sideASuppSpacer, 3,
2978                            new TGeoCombiTrans( xloc,-yloc, zloc,
2979                            new TGeoRotation("",180,180,kSuppSpacerAngle-90)));
2980   trayASuppStruct->AddNode(sideASuppSpacer, 4,
2981                            new TGeoCombiTrans(-xloc,-yloc, zloc,
2982                            new TGeoRotation("",270+kSuppSpacerAngle,0,0)));
2983
2984
2985   zloc += kSuppCylHeight/2;
2986   trayASuppStruct->AddNode(sideAIntSuppRing, 3,
2987                            new TGeoTranslation(0, 0, zloc) );
2988   trayASuppStruct->AddNode(sideAIntSuppRing, 4,
2989                            new TGeoCombiTrans( 0, 0, zloc,
2990                                                new TGeoRotation("",180,0,0)));
2991
2992   zloc += kIntSuppRingThick;
2993   trayASuppStruct->AddNode(sideAExtSuppRing, 3,
2994                            new TGeoTranslation(0, 0, zloc) );
2995   trayASuppStruct->AddNode(sideAExtSuppRing, 4,
2996                            new TGeoCombiTrans( 0, 0, zloc,
2997                                                new TGeoRotation("",180,0,0)));
2998
2999   zloc += kExtSuppRingThick;
3000   trayASuppStruct->AddNode(sideASuppForwRing, 1,
3001                            new TGeoTranslation(0, 0, zloc) );
3002   trayASuppStruct->AddNode(sideASuppForwRing, 2,
3003                            new TGeoCombiTrans( 0, 0, zloc,
3004                                                new TGeoRotation("",180,0,0)));
3005
3006   zloc += kSuppForwRingThikAll;
3007   trayASuppStruct->AddNode(sideASuppForwCone, 1,
3008                            new TGeoTranslation(0, 0, zloc) );
3009   trayASuppStruct->AddNode(sideASuppForwCone, 2,
3010                            new TGeoCombiTrans( 0, 0, zloc,
3011                                                new TGeoRotation("",180,0,0)));
3012
3013   zloc += (kSuppForwConeLen1+kSuppForwConeLen2);
3014   trayASuppStruct->AddNode(sideAFirstSuppBackRing, 1,
3015                            new TGeoTranslation(0, 0, zloc) );
3016   trayASuppStruct->AddNode(sideAFirstSuppBackRing, 2,
3017                            new TGeoCombiTrans( 0, 0, zloc,
3018                                                new TGeoRotation("",180,0,0)));
3019
3020   zloc += kSuppBackRingThick1;
3021   trayASuppStruct->AddNode(sideASecondSuppBackRing, 1,
3022                            new TGeoTranslation(0, 0, zloc) );
3023   trayASuppStruct->AddNode(sideASecondSuppBackRing, 2,
3024                            new TGeoCombiTrans( 0, 0, zloc,
3025                                                new TGeoRotation("",180,0,0)));
3026
3027   xloc = kSuppRearRingXRodHole;
3028   yloc = kSuppRearRingBaseHi + kSuppRearRingYRodHole;
3029   zloc = kRearSuppZTransGlob - kBackRodZTrans + suppRod->GetDz();
3030   trayASuppStruct->AddNode(sideASuppRod, 1,
3031                            new TGeoTranslation( xloc, yloc, zloc) );
3032   trayASuppStruct->AddNode(sideASuppRod, 2,
3033                            new TGeoTranslation(-xloc, yloc, zloc) );
3034   trayASuppStruct->AddNode(sideASuppRod, 3,
3035                            new TGeoTranslation( xloc,-yloc, zloc) );
3036   trayASuppStruct->AddNode(sideASuppRod, 4,
3037                            new TGeoTranslation(-xloc,-yloc, zloc) );
3038
3039   zloc += suppRod->GetDz();
3040   trayASuppStruct->AddNode(sideASuppRearRing, 1,
3041                            new TGeoTranslation( 0, 0, zloc) );
3042   trayASuppStruct->AddNode(sideASuppRearRing, 2,
3043                            new TGeoCombiTrans( 0, 0, zloc,
3044                                                new TGeoRotation("",180,0,0)));
3045
3046
3047   // Finally put everything in the mother volume
3048   moth->AddNode(trayASuppStruct,1,0);
3049
3050   return;
3051 }
3052
3053 //______________________________________________________________________
3054 void AliITSv11GeometrySupport::ServicesCableSupportSPD(TGeoVolume *moth,
3055                                                        TGeoManager *mgr){
3056 //
3057 // Creates the all SPD cable trays which are outside the ITS support cones
3058 // but still inside the TPC
3059 // In order to avoid a huge monolithic routine, this method actually
3060 // calls inner methods to create and assemble the various (macro)pieces
3061 //
3062 // Input:
3063 //         moth : the TGeoVolume owing the volume structure
3064 //         mgr  : the GeoManager (default gGeoManager)
3065 // Output:
3066 //
3067 // Created:         ???       Bjorn S. Nilsen
3068 // Updated:      15 Nov 2009  Mario Sitta
3069 //
3070 // Technical data are taken from AutoCAD drawings and other (oral)
3071 // information given by F.Tosello
3072 //
3073
3074   SPDCableTraysSideA(moth, mgr);
3075 //  SPDCableTraysSideC(moth, mgr);
3076
3077 }
3078
3079 //______________________________________________________________________
3080 void AliITSv11GeometrySupport::ServicesCableSupportSDD(TGeoVolume *moth,
3081                                                        TGeoManager *mgr){
3082 //
3083 // Creates the all SDD cable trays which are outside the ITS support cones
3084 // but still inside the TPC
3085 // In order to avoid a huge monolithic routine, this method actually
3086 // calls inner methods to create and assemble the various (macro)pieces
3087 //
3088 // Input:
3089 //         moth : the TGeoVolume owing the volume structure
3090 //         mgr  : the GeoManager (default gGeoManager)
3091 // Output:
3092 //
3093 // Created:      14 Dec 2009  Mario Sitta
3094 //
3095
3096   SDDCableTraysSideA(moth, mgr);
3097 //  SDDCableTraysSideC(moth, mgr);
3098
3099   return;
3100 }
3101
3102 //______________________________________________________________________
3103 void AliITSv11GeometrySupport::ServicesCableSupportSSD(TGeoVolume *moth,
3104                                                        TGeoManager *mgr){
3105 //
3106 // Creates the SSD cable trays which are outside the ITS support cones
3107 // but still inside the TPC
3108 // In order to avoid a huge monolithic routine, this method actually
3109 // calls inner methods to create and assemble the various (macro)pieces
3110 //
3111 // Input:
3112 //         moth : the TGeoVolume owing the volume structure
3113 //         mgr  : the GeoManager (default gGeoManager)
3114 // Output:
3115 //
3116 // Created:      15 Nov 2009  Mario Sitta
3117 //
3118
3119   SSDCableTraysSideA(moth, mgr);
3120 //  SSDCableTraysSideC(moth, mgr);
3121
3122   return;
3123 }
3124
3125 //______________________________________________________________________
3126 void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
3127                                                   TGeoManager *mgr){
3128 //
3129 // Creates the SPD cable trays which are outside the ITS support cones
3130 // but still inside the TPC on Side A
3131 // (part of this code is taken or anyway inspired to ServicesCableSupport
3132 // method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
3133 //
3134 // Input:
3135 //         moth : the TGeoVolume owing the volume structure
3136 //         mgr  : the GeoManager (default gGeoManager)
3137 // Output:
3138 //
3139 // Created:      15 Feb 2010  Mario Sitta
3140 //
3141 // Technical data are taken from AutoCAD drawings, L.Simonetti technical
3142 // drawings and other (oral) information given by F.Tosello and D.Elia
3143 // (small differences with blueprints - e.g. -0.07mm in R1Trans and
3144 // R2Trans - fix small overlaps; they are then compensated in positioning
3145 // the Rear Tray to avoid its own overlaps with the rear supporting ring)
3146 // Optical cables and low voltage cables are approximated with mean
3147 // materials and square cross sections, but preserving the total material
3148 // budget.
3149 //
3150
3151   // Overall position and rotation of the A-Side Cable Trays
3152   // (parts of 0872/G/D)
3153   const Double_t kTrayAR1Trans           =  396.93 *fgkmm;
3154   const Double_t kTrayAR2Trans           =  413.93 *fgkmm;
3155   const Double_t kTrayAZTrans            = 1011.00 *fgkmm;
3156   const Double_t kTrayAZRot              = (180-169.5);// Degrees
3157   const Double_t kTrayAFirstRotAng       =   22.00;    // Degrees
3158   const Double_t kTrayASecondRotAng      =   15.00;    // Degrees
3159
3160   const Double_t kForwardTrayWide        =   94.00 *fgkmm;//!!!TO BE CHECKED!!!
3161   const Double_t kForwardTrayFirstHigh   =   83.00 *fgkmm;//!!!TO BE CHECKED!!!
3162   const Double_t kForwardTraySecondHigh  =   52.70 *fgkmm;//!!!TO BE CHECKED!!!
3163   const Double_t kForwardTrayTotalLen    =  853.00 *fgkmm;
3164   const Double_t kForwardTrayFirstLen    =  435.00 *fgkmm;
3165   const Double_t kForwardTrayWingWide    =   16.00 *fgkmm;//!!!TO BE CHECKED!!!
3166   const Double_t kForwardTrayInterSpace  =   18.00 *fgkmm;//!!!TO BE CHECKED!!!
3167   const Double_t kForwardTrayThick       =    2.00 *fgkmm;
3168
3169   const Int_t kForwardSideNpoints        =    6;
3170
3171   const Double_t kExternalTrayLen        = 1200.00 *fgkmm;
3172   const Double_t kExternalTrayWide       = kForwardTrayWide;
3173   const Double_t kExternalTrayHigh       = kForwardTraySecondHigh;
3174   const Double_t kExternalTrayThick      = kForwardTrayThick;
3175
3176   const Double_t kCoolingTubeRmin        =    5.00 *fgkmm;
3177   const Double_t kCoolingTubeRmax        =    6.00 *fgkmm;
3178
3179   const Double_t kOpticalFibersSect      =    8.696*fgkmm;//!!!ESTIMATED!!!
3180   const Double_t kLowVoltageCableSect    =    3.412*fgkmm;//!!!ESTIMATED!!!
3181
3182   // Local variables
3183   Double_t xprof[kForwardSideNpoints], yprof[kForwardSideNpoints];
3184   Double_t xloc, yloc, zloc, alpharot;
3185
3186
3187   // The two tray components as assemblies
3188   TGeoVolumeAssembly *cableTrayAForw =
3189     new TGeoVolumeAssembly("ITSsupportSPDTrayAForwRear");
3190   TGeoVolumeAssembly *cableTrayAExt =
3191     new TGeoVolumeAssembly("ITSsupportSPDTrayAExt");
3192
3193
3194   // First create all needed shapes
3195
3196   // The lower face of the forward tray: a BBox
3197   TGeoBBox *forwTrayLowerFace = new TGeoBBox(kForwardTrayWide/2,
3198                                              kForwardTrayThick/2,
3199                                              kForwardTrayTotalLen/2);
3200
3201   // The side face of the forward tray: a Xtru
3202   TGeoXtru *forwTraySideFace = new TGeoXtru(2);
3203   forwTraySideFace->SetName("ITSsuppSPDForwTraySide");
3204
3205   xprof[0] = 0;
3206   yprof[0] = kForwardTrayThick;
3207   xprof[1] = kForwardTrayTotalLen;
3208   yprof[1] = yprof[0];
3209   xprof[2] = xprof[1];
3210   yprof[2] = kForwardTraySecondHigh - kForwardTrayThick;
3211   xprof[3] = kForwardTrayFirstLen;
3212   yprof[3] = yprof[2];
3213   xprof[4] = xprof[3];
3214   yprof[4] = kForwardTrayFirstHigh - kForwardTrayThick;
3215   xprof[5] = xprof[0];
3216   yprof[5] = yprof[4];
3217
3218   forwTraySideFace->DefinePolygon(6, xprof, yprof);
3219   forwTraySideFace->DefineSection(0, 0);
3220   forwTraySideFace->DefineSection(1, kForwardTrayThick);
3221
3222   // The covers of the forward tray: two BBox's
3223   TGeoBBox *forwTrayShortCover = new TGeoBBox(kForwardTrayWide/2,
3224                                               kForwardTrayThick/2,
3225                                               kForwardTrayFirstLen/2);
3226
3227   TGeoBBox *forwTrayLongCover = new TGeoBBox(kForwardTrayWide/2,
3228                                              kForwardTrayThick/2,
3229                              (kForwardTrayTotalLen - kForwardTrayFirstLen)/2);
3230
3231   // Each small wing of the forward tray: a BBox
3232   TGeoBBox *forwTrayWing = new TGeoBBox(kForwardTrayWingWide/2,
3233                              (kForwardTrayFirstHigh-kForwardTraySecondHigh)/2,
3234                                         kForwardTrayThick/2);
3235
3236   // The internal plane of the forward tray: a BBox
3237   TGeoBBox *forwTrayPlane = new TGeoBBox(kForwardTrayWide/2-kForwardTrayThick,
3238                                          kForwardTrayThick/2,
3239                                          kForwardTrayTotalLen/2);
3240
3241   // The internal wall of the forward tray: a BBox
3242   TGeoBBox *forwTrayWall = new TGeoBBox(kForwardTrayThick/2,
3243                                  (kForwardTrayInterSpace-kForwardTrayThick)/2,
3244                                         kForwardTrayTotalLen/2);
3245
3246   // Each horizontal face of the external tray: a BBox
3247   TGeoBBox *extTrayHorFace = new TGeoBBox(kExternalTrayWide/2-kExternalTrayThick,
3248                                           kExternalTrayThick/2,
3249                                           kExternalTrayLen/2);
3250
3251   // Each vertical face of the external tray: a BBox
3252   TGeoBBox *extTrayVerFace = new TGeoBBox(kExternalTrayThick/2,
3253                                           kExternalTrayHigh/2,
3254                                           kExternalTrayLen/2);
3255
3256   // The internal wall of the external tray: a BBox
3257   TGeoBBox *extTrayWall = new TGeoBBox(kExternalTrayThick/2,
3258                                  (kForwardTrayInterSpace-kExternalTrayThick)/2,
3259                                        kExternalTrayLen/2);
3260
3261   // The cooling tube inside the forward tray: a TubeSeg
3262   Double_t zelong = (kForwardTraySecondHigh - 2*kForwardTrayThick
3263                 - 2*forwTrayWall->GetDY() - kCoolingTubeRmax)*SinD(kTrayAZRot);
3264   Double_t zlen = (zelong + kForwardTrayTotalLen)/2;
3265   TGeoTubeSeg *coolTubeForw = new TGeoTubeSeg(kCoolingTubeRmin,
3266                                               kCoolingTubeRmax, zlen, 0, 360);
3267
3268   // The cooling tube inside the external tray: a Ctub
3269   TGeoCtub *coolTubeExt = new TGeoCtub(kCoolingTubeRmin, kCoolingTubeRmax,
3270                                        kExternalTrayLen/2, 0, 360,
3271                                        0, SinD(kTrayAZRot),-CosD(kTrayAZRot),
3272                                        0,                0,               1);
3273
3274   // The optical fibers inside the forward tray: a BBox
3275   TGeoBBox *optFibsForw = new TGeoBBox(kOpticalFibersSect/2,
3276                                        kOpticalFibersSect/2,
3277                                        kForwardTrayTotalLen/2);
3278
3279   // The optical fibers inside the external tray: a Xtru
3280   TGeoXtru *optFibsExt = new TGeoXtru(2);
3281   optFibsExt->SetName("ITSsuppSPDExtTrayOptFibs");
3282
3283   yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
3284            + 2*forwTrayWall->GetDY();
3285   xprof[0] = yprof[0]*TanD(kTrayAZRot);
3286   xprof[1] = kExternalTrayLen;
3287   yprof[1] = yprof[0];
3288   xprof[2] = xprof[1];
3289   yprof[2] = yprof[1] + kOpticalFibersSect;
3290   yprof[3] = yprof[2];
3291   xprof[3] = yprof[2]*TanD(kTrayAZRot);
3292
3293   optFibsExt->DefinePolygon(4, xprof, yprof);
3294   optFibsExt->DefineSection(0, 0);
3295   optFibsExt->DefineSection(1, kOpticalFibersSect);
3296
3297   // The Low Voltage cables inside the forward tray: a BBox
3298   TGeoBBox *lowCablesForw = new TGeoBBox(kLowVoltageCableSect/2,
3299                                          kLowVoltageCableSect/2,
3300                                          kForwardTrayTotalLen/2);
3301
3302   // The Low Voltage inside the external tray: a Xtru
3303   TGeoXtru *lowCablesExt = new TGeoXtru(2);
3304   lowCablesExt->SetName("ITSsuppSPDExtTrayLowVoltage");
3305
3306   yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
3307            + 2*forwTrayWall->GetDY();
3308   xprof[0] = yprof[0]*TanD(kTrayAZRot);
3309   xprof[1] = kExternalTrayLen;
3310   yprof[1] = yprof[0];
3311   xprof[2] = xprof[1];
3312   yprof[2] = yprof[1] + kLowVoltageCableSect;
3313   yprof[3] = yprof[2];
3314   xprof[3] = yprof[2]*TanD(kTrayAZRot);
3315
3316   lowCablesExt->DefinePolygon(4, xprof, yprof);
3317   lowCablesExt->DefineSection(0, 0);
3318   lowCablesExt->DefineSection(1, kLowVoltageCableSect);
3319
3320
3321   // We have all shapes: now create the real volumes
3322   TGeoMedium *medAl   = mgr->GetMedium("ITS_ALUMINUM$");
3323   TGeoMedium *medIn   = mgr->GetMedium("ITS_INOX$");
3324   TGeoMedium *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!!TO BE CHECKED!!
3325   TGeoMedium *medLVC  = mgr->GetMedium("ITS_SPD_LOWCABLES$");
3326
3327   TGeoVolume *forwTrayABase = new TGeoVolume("ITSsuppSPDSideAForwTrayABase",
3328                                             forwTrayLowerFace, medAl);
3329
3330   forwTrayABase->SetVisibility(kTRUE);
3331   forwTrayABase->SetLineColor(6); // Purple
3332   forwTrayABase->SetLineWidth(1);
3333   forwTrayABase->SetFillColor(forwTrayABase->GetLineColor());
3334   forwTrayABase->SetFillStyle(4000); // 0% transparent
3335
3336   TGeoVolume *forwTrayASide = new TGeoVolume("ITSsuppSPDSideAForwTrayASide",
3337                                             forwTraySideFace, medAl);
3338
3339   forwTrayASide->SetVisibility(kTRUE);
3340   forwTrayASide->SetLineColor(6); // Purple
3341   forwTrayASide->SetLineWidth(1);
3342   forwTrayASide->SetFillColor(forwTrayASide->GetLineColor());
3343   forwTrayASide->SetFillStyle(4000); // 0% transparent
3344
3345   TGeoVolume *forwTrayACoverShort = new TGeoVolume("ITSsuppSPDSideAForwTrayASC",
3346                                                   forwTrayShortCover, medAl);
3347
3348   forwTrayACoverShort->SetVisibility(kTRUE);
3349   forwTrayACoverShort->SetLineColor(6); // Purple
3350   forwTrayACoverShort->SetLineWidth(1);
3351   forwTrayACoverShort->SetFillColor(forwTrayACoverShort->GetLineColor());
3352   forwTrayACoverShort->SetFillStyle(4000); // 0% transparent
3353
3354   TGeoVolume *forwTrayACoverLong = new TGeoVolume("ITSsuppSPDSideAForwTrayALC",
3355                                                  forwTrayLongCover, medAl);
3356
3357   forwTrayACoverLong->SetVisibility(kTRUE);
3358   forwTrayACoverLong->SetLineColor(6); // Purple
3359   forwTrayACoverLong->SetLineWidth(1);
3360   forwTrayACoverLong->SetFillColor(forwTrayACoverLong->GetLineColor());
3361   forwTrayACoverLong->SetFillStyle(4000); // 0% transparent
3362
3363   TGeoVolume *forwTrayAWing = new TGeoVolume("ITSsuppSPDSideAForwTrayAWing",
3364                                              forwTrayWing, medAl);
3365
3366   forwTrayAWing->SetVisibility(kTRUE);
3367   forwTrayAWing->SetLineColor(6); // Purple
3368   forwTrayAWing->SetLineWidth(1);
3369   forwTrayAWing->SetFillColor(forwTrayAWing->GetLineColor());
3370   forwTrayAWing->SetFillStyle(4000); // 0% transparent
3371
3372   TGeoVolume *forwTrayAPlane = new TGeoVolume("ITSsuppSPDSideAForwTrayAPlane",
3373                                               forwTrayPlane, medAl);
3374
3375   forwTrayAPlane->SetVisibility(kTRUE);
3376   forwTrayAPlane->SetLineColor(6); // Purple
3377   forwTrayAPlane->SetLineWidth(1);
3378   forwTrayAPlane->SetFillColor(forwTrayAPlane->GetLineColor());
3379   forwTrayAPlane->SetFillStyle(4000); // 0% transparent
3380
3381   TGeoVolume *forwTrayAWall = new TGeoVolume("ITSsuppSPDSideAForwTrayAWall",
3382                                              forwTrayWall, medAl);
3383
3384   forwTrayAWall->SetVisibility(kTRUE);
3385   forwTrayAWall->SetLineColor(6); // Purple
3386   forwTrayAWall->SetLineWidth(1);
3387   forwTrayAWall->SetFillColor(forwTrayAWall->GetLineColor());
3388   forwTrayAWall->SetFillStyle(4000); // 0% transparent
3389
3390   TGeoVolume *extTrayAHorFace = new TGeoVolume("ITSsuppSPDSideAExtTrayHorFace",
3391                                                extTrayHorFace, medAl);
3392
3393   extTrayAHorFace->SetVisibility(kTRUE);
3394   extTrayAHorFace->SetLineColor(6); // Purple
3395   extTrayAHorFace->SetLineWidth(1);
3396   extTrayAHorFace->SetFillColor(extTrayAHorFace->GetLineColor());
3397   extTrayAHorFace->SetFillStyle(4000); // 0% transparent
3398
3399   TGeoVolume *extTrayAVerFace = new TGeoVolume("ITSsuppSPDSideAExtTrayVerFace",
3400                                                extTrayVerFace, medAl);
3401
3402   extTrayAVerFace->SetVisibility(kTRUE);
3403   extTrayAVerFace->SetLineColor(6); // Purple
3404   extTrayAVerFace->SetLineWidth(1);
3405   extTrayAVerFace->SetFillColor(extTrayAVerFace->GetLineColor());
3406   extTrayAVerFace->SetFillStyle(4000); // 0% transparent
3407
3408   TGeoVolume *extTrayAWall = new TGeoVolume("ITSsuppSPDSideAExtTrayWall",
3409                                             extTrayWall, medAl);
3410
3411   extTrayAWall->SetVisibility(kTRUE);
3412   extTrayAWall->SetLineColor(6); // Purple
3413   extTrayAWall->SetLineWidth(1);
3414   extTrayAWall->SetFillColor(extTrayAWall->GetLineColor());
3415   extTrayAWall->SetFillStyle(4000); // 0% transparent
3416
3417   TGeoVolume *forwCoolTube = new TGeoVolume("ITSsuppSPDSideAForwTrayCoolTube",
3418                                             coolTubeForw, medIn);
3419
3420   forwCoolTube->SetVisibility(kTRUE);
3421   forwCoolTube->SetLineColor(kGray); // as in GeometrySPD
3422   forwCoolTube->SetLineWidth(1);
3423   forwCoolTube->SetFillColor(forwCoolTube->GetLineColor());
3424   forwCoolTube->SetFillStyle(4000); // 0% transparent
3425
3426   TGeoVolume *extCoolTube = new TGeoVolume("ITSsuppSPDSideAExtTrayCoolTube",
3427                                            coolTubeExt, medIn);
3428
3429   extCoolTube->SetVisibility(kTRUE);
3430   extCoolTube->SetLineColor(kGray); // as in GeometrySPD
3431   extCoolTube->SetLineWidth(1);
3432   extCoolTube->SetFillColor(extCoolTube->GetLineColor());
3433   extCoolTube->SetFillStyle(4000); // 0% transparent
3434
3435   TGeoVolume *forwOptFibs = new TGeoVolume("ITSsuppSPDSideAForwTrayOptFibs",
3436                                            optFibsForw, medFibs);
3437
3438   forwOptFibs->SetVisibility(kTRUE);
3439   forwOptFibs->SetLineColor(kOrange); // Orange
3440   forwOptFibs->SetLineWidth(1);
3441   forwOptFibs->SetFillColor(forwOptFibs->GetLineColor());
3442   forwOptFibs->SetFillStyle(4000); // 0% transparent
3443
3444   TGeoVolume *extOptFibs = new TGeoVolume("ITSsuppSPDSideAExtTrayOptFibs",
3445                                           optFibsExt, medFibs);
3446
3447   extOptFibs->SetVisibility(kTRUE);
3448   extOptFibs->SetLineColor(kOrange); // Orange
3449   extOptFibs->SetLineWidth(1);
3450   extOptFibs->SetFillColor(extOptFibs->GetLineColor());
3451   extOptFibs->SetFillStyle(4000); // 0% transparent
3452
3453   TGeoVolume *forwLowCabs = new TGeoVolume("ITSsuppSPDSideAForwTrayLowCabs",
3454                                            lowCablesForw, medLVC);
3455
3456   forwLowCabs->SetVisibility(kTRUE);
3457   forwLowCabs->SetLineColor(kRed); // Red
3458   forwLowCabs->SetLineWidth(1);
3459   forwLowCabs->SetFillColor(forwLowCabs->GetLineColor());
3460   forwLowCabs->SetFillStyle(4000); // 0% transparent
3461
3462   TGeoVolume *extLowCabs = new TGeoVolume("ITSsuppSPDSideAExtTrayLowCabs",
3463                                           lowCablesExt, medLVC);
3464
3465   extLowCabs->SetVisibility(kTRUE);
3466   extLowCabs->SetLineColor(kRed); // Red
3467   extLowCabs->SetLineWidth(1);
3468   extLowCabs->SetFillColor(extLowCabs->GetLineColor());
3469   extLowCabs->SetFillStyle(4000); // 0% transparent
3470
3471
3472   // Now build up the trays
3473   yloc = forwTrayLowerFace->GetDY();
3474   zloc = forwTrayLowerFace->GetDZ();
3475   cableTrayAForw->AddNode(forwTrayABase, 1,
3476                       new TGeoTranslation(0, yloc, zloc));
3477
3478   xloc = kForwardTrayWide/2;
3479   cableTrayAForw->AddNode(forwTrayASide, 1,
3480                       new TGeoCombiTrans( xloc, 0, 0,
3481                                          new TGeoRotation("",90,-90,-90)));
3482   cableTrayAForw->AddNode(forwTrayASide, 2,
3483                       new TGeoCombiTrans(-xloc+kForwardTrayThick, 0, 0,
3484                                          new TGeoRotation("",90,-90,-90)));
3485
3486   yloc = kForwardTrayFirstHigh - forwTrayShortCover->GetDY();
3487   zloc = forwTrayShortCover->GetDZ();
3488   cableTrayAForw->AddNode(forwTrayACoverShort, 1,
3489                       new TGeoTranslation(0, yloc, zloc));
3490
3491   yloc = kForwardTraySecondHigh - forwTrayLongCover->GetDY();
3492   zloc = kForwardTrayFirstLen + forwTrayLongCover->GetDZ();
3493   cableTrayAForw->AddNode(forwTrayACoverLong, 1,
3494                       new TGeoTranslation(0, yloc, zloc));
3495
3496   xloc = kForwardTrayWide/2 - kForwardTrayThick - forwTrayWing->GetDX();
3497   yloc = kForwardTrayFirstHigh - kForwardTrayThick - forwTrayWing->GetDY();
3498   zloc = kForwardTrayFirstLen - forwTrayWing->GetDZ();
3499   cableTrayAForw->AddNode(forwTrayAWing, 1,
3500                       new TGeoTranslation( xloc, yloc, zloc));
3501   cableTrayAForw->AddNode(forwTrayAWing, 2,
3502                       new TGeoTranslation(-xloc, yloc, zloc));
3503
3504   yloc = kForwardTrayThick + kForwardTrayInterSpace - forwTrayPlane->GetDY();
3505   zloc = forwTrayPlane->GetDZ();
3506   cableTrayAForw->AddNode(forwTrayAPlane, 1,
3507                       new TGeoTranslation(0, yloc, zloc));
3508
3509   yloc = kForwardTrayThick + forwTrayWall->GetDY();
3510   zloc = forwTrayWall->GetDZ();
3511   cableTrayAForw->AddNode(forwTrayAWall, 1,
3512                       new TGeoTranslation(0, yloc, zloc));
3513
3514   yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY()
3515        + coolTubeForw->GetRmax();
3516   zloc = coolTubeForw->GetDz();
3517   cableTrayAForw->AddNode(forwCoolTube, 1,
3518                       new TGeoTranslation(0, yloc, zloc));
3519
3520   xloc = optFibsForw->GetDX() + coolTubeForw->GetRmax();
3521   yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() + optFibsForw->GetDY();
3522   zloc = optFibsForw->GetDZ();
3523   cableTrayAForw->AddNode(forwOptFibs, 1,
3524                       new TGeoTranslation(xloc, yloc, zloc));
3525
3526   xloc = lowCablesForw->GetDX() + coolTubeForw->GetRmax();
3527   yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() +lowCablesForw->GetDY();
3528   zloc = lowCablesForw->GetDZ();
3529   cableTrayAForw->AddNode(forwLowCabs, 1,
3530                       new TGeoTranslation(-xloc, yloc, zloc));
3531
3532   // To simplify following placement in MARS, origin is on top
3533   yloc = -kExternalTrayHigh + kExternalTrayThick/2;
3534   zloc = kExternalTrayLen/2;
3535   cableTrayAExt->AddNode(extTrayAHorFace, 1,
3536                       new TGeoTranslation( 0, yloc, zloc));
3537
3538   xloc = kExternalTrayWide/2 - kExternalTrayThick/2;
3539   yloc = -kExternalTrayHigh/2;
3540   cableTrayAExt->AddNode(extTrayAVerFace, 1,
3541                       new TGeoTranslation( xloc, yloc, zloc));
3542   cableTrayAExt->AddNode(extTrayAVerFace, 2,
3543                       new TGeoTranslation(-xloc, yloc, zloc));
3544
3545   yloc = -kExternalTrayThick/2;
3546   cableTrayAExt->AddNode(extTrayAHorFace, 2,
3547                       new TGeoTranslation( 0, yloc, zloc));
3548
3549   yloc = -kExternalTrayHigh
3550        + kExternalTrayThick + kForwardTrayInterSpace - kExternalTrayThick/2;
3551   cableTrayAExt->AddNode(extTrayAHorFace, 3,
3552                       new TGeoTranslation( 0, yloc, zloc));
3553
3554   yloc = -kExternalTrayHigh + kExternalTrayThick + extTrayWall->GetDY();
3555   cableTrayAExt->AddNode(extTrayAWall, 1,
3556                       new TGeoTranslation( 0, yloc, zloc));
3557
3558   yloc = -kExternalTrayHigh + 2*kExternalTrayThick + 2*extTrayWall->GetDY()
3559        + coolTubeExt->GetRmax();
3560   zloc = coolTubeExt->GetDz();
3561   cableTrayAExt->AddNode(extCoolTube, 1,
3562                       new TGeoTranslation(0, yloc, zloc));
3563
3564   xloc = kOpticalFibersSect + coolTubeExt->GetRmax();
3565   cableTrayAExt->AddNode(extOptFibs, 1,
3566                       new TGeoCombiTrans( xloc, 0, 0,
3567                                          new TGeoRotation("",90,-90,-90)));
3568
3569   xloc = kLowVoltageCableSect + coolTubeExt->GetRmax();
3570   cableTrayAExt->AddNode(extLowCabs, 1,
3571                       new TGeoCombiTrans(-xloc, 0, 0,
3572                                          new TGeoRotation("",90,-90,-90)));
3573
3574
3575   // Finally put everything in the mother volume
3576   Double_t rExtTray = kTrayAR2Trans + kExternalTrayHigh;
3577
3578   moth->AddNode(cableTrayAForw,1,
3579                 new TGeoTranslation( 0, kTrayAR1Trans, kTrayAZTrans));
3580   moth->AddNode(cableTrayAForw,2,
3581                 new TGeoCombiTrans(  0,-kTrayAR1Trans, kTrayAZTrans,
3582                                     new TGeoRotation("",180, 0, 0)));
3583
3584   yloc = kTrayAR1Trans + kExternalTrayHigh;
3585   zloc = kTrayAZTrans + kForwardTrayTotalLen;
3586   moth->AddNode(cableTrayAExt,1,
3587                 new TGeoCombiTrans( 0, yloc, zloc,
3588                                     new TGeoRotation("",  0,-kTrayAZRot, 0)));
3589   moth->AddNode(cableTrayAExt,2,
3590                 new TGeoCombiTrans( 0,-yloc, zloc,
3591                                     new TGeoRotation("",180,-kTrayAZRot, 0)));
3592
3593   alpharot = kTrayAFirstRotAng + kTrayASecondRotAng;
3594   xloc = kTrayAR2Trans*SinD(alpharot);
3595   yloc = kTrayAR2Trans*CosD(alpharot);
3596   moth->AddNode(cableTrayAForw,3,
3597                             new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
3598                             new TGeoRotation("",-alpharot,0,0)   )   );
3599   xloc = rExtTray*SinD(alpharot);
3600   yloc = rExtTray*CosD(alpharot);
3601   moth->AddNode(cableTrayAExt,3,
3602                             new TGeoCombiTrans( xloc, yloc, zloc,
3603                             new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );
3604
3605   alpharot += 180;
3606   xloc = kTrayAR2Trans*SinD(alpharot);
3607   yloc = kTrayAR2Trans*CosD(alpharot);
3608   moth->AddNode(cableTrayAForw,4,
3609                             new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
3610                             new TGeoRotation("",-alpharot,0,0)   )   );
3611   xloc = rExtTray*SinD(alpharot);
3612   yloc = rExtTray*CosD(alpharot);
3613   moth->AddNode(cableTrayAExt,4,
3614                             new TGeoCombiTrans( xloc, yloc, zloc,
3615                             new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );
3616
3617   alpharot = - kTrayAFirstRotAng - kTrayASecondRotAng;
3618   xloc = kTrayAR2Trans*SinD(alpharot);
3619   yloc = kTrayAR2Trans*CosD(alpharot);
3620   moth->AddNode(cableTrayAForw,5,
3621                             new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
3622                             new TGeoRotation("",-alpharot,0,0)   )   );
3623   xloc = rExtTray*SinD(alpharot);
3624   yloc = rExtTray*CosD(alpharot);
3625   moth->AddNode(cableTrayAExt,5,
3626                             new TGeoCombiTrans( xloc, yloc, zloc,
3627                             new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );
3628
3629   alpharot += 180;
3630   xloc = kTrayAR2Trans*SinD(alpharot);
3631   yloc = kTrayAR2Trans*CosD(alpharot);
3632   moth->AddNode(cableTrayAForw,6,
3633                             new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
3634                             new TGeoRotation("",-alpharot,0,0)   )   );
3635   xloc = rExtTray*SinD(alpharot);
3636   yloc = rExtTray*CosD(alpharot);
3637   moth->AddNode(cableTrayAExt,6,
3638                             new TGeoCombiTrans( xloc, yloc, zloc,
3639                             new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );
3640
3641   alpharot = kTrayAFirstRotAng + 3*kTrayASecondRotAng;
3642   xloc = kTrayAR2Trans*SinD(alpharot);
3643   yloc = kTrayAR2Trans*CosD(alpharot);
3644   moth->AddNode(cableTrayAForw,7,
3645                             new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
3646                             new TGeoRotation("",-alpharot,0,0)   )   );
3647   xloc = rExtTray*SinD(alpharot);
3648   yloc = rExtTray*CosD(alpharot);
3649   moth->AddNode(cableTrayAExt,7,
3650                             new TGeoCombiTrans( xloc, yloc, zloc,
3651                             new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );
3652
3653   alpharot += 180;
3654   xloc = kTrayAR2Trans*SinD(alpharot);
3655   yloc = kTrayAR2Trans*CosD(alpharot);
3656   moth->AddNode(cableTrayAForw,8,
3657                             new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
3658                             new TGeoRotation("",-alpharot,0,0)   )   );
3659   xloc = rExtTray*SinD(alpharot);
3660   yloc = rExtTray*CosD(alpharot);
3661   moth->AddNode(cableTrayAExt,8,
3662                             new TGeoCombiTrans( xloc, yloc, zloc,
3663                             new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );
3664
3665   alpharot = - kTrayAFirstRotAng - 3*kTrayASecondRotAng;
3666   xloc = kTrayAR2Trans*SinD(alpharot);
3667   yloc = kTrayAR2Trans*CosD(alpharot);
3668   moth->AddNode(cableTrayAForw,9,
3669                             new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
3670                             new TGeoRotation("",-alpharot,0,0)   )   );
3671   xloc = rExtTray*SinD(alpharot);
3672   yloc = rExtTray*CosD(alpharot);
3673   moth->AddNode(cableTrayAExt,9,
3674                             new TGeoCombiTrans( xloc, yloc, zloc,
3675                             new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );
3676
3677   alpharot += 180;
3678   xloc = kTrayAR2Trans*SinD(alpharot);
3679   yloc = kTrayAR2Trans*CosD(alpharot);
3680   moth->AddNode(cableTrayAForw,10,
3681                             new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
3682                             new TGeoRotation("",-alpharot,0,0)   )   );
3683   xloc = rExtTray*SinD(alpharot);
3684   yloc = rExtTray*CosD(alpharot);
3685   moth->AddNode(cableTrayAExt,10,
3686                             new TGeoCombiTrans( xloc, yloc, zloc,
3687                             new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );
3688
3689
3690   return;
3691 }
3692
3693 //______________________________________________________________________
3694 void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth,
3695                                                   TGeoManager *mgr){
3696 //
3697 // Creates the SDD cable trays which are outside the ITS support cones
3698 // but still inside the TPC on Side A
3699 // (part of this code is taken or anyway inspired to ServicesCableSupport
3700 // method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
3701 //
3702 // Input:
3703 //         moth : the TGeoVolume owing the volume structure
3704 //         mgr  : the GeoManager (default gGeoManager)
3705 // Output:
3706 //
3707 // Created:         ???       Bjorn S. Nilsen
3708 // Updated:       5 Jan 2010  Mario Sitta
3709 // Updated:      26 Feb 2010  Mario Sitta
3710 //
3711 // Technical data are taken from AutoCAD drawings, L.Simonetti technical
3712 // drawings and other (oral) information given by F.Tosello
3713 //
3714
3715   // Overall position and rotation of the A-Side Cable Trays
3716   // (parts of 0872/G/D)
3717   const Double_t kTrayARTrans            =  410.00 *fgkmm;
3718   const Double_t kTrayAZTrans            = 1011.00 *fgkmm;
3719   const Double_t kTrayAZToSupportRing    =  435.00 *fgkmm;
3720   const Double_t kExternTrayZTrans       =  853.00 *fgkmm;
3721   const Double_t kExternCoverYTrans      =    2.00 *fgkmm;
3722   const Double_t kTrayAZRot              = (180-169.5);// Degrees
3723   const Double_t kTrayAFirstRotAng       =   22.00;    // Degrees
3724   const Double_t kTrayASecondRotAng      =   15.00;    // Degrees
3725
3726   const Double_t kForwardTrayTailHeight  =  100.00 *fgkmm; // Computed
3727   const Double_t kForwardTrayTotalHeight =  170.00 *fgkmm; // Computed
3728   const Double_t kForwardTrayUpperLength =  405.00 *fgkmm; // Computed
3729   const Double_t kForwardCoverLength     =  380.00 *fgkmm;
3730   const Double_t kForwardCoverWide       =  133.00 *fgkmm;
3731   const Double_t kForwardCoverHeight     =   10.00 *fgkmm;
3732   const Double_t kForwardCoverThick      =    1.00 *fgkmm;
3733
3734   const Double_t kExternTrayTotalLen     = 1200.00 *fgkmm;
3735   const Double_t kExternTrayTotalHeight  =   52.00 *fgkmm;
3736   const Double_t kExternCoverLen         = kExternTrayTotalLen;
3737   const Double_t kExternCoverThick       =    5.00 *fgkmm;
3738   const Double_t kExternCoverSideThick   =    3.00 *fgkmm;
3739
3740   const Int_t    kForwardTrayNpoints     =    8;
3741
3742
3743   // Local variables
3744   Double_t xprof[kForwardTrayNpoints], yprof[kForwardTrayNpoints];
3745   Double_t xloc, yloc, zloc, alpharot;
3746
3747
3748   // The whole tray as an assembly
3749   TGeoVolumeAssembly *cableTrayA = new TGeoVolumeAssembly("ITSsupportSDDTrayA");
3750
3751
3752   // First create all needed shapes
3753
3754   // The forward tray is very complex and deserves a dedicated method
3755   TGeoVolumeAssembly *forwardTray = CreateSDDForwardTraySideA(mgr);
3756
3757   // The forward cover: a Xtru
3758   TGeoXtru *forwardCover = new TGeoXtru(2);
3759   forwardCover->SetName("ITSsuppSDDForwCover");
3760
3761   xprof[0] = kForwardCoverWide/2;
3762   yprof[0] = kForwardCoverHeight;
3763   xprof[1] = xprof[0];
3764   yprof[1] = 0;
3765   xprof[2] = xprof[1] - kForwardCoverThick;
3766   yprof[2] = yprof[1];
3767   xprof[3] = xprof[2];
3768   yprof[3] = yprof[0] - kForwardCoverThick;
3769
3770   // We did the right side, now reflex on the left side
3771   for (Int_t jp = 0; jp < 4; jp++) {
3772     xprof[4+jp] = -xprof[3-jp];
3773     yprof[4+jp] =  yprof[3-jp];
3774   }
3775
3776   forwardCover->DefinePolygon(8, xprof, yprof);
3777   forwardCover->DefineSection(0, 0);
3778   forwardCover->DefineSection(1, kForwardCoverLength);
3779
3780   // The external tray (as 0872/G/D/03): a Xtru
3781   TGeoXtru *externalTray = CreateSDDSSDTraysSideA(kExternTrayTotalLen,
3782                                                   kExternTrayTotalHeight);
3783
3784   // The external covers: a Composite Shape
3785   TGeoCompositeShape *externCover = CreateTrayAExternalCover(kExternCoverLen);
3786
3787
3788   // We have all shapes: now create the real volumes
3789   TGeoMedium *medAl    = mgr->GetMedium("ITS_ALUMINUM$");
3790   TGeoMedium *medAntic = mgr->GetMedium("ITS_ANTICORODAL$");
3791
3792   TGeoVolume *forwardTrayCover = new TGeoVolume("ITSsuppSDDSideAForwTrayCover",
3793                                                 forwardCover, medAl);
3794
3795   forwardTrayCover->SetVisibility(kTRUE);
3796   forwardTrayCover->SetLineColor(kMagenta+1); // Purple
3797   forwardTrayCover->SetLineWidth(1);
3798   forwardTrayCover->SetFillColor(forwardTrayCover->GetLineColor());
3799   forwardTrayCover->SetFillStyle(4000); // 0% transparent
3800
3801   TGeoVolume *externalTraySDD = new TGeoVolume("ITSsuppSDDSideAExternalTray",
3802                                                externalTray, medAl);
3803
3804   externalTraySDD->SetVisibility(kTRUE);
3805   externalTraySDD->SetLineColor(6); // Purple
3806   externalTraySDD->SetLineWidth(1);
3807   externalTraySDD->SetFillColor(externalTraySDD->GetLineColor());
3808   externalTraySDD->SetFillStyle(4000); // 0% transparent
3809
3810   TGeoVolume *externTrayCover = new TGeoVolume("ITSsuppSDDSideAExtTrayCover",
3811                                                externCover, medAntic);
3812
3813   externTrayCover->SetVisibility(kTRUE);
3814   externTrayCover->SetLineColor(kMagenta+1); // Purple
3815   externTrayCover->SetLineWidth(1);
3816   externTrayCover->SetFillColor(externTrayCover->GetLineColor());
3817   externTrayCover->SetFillStyle(4000); // 0% transparent
3818
3819
3820   // Now build up the tray
3821   yloc = kForwardTrayTotalHeight - forwardCover->GetY(3) +
3822          kExternTrayTotalHeight +
3823          kExternCoverSideThick - kForwardTrayTailHeight;
3824   zloc = kTrayAZToSupportRing - kForwardCoverLength;
3825   cableTrayA->AddNode(forwardTrayCover, 1,
3826                       new TGeoTranslation( 0, yloc, zloc) );
3827
3828   Double_t totalhi = kExternTrayTotalHeight + kExternCoverThick
3829                    - kExternCoverYTrans;
3830
3831   yloc = totalhi*(1 - CosD(kTrayAZRot));
3832   zloc = kExternTrayZTrans + totalhi*SinD(kTrayAZRot);
3833   cableTrayA->AddNode(externalTraySDD, 1,
3834                       new TGeoCombiTrans( 0, yloc, zloc,
3835                       new TGeoRotation("", 0,-kTrayAZRot, 0)        ) );
3836
3837   yloc = kExternTrayTotalHeight - kExternCoverYTrans;
3838   zloc = kExternTrayZTrans - yloc*SinD(kTrayAZRot);
3839   yloc *= CosD(kTrayAZRot);
3840   zloc += totalhi*SinD(kTrayAZRot);
3841   yloc += totalhi*(1 - CosD(kTrayAZRot));
3842   cableTrayA->AddNode(externTrayCover,1,
3843                       new TGeoCombiTrans( 0, yloc, zloc,
3844                       new TGeoRotation("", 0,-kTrayAZRot, 0)        ) );
3845
3846
3847   // Finally put everything in the mother volume
3848   alpharot = -kTrayAFirstRotAng;
3849   xloc = kTrayARTrans*SinD(alpharot);
3850   yloc = kTrayARTrans*CosD(alpharot);
3851   zloc = kTrayAZTrans;
3852   moth->AddNode(cableTrayA,1,
3853                             new TGeoCombiTrans( xloc, yloc, zloc,
3854                             new TGeoRotation("",-alpharot,0,0)   )   );
3855
3856   alpharot += 180;
3857   xloc = kTrayARTrans*SinD(alpharot);
3858   yloc = kTrayARTrans*CosD(alpharot);
3859   moth->AddNode(cableTrayA,2,
3860                             new TGeoCombiTrans( xloc, yloc, zloc,
3861                             new TGeoRotation("",-alpharot,0,0)   )   );
3862
3863   alpharot = kTrayAFirstRotAng + 2*kTrayASecondRotAng;
3864   xloc = kTrayARTrans*SinD(alpharot);
3865   yloc = kTrayARTrans*CosD(alpharot);
3866   moth->AddNode(cableTrayA,3,
3867                             new TGeoCombiTrans( xloc, yloc, zloc,
3868                             new TGeoRotation("",-alpharot,0,0)   )   );
3869
3870   alpharot += 180;
3871   xloc = kTrayARTrans*SinD(alpharot);
3872   yloc = kTrayARTrans*CosD(alpharot);
3873   moth->AddNode(cableTrayA,4,
3874                             new TGeoCombiTrans( xloc, yloc, zloc,
3875                             new TGeoRotation("",-alpharot,0,0)   )   );
3876
3877   // To avoid putting an assembly inside another assembly,
3878   // the forwardTray is put directly in the mother volume
3879   Double_t rforw = kTrayARTrans + kExternTrayTotalHeight +
3880                    kExternCoverSideThick -
3881                    kForwardTrayTailHeight;
3882
3883   alpharot = -kTrayAFirstRotAng;
3884   xloc = rforw*SinD(alpharot);
3885   yloc = rforw*CosD(alpharot);
3886   zloc = kTrayAZTrans + kTrayAZToSupportRing - kForwardTrayUpperLength;
3887
3888   moth->AddNode(forwardTray,1,
3889                             new TGeoCombiTrans( xloc, yloc, zloc,
3890                             new TGeoRotation("",-alpharot,0,0)   )   );
3891
3892   alpharot += 180;
3893   xloc = rforw*SinD(alpharot);
3894   yloc = rforw*CosD(alpharot);
3895   moth->AddNode(forwardTray,2,
3896                             new TGeoCombiTrans( xloc, yloc, zloc,
3897                             new TGeoRotation("",-alpharot,0,0)   )   );
3898
3899   alpharot = kTrayAFirstRotAng + 2*kTrayASecondRotAng;
3900   xloc = rforw*SinD(alpharot);
3901   yloc = rforw*CosD(alpharot);
3902   moth->AddNode(forwardTray,3,
3903                             new TGeoCombiTrans( xloc, yloc, zloc,
3904                             new TGeoRotation("",-alpharot,0,0)   )   );
3905
3906   alpharot += 180;
3907   xloc = rforw*SinD(alpharot);
3908   yloc = rforw*CosD(alpharot);
3909   moth->AddNode(forwardTray,4,
3910                             new TGeoCombiTrans( xloc, yloc, zloc,
3911                             new TGeoRotation("",-alpharot,0,0)   )   );
3912
3913
3914   return;
3915 }
3916
3917 //______________________________________________________________________
3918 void AliITSv11GeometrySupport::SSDCableTraysSideA(TGeoVolume *moth,
3919                                                   TGeoManager *mgr){
3920 //
3921 // Creates the SSD cable trays which are outside the ITS support cones
3922 // but still inside the TPC on Side A
3923 // (part of this code is taken or anyway inspired to ServicesCableSupport
3924 // method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
3925 //
3926 // Input:
3927 //         moth : the TGeoVolume owing the volume structure
3928 //         mgr  : the GeoManager (default gGeoManager)
3929 // Output:
3930 //
3931 // Created:         ???       Bjorn S. Nilsen
3932 // Updated:      30 Dec 2009  Mario Sitta
3933 //
3934 // Technical data are taken from AutoCAD drawings, L.Simonetti technical
3935 // drawings and other (oral) information given by F.Tosello and
3936 // Ton van den Brink
3937 // Cables and cooling tubes are approximated with proper materials and
3938 // rectangular cross sections, always preserving the total material budget.
3939 //
3940
3941   // Dimensions and positions of the A-Side Cable Trays
3942   // (parts of 0872/G/D)
3943   const Double_t kTrayARTrans            =  410.00 *fgkmm;
3944   const Double_t kTrayAZTrans            = 1011.00 *fgkmm;
3945   const Double_t kForwardSideYTrans      =   12.00 *fgkmm;//!!!TO BE CHECKED!!!
3946   const Double_t kCoversYTrans           =    2.00 *fgkmm;
3947   const Double_t kTrayAZRot              = (180-169.5);// Degrees
3948   const Double_t kTrayAFirstRotAng       =   22.00;    // Degrees
3949   const Double_t kTrayASecondRotAng      =   15.00;    // Degrees
3950
3951   const Double_t kTrayTotalHeight        =   52.00 *fgkmm;
3952   const Double_t kTrayHeighToBend        =   32.00 *fgkmm;
3953   const Double_t kTrayWidth              =  130.00 *fgkmm;
3954   const Double_t kTrayThick              =    2.00 *fgkmm;
3955
3956   const Double_t kTrayBendAngle          =   22.00 *TMath::DegToRad();
3957
3958   const Double_t kForwardTrayTotalLen    =  853.00 *fgkmm;
3959   const Double_t kForwardTrayFirstLen    =  350.00 *fgkmm;
3960   const Double_t kForwardTrayFirstHeight =   47.00 *fgkmm;
3961   const Double_t kForwardCoverLen        =  420.00 *fgkmm;
3962
3963   const Double_t kForwardSideLength      = kForwardTrayFirstLen;//!!!TO BE CHECKED!!!
3964   const Double_t kForwardSideHeight      =   90.00 *fgkmm;//!!!TO BE CHECKED!!!
3965   const Double_t kForwardSideThick       =    1.00 *fgkmm;//!!!TO BE CHECKED!!!
3966   const Double_t kForwardCoverHeight     =   10.00 *fgkmm;//!!!TO BE CHECKED!!!
3967
3968   const Double_t kExternalTrayTotalLen   = 1200.00 *fgkmm;
3969   const Double_t kExternalCoverLen       = kExternalTrayTotalLen;
3970   const Double_t kExternalCoverThick     =    5.00 *fgkmm;
3971
3972   const Int_t    kForwardTrayNpoints     =   16;
3973
3974   const Double_t kServicesWidth          =  100.00 *fgkmm;
3975   const Double_t kCopperHeight           =   11.20 *fgkmm;// 1120 mm^2
3976   const Double_t kCablePlasticHeight     =   11.50 *fgkmm;// 1150 mm^2
3977   const Double_t kCoolingWaterHeight     =    2.65 *fgkmm;//  265 mm^2
3978   const Double_t kPoliUrethaneHeight     =    4.62 *fgkmm;//  462 mm^2
3979
3980
3981   // Local variables
3982   Double_t xprof[kForwardTrayNpoints], yprof[kForwardTrayNpoints];
3983   Double_t xloc, yloc, zloc, alpharot, totalhi;
3984
3985
3986   // The two tray components as assemblies
3987   TGeoVolumeAssembly *cableTrayAFR =
3988     new TGeoVolumeAssembly("ITSsupportSSDTrayAForwRear");
3989   TGeoVolumeAssembly *cableTrayAExt =
3990     new TGeoVolumeAssembly("ITSsupportSSDTrayAExt");
3991
3992
3993   // First create all needed shapes
3994
3995   // The first part of the forward tray (part of 0872/G/D/07): a Xtru
3996   TGeoXtru *forwTrayPart1 = new TGeoXtru(2);
3997
3998   xprof[3] = kTrayWidth/2;
3999   yprof[3] = kForwardTrayFirstHeight;
4000   xprof[2] = xprof[3] - kTrayThick;
4001   yprof[2] = yprof[3];
4002   xprof[4] = xprof[3];
4003   yprof[4] = kTrayTotalHeight - kTrayHeighToBend;
4004   xprof[5] = xprof[4] - yprof[4]*TMath::Tan(kTrayBendAngle);
4005   yprof[5] = 0;
4006
4007   InsidePoint( xprof[3], yprof[3], xprof[4], yprof[4], xprof[5], yprof[5],
4008               -kTrayThick, xprof[1], yprof[1]);
4009
4010   xprof[6] = -xprof[5];
4011   yprof[6] =  yprof[5];
4012
4013   InsidePoint( xprof[4], yprof[4], xprof[5], yprof[5], xprof[6], yprof[6],
4014               -kTrayThick, xprof[0], yprof[0]);
4015
4016   // We did the right side, now reflex on the left side
4017   for (Int_t jp = 0; jp < 6; jp++) {
4018     xprof[6+jp] = -xprof[5-jp];
4019     yprof[6+jp] =  yprof[5-jp];
4020   }
4021
4022   // And now the actual Xtru
4023   forwTrayPart1->DefinePolygon(12, xprof, yprof);
4024   forwTrayPart1->DefineSection(0, 0);
4025   forwTrayPart1->DefineSection(1, kForwardTrayFirstLen);
4026
4027   // The second part of the forward tray (part of 0872/G/D/07): a Xtru
4028   TGeoXtru *forwTrayPart2 =
4029     CreateSDDSSDTraysSideA(kForwardTrayTotalLen - kForwardTrayFirstLen,
4030                            kTrayTotalHeight);
4031
4032   // The external tray (as 0872/G/D/03): a Xtru with same profile
4033   TGeoXtru *externalTray = CreateSDDSSDTraysSideA(kExternalTrayTotalLen,
4034                                                   kTrayTotalHeight);
4035
4036   // The side wall of the forward tray: a BBox
4037   TGeoBBox *forwSide = new TGeoBBox(kForwardSideThick/2,
4038                                     kForwardSideHeight/2,
4039                                     kForwardSideLength/2);
4040
4041   // The side cover over the walls: a Xtru
4042   TGeoXtru *forwSideCover = new TGeoXtru(2);
4043   forwSideCover->SetName("ITSsuppSSDForwCover");
4044
4045   xprof[0] = kTrayWidth/2 + 2*kForwardSideThick;
4046   yprof[0] = kForwardCoverHeight;
4047   xprof[1] = xprof[0];
4048   yprof[1] = 0;
4049   xprof[2] = xprof[1] - kForwardSideThick;
4050   yprof[2] = yprof[1];
4051   xprof[3] = xprof[2];
4052   yprof[3] = yprof[0] - kForwardSideThick;
4053
4054   // We did the right side, now reflex on the left side
4055   for (Int_t jp = 0; jp < 4; jp++) {
4056     xprof[4+jp] = -xprof[3-jp];
4057     yprof[4+jp] =  yprof[3-jp];
4058   }
4059
4060   forwSideCover->DefinePolygon(8, xprof, yprof);
4061   forwSideCover->DefineSection(0, 0);
4062   forwSideCover->DefineSection(1, kForwardSideLength);
4063
4064   // The forward and external covers: two Composite Shape's
4065   TGeoCompositeShape *forwardCover = CreateTrayAForwardCover(kForwardCoverLen);
4066
4067   TGeoCompositeShape *externCover = CreateTrayAExternalCover(kExternalCoverLen);
4068
4069   // The cable copper inside the forward tray: a BBox
4070   TGeoBBox *forwCopper = new TGeoBBox(kServicesWidth/2,
4071                                       kCopperHeight/2,
4072                                       kForwardTrayTotalLen/2);
4073
4074   // The cable copper inside the forward tray: a Xtru
4075   TGeoXtru *extCopper = new TGeoXtru(2);
4076   extCopper->SetName("ITSsuppSSDExtTrayCopper");
4077
4078   totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
4079           - kTrayThick;
4080
4081   xprof[0] = -totalhi*TanD(kTrayAZRot);
4082   yprof[0] = kTrayThick;
4083   xprof[1] = kExternalTrayTotalLen;
4084   yprof[1] = yprof[0];
4085   xprof[2] = xprof[1];
4086   yprof[2] = yprof[1] + kCopperHeight;
4087   totalhi -= kCopperHeight;
4088   xprof[3] = -totalhi*TanD(kTrayAZRot);
4089   yprof[3] = yprof[2];
4090
4091   extCopper->DefinePolygon(4, xprof, yprof);
4092   extCopper->DefineSection(0, 0);
4093   extCopper->DefineSection(1, kServicesWidth);
4094
4095   // The cable plastic inside the forward tray: a BBox
4096   TGeoBBox *forwPlastic = new TGeoBBox(kServicesWidth/2,
4097                                        kCablePlasticHeight/2,
4098                                        kForwardTrayTotalLen/2);
4099
4100   // The cable plastic inside the forward tray: a Xtru
4101   TGeoXtru *extPlastic = new TGeoXtru(2);
4102   extPlastic->SetName("ITSsuppSSDExtTrayPlastic");
4103
4104   totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
4105           - kTrayThick - kCopperHeight;
4106
4107   xprof[0] = -totalhi*TanD(kTrayAZRot);
4108   yprof[0] = kTrayThick;
4109   xprof[1] = kExternalTrayTotalLen;
4110   yprof[1] = yprof[0];
4111   xprof[2] = xprof[1];
4112   yprof[2] = yprof[1] + kCablePlasticHeight;
4113   totalhi -= kCablePlasticHeight;
4114   xprof[3] = -totalhi*TanD(kTrayAZRot);
4115   yprof[3] = yprof[2];
4116
4117   extPlastic->DefinePolygon(4, xprof, yprof);
4118   extPlastic->DefineSection(0, 0);
4119   extPlastic->DefineSection(1, kServicesWidth);
4120
4121   // The cooling water inside the forward tray: a BBox
4122   TGeoBBox *forwWater = new TGeoBBox(kServicesWidth/2,
4123                                      kCoolingWaterHeight/2,
4124                                      kForwardTrayTotalLen/2);
4125
4126   // The cooling water inside the forward tray: a Xtru
4127   TGeoXtru *extWater = new TGeoXtru(2);
4128   extWater->SetName("ITSsuppSSDExtTrayWater");
4129
4130   totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
4131           - kTrayThick - kCopperHeight - kCablePlasticHeight;
4132
4133   xprof[0] = -totalhi*TanD(kTrayAZRot);
4134   yprof[0] = kTrayThick;
4135   xprof[1] = kExternalTrayTotalLen;
4136   yprof[1] = yprof[0];
4137   xprof[2] = xprof[1];
4138   yprof[2] = yprof[1] + kCoolingWaterHeight;
4139   totalhi -= kCoolingWaterHeight;
4140   xprof[3] = -totalhi*TanD(kTrayAZRot);
4141   yprof[3] = yprof[2];
4142
4143   extWater->DefinePolygon(4, xprof, yprof);
4144   extWater->DefineSection(0, 0);
4145   extWater->DefineSection(1, kServicesWidth);
4146
4147   // The polyurethane inside the forward tray: a BBox
4148   TGeoBBox *forwPUR = new TGeoBBox(kServicesWidth/2,
4149                                    kPoliUrethaneHeight/2,
4150                                    kForwardTrayTotalLen/2);
4151
4152   // The poliurethane inside the forward tray: a Xtru
4153   TGeoXtru *extPUR = new TGeoXtru(2);
4154   extPUR->SetName("ITSsuppSSDExtTrayPUR");
4155
4156   totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
4157           - kTrayThick - kCopperHeight - kCablePlasticHeight
4158           - kCoolingWaterHeight;
4159
4160   xprof[0] = -totalhi*TanD(kTrayAZRot);
4161   yprof[0] = kTrayThick;
4162   xprof[1] = kExternalTrayTotalLen;
4163   yprof[1] = yprof[0];
4164   xprof[2] = xprof[1];
4165   yprof[2] = yprof[1] + kPoliUrethaneHeight;
4166   totalhi -= kPoliUrethaneHeight;
4167   xprof[3] = -totalhi*TanD(kTrayAZRot);
4168   yprof[3] = yprof[2];
4169
4170   extPUR->DefinePolygon(4, xprof, yprof);
4171   extPUR->DefineSection(0, 0);
4172   extPUR->DefineSection(1, kServicesWidth);
4173
4174
4175   // We have all shapes: now create the real volumes
4176   TGeoMedium *medAl    = mgr->GetMedium("ITS_ALUMINUM$");
4177   TGeoMedium *medAntic = mgr->GetMedium("ITS_ANTICORODAL$");
4178   TGeoMedium *medCu    = mgr->GetMedium("ITS_COPPER$");
4179   TGeoMedium *medFEP   = mgr->GetMedium("ITS_SSD FEP$");
4180   TGeoMedium *medH2O   = mgr->GetMedium("ITS_WATER$");
4181   TGeoMedium *medPUR   = mgr->GetMedium("ITS_POLYURETHANE$");
4182
4183   TGeoVolume *forwTrayFirst = new TGeoVolume("ITSsuppSSDSideAForwTrayFirst",
4184                                              forwTrayPart1, medAl);
4185
4186   forwTrayFirst->SetVisibility(kTRUE);
4187   forwTrayFirst->SetLineColor(6); // Purple
4188   forwTrayFirst->SetLineWidth(1);
4189   forwTrayFirst->SetFillColor(forwTrayFirst->GetLineColor());
4190   forwTrayFirst->SetFillStyle(4000); // 0% transparent
4191
4192   TGeoVolume *forwTraySecond = new TGeoVolume("ITSsuppSSDSideAForwTraySecond",
4193                                               forwTrayPart2, medAl);
4194
4195   forwTraySecond->SetVisibility(kTRUE);
4196   forwTraySecond->SetLineColor(6); // Purple
4197   forwTraySecond->SetLineWidth(1);
4198   forwTraySecond->SetFillColor(forwTraySecond->GetLineColor());
4199   forwTraySecond->SetFillStyle(4000); // 0% transparent
4200
4201   TGeoVolume *forwTraySide = new TGeoVolume("ITSsuppSSDSideAForwTraySide",
4202                                             forwSide, medAl);
4203
4204   forwTraySide->SetVisibility(kTRUE);
4205   forwTraySide->SetLineColor(6); // Purple
4206   forwTraySide->SetLineWidth(1);
4207   forwTraySide->SetFillColor(forwTraySide->GetLineColor());
4208   forwTraySide->SetFillStyle(4000); // 0% transparent
4209
4210   TGeoVolume *forwTraySideCover = new TGeoVolume("ITSsuppSSDSideAForwTraySideCover",
4211                                             forwSideCover, medAl);
4212
4213   forwTraySideCover->SetVisibility(kTRUE);
4214   forwTraySideCover->SetLineColor(6); // Purple
4215   forwTraySideCover->SetLineWidth(1);
4216   forwTraySideCover->SetFillColor(forwTraySideCover->GetLineColor());
4217   forwTraySideCover->SetFillStyle(4000); // 0% transparent
4218
4219   TGeoVolume *externalTraySSD = new TGeoVolume("ITSsuppSSDSideAExternalTray",
4220                                                externalTray, medAl);
4221
4222   externalTraySSD->SetVisibility(kTRUE);
4223   externalTraySSD->SetLineColor(6); // Purple
4224   externalTraySSD->SetLineWidth(1);
4225   externalTraySSD->SetFillColor(externalTraySSD->GetLineColor());
4226   externalTraySSD->SetFillStyle(4000); // 0% transparent
4227
4228   TGeoVolume *forwardTrayCover = new TGeoVolume("ITSsuppSSDSideAForwTrayCover",
4229                                                 forwardCover, medAntic);
4230
4231   forwardTrayCover->SetVisibility(kTRUE);
4232   forwardTrayCover->SetLineColor(kMagenta+1); // Purple
4233   forwardTrayCover->SetLineWidth(1);
4234   forwardTrayCover->SetFillColor(forwardTrayCover->GetLineColor());
4235   forwardTrayCover->SetFillStyle(4000); // 0% transparent
4236
4237   TGeoVolume *externTrayCover = new TGeoVolume("ITSsuppSSDSideAExtTrayCover",
4238                                                externCover, medAntic);
4239
4240   externTrayCover->SetVisibility(kTRUE);
4241   externTrayCover->SetLineColor(kMagenta+1); // Purple
4242   externTrayCover->SetLineWidth(1);
4243   externTrayCover->SetFillColor(externTrayCover->GetLineColor());
4244   externTrayCover->SetFillStyle(4000); // 0% transparent
4245
4246   TGeoVolume *forwCableCu = new TGeoVolume("ITSsuppSSDSideAForwCableCu",
4247                                            forwCopper, medCu);
4248
4249   forwCableCu->SetVisibility(kTRUE);
4250   forwCableCu->SetLineColor(kRed); // Red
4251   forwCableCu->SetLineWidth(1);
4252   forwCableCu->SetFillColor(forwCableCu->GetLineColor());
4253   forwCableCu->SetFillStyle(4000); // 0% transparent
4254
4255   TGeoVolume *extCableCu = new TGeoVolume("ITSsuppSSDSideAExtCableCu",
4256                                           extCopper, medCu);
4257
4258   extCableCu->SetVisibility(kTRUE);
4259   extCableCu->SetLineColor(kRed); // Red
4260   extCableCu->SetLineWidth(1);
4261   extCableCu->SetFillColor(extCableCu->GetLineColor());
4262   extCableCu->SetFillStyle(4000); // 0% transparent
4263
4264   TGeoVolume *forwCableFEP = new TGeoVolume("ITSsuppSSDSideAForwCableFEP",
4265                                             forwPlastic, medFEP);
4266
4267   forwCableFEP->SetVisibility(kTRUE);
4268   forwCableFEP->SetLineColor(kYellow); // Yellow
4269   forwCableFEP->SetLineWidth(1);
4270   forwCableFEP->SetFillColor(forwCableFEP->GetLineColor());
4271   forwCableFEP->SetFillStyle(4000); // 0% transparent
4272
4273   TGeoVolume *extCableFEP = new TGeoVolume("ITSsuppSSDSideAExtCableFEP",
4274                                            extPlastic, medFEP);
4275
4276   extCableFEP->SetVisibility(kTRUE);
4277   extCableFEP->SetLineColor(kYellow); // Yellow
4278   extCableFEP->SetLineWidth(1);
4279   extCableFEP->SetFillColor(extCableFEP->GetLineColor());
4280   extCableFEP->SetFillStyle(4000); // 0% transparent
4281
4282   TGeoVolume *forwTrayWater = new TGeoVolume("ITSsuppSSDSideAForwTrayWater",
4283                                              forwWater, medH2O);
4284
4285   forwTrayWater->SetVisibility(kTRUE);
4286   forwTrayWater->SetLineColor(kBlue); // Blue
4287   forwTrayWater->SetLineWidth(1);
4288   forwTrayWater->SetFillColor(forwTrayWater->GetLineColor());
4289   forwTrayWater->SetFillStyle(4000); // 0% transparent
4290
4291   TGeoVolume *extTrayWater = new TGeoVolume("ITSsuppSSDSideAExtTrayWater",
4292                                             extWater, medH2O);
4293
4294   extTrayWater->SetVisibility(kTRUE);
4295   extTrayWater->SetLineColor(kBlue); // Blue
4296   extTrayWater->SetLineWidth(1);
4297   extTrayWater->SetFillColor(extTrayWater->GetLineColor());
4298   extTrayWater->SetFillStyle(4000); // 0% transparent
4299
4300   TGeoVolume *forwPolyUr = new TGeoVolume("ITSsuppSSDSideAForwPolyUr",
4301                                           forwPUR, medPUR);
4302
4303   forwPolyUr->SetVisibility(kTRUE);
4304   forwPolyUr->SetLineColor(kGray); // Gray
4305   forwPolyUr->SetLineWidth(1);
4306   forwPolyUr->SetFillColor(forwPolyUr->GetLineColor());
4307   forwPolyUr->SetFillStyle(4000); // 0% transparent
4308
4309   TGeoVolume *extPolyUr = new TGeoVolume("ITSsuppSSDSideAExtPolyUr",
4310                                          extPUR, medPUR);
4311
4312   extPolyUr->SetVisibility(kTRUE);
4313   extPolyUr->SetLineColor(kGray); // Gray
4314   extPolyUr->SetLineWidth(1);
4315   extPolyUr->SetFillColor(extPolyUr->GetLineColor());
4316   extPolyUr->SetFillStyle(4000); // 0% transparent
4317
4318
4319   // Now build up the tray
4320   cableTrayAFR->AddNode(forwTrayFirst, 1, 0);
4321
4322   cableTrayAFR->AddNode(forwTraySecond, 1,
4323                         new TGeoTranslation(0, 0, kForwardTrayFirstLen) );
4324
4325   xloc = kTrayWidth/2 + kForwardSideThick/2;
4326   yloc = kForwardTrayFirstHeight + kForwardSideHeight/2 - kForwardSideYTrans;
4327   zloc = kForwardSideLength/2;
4328   cableTrayAFR->AddNode(forwTraySide,1,
4329                         new TGeoTranslation( xloc, yloc, zloc) );
4330   cableTrayAFR->AddNode(forwTraySide,2,
4331                         new TGeoTranslation(-xloc, yloc, zloc) );
4332
4333   yloc = kForwardTrayFirstHeight + kForwardSideHeight - kForwardSideYTrans
4334        - kForwardCoverHeight;
4335   cableTrayAFR->AddNode(forwTraySideCover,1,
4336                         new TGeoTranslation(0, yloc, 0) );
4337
4338   yloc = kTrayTotalHeight - kCoversYTrans;
4339   zloc = kForwardTrayTotalLen - kForwardCoverLen;
4340   cableTrayAFR->AddNode(forwardTrayCover,1,
4341                         new TGeoTranslation(0, yloc, zloc) );
4342
4343   yloc = kTrayThick + forwCopper->GetDY();
4344   zloc = forwCopper->GetDZ();
4345   cableTrayAFR->AddNode(forwCableCu, 1,
4346                         new TGeoTranslation(0, yloc, zloc) );
4347
4348   yloc = kTrayThick + kCopperHeight + forwPlastic->GetDY();
4349   zloc = forwPlastic->GetDZ();
4350   cableTrayAFR->AddNode(forwCableFEP, 1,
4351                         new TGeoTranslation(0, yloc, zloc) );
4352
4353   yloc = kTrayThick + kCopperHeight + kCablePlasticHeight + forwWater->GetDY();
4354   zloc = forwWater->GetDZ();
4355   cableTrayAFR->AddNode(forwTrayWater, 1,
4356                         new TGeoTranslation(0, yloc, zloc) );
4357
4358   yloc = kTrayThick + kCopperHeight + kCablePlasticHeight
4359        + kCoolingWaterHeight + forwPUR->GetDY();
4360   zloc = forwPUR->GetDZ();
4361   cableTrayAFR->AddNode(forwPolyUr, 1,
4362                         new TGeoTranslation(0, yloc, zloc) );
4363
4364   // To simplify following placement in MARS, origin is on top
4365   totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans;
4366
4367   yloc = -totalhi;
4368   cableTrayAExt->AddNode(externalTraySSD, 1,
4369                         new TGeoTranslation(0, yloc, 0) );
4370
4371   yloc = -totalhi + kTrayTotalHeight - kCoversYTrans;
4372   cableTrayAExt->AddNode(externTrayCover,1,
4373                         new TGeoTranslation(0, yloc, 0) );
4374
4375   xloc = extCopper->GetDZ();
4376   yloc = -totalhi;
4377   cableTrayAExt->AddNode(extCableCu,1,
4378                         new TGeoCombiTrans( xloc, yloc, 0,
4379                         new TGeoRotation("",-90, 90, 90)        ) );
4380
4381   xloc = extPlastic->GetDZ();
4382   yloc = -totalhi + kCopperHeight;
4383   cableTrayAExt->AddNode(extCableFEP,1,
4384                         new TGeoCombiTrans( xloc, yloc, 0,
4385                         new TGeoRotation("",-90, 90, 90)        ) );
4386
4387   xloc = extWater->GetDZ();
4388   yloc = -totalhi + kCopperHeight + kCablePlasticHeight;
4389   cableTrayAExt->AddNode(extTrayWater,1,
4390                         new TGeoCombiTrans( xloc, yloc, 0,
4391                         new TGeoRotation("",-90, 90, 90)        ) );
4392
4393   xloc = extPUR->GetDZ();
4394   yloc = -totalhi + kCopperHeight + kCablePlasticHeight + kCoolingWaterHeight;
4395   cableTrayAExt->AddNode(extPolyUr,1,
4396                         new TGeoCombiTrans( xloc, yloc, 0,
4397                         new TGeoRotation("",-90, 90, 90)        ) );
4398
4399
4400   // Finally put everything in the mother volume
4401   zloc = kTrayAZTrans;
4402   Double_t zlocext = zloc + kForwardTrayTotalLen;
4403   Double_t rExtTray = kTrayARTrans + kTrayTotalHeight;
4404
4405   alpharot = kTrayAFirstRotAng;
4406   xloc = kTrayARTrans*SinD(alpharot);
4407   yloc = kTrayARTrans*CosD(alpharot);
4408   moth->AddNode(cableTrayAFR,1,
4409                             new TGeoCombiTrans( xloc, yloc, zloc,
4410                             new TGeoRotation("",-alpharot,0,0)   )   );
4411   xloc = rExtTray*SinD(alpharot);
4412   yloc = rExtTray*CosD(alpharot);
4413   moth->AddNode(cableTrayAExt,1,
4414                             new TGeoCombiTrans( xloc, yloc, zlocext,
4415                             new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );
4416
4417   alpharot += 180;
4418   xloc = kTrayARTrans*SinD(alpharot);
4419   yloc = kTrayARTrans*CosD(alpharot);
4420   moth->AddNode(cableTrayAFR,2,
4421                             new TGeoCombiTrans( xloc, yloc, zloc,
4422                             new TGeoRotation("",-alpharot,0,0)   )   );
4423   xloc = rExtTray*SinD(alpharot);
4424   yloc = rExtTray*CosD(alpharot);
4425   moth->AddNode(cableTrayAExt,2,
4426                             new TGeoCombiTrans( xloc, yloc, zlocext,
4427                             new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );
4428
4429   alpharot = -kTrayAFirstRotAng - 2*kTrayASecondRotAng;
4430   xloc = kTrayARTrans*SinD(alpharot);
4431   yloc = kTrayARTrans*CosD(alpharot);
4432   moth->AddNode(cableTrayAFR,3,
4433                             new TGeoCombiTrans( xloc, yloc, zloc,
4434                             new TGeoRotation("",-alpharot,0,0)   )   );
4435   xloc = rExtTray*SinD(alpharot);
4436   yloc = rExtTray*CosD(alpharot);
4437   moth->AddNode(cableTrayAExt,3,
4438                             new TGeoCombiTrans( xloc, yloc, zlocext,
4439                             new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );
4440
4441   alpharot += 180;
4442   xloc = kTrayARTrans*SinD(alpharot);
4443   yloc = kTrayARTrans*CosD(alpharot);
4444   moth->AddNode(cableTrayAFR,4,
4445                             new TGeoCombiTrans( xloc, yloc, zloc,
4446                             new TGeoRotation("",-alpharot,0,0)   )   );
4447   xloc = rExtTray*SinD(alpharot);
4448   yloc = rExtTray*CosD(alpharot);
4449   moth->AddNode(cableTrayAExt,4,
4450                             new TGeoCombiTrans( xloc, yloc, zlocext,
4451                             new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );
4452
4453
4454   return;
4455 }
4456
4457 //______________________________________________________________________
4458 TGeoVolumeAssembly* AliITSv11GeometrySupport::CreateSDDForwardTraySideA(TGeoManager *mgr){
4459 //
4460 // Creates the forward SDD tray on Side A (0872/G/D/01)
4461 //
4462 // Input:
4463 //         mgr  : the GeoManager (used only to get the proper material)
4464 //
4465 // Output:
4466 //
4467 // Return:     a TGeoVolumeAssembly for the tray
4468 //
4469 // Created:      08 Jan 2010  Mario Sitta
4470 //
4471 // Technical data are taken from AutoCAD drawings, L.Simonetti technical
4472 // drawings and other (oral) information given by F.Tosello
4473 //
4474
4475   // Dimensions of the A-Side Forward Cable Tray (0872/G/D/01)
4476   const Double_t kForwardTrayThick        =    2.00 *fgkmm;
4477   const Double_t kForwardTraySideLength   =  823.00 *fgkmm;
4478   const Double_t kForwardTrayTailLength   =  212.00 *fgkmm;
4479   const Double_t kForwardTrayBaseHalfWide =   55.00 *fgkmm;
4480   const Double_t kForwardTrayNotchLength  =   47.20 *fgkmm;
4481   const Double_t kForwardTrayNotchHeight  =   25.00 *fgkmm;
4482   const Double_t kForwardTrayNotchDown    =   10.00 *fgkmm;
4483   const Double_t kForwardTraySide1Height  =   39.00 *fgkmm;
4484   const Double_t kForwardTraySide2Height  =   26.00 *fgkmm;
4485   const Double_t kForwardTraySide2Expand  =   10.50 *fgkmm;
4486   const Double_t kForwardTraySide3TailLen =  418.00 *fgkmm;
4487   const Double_t kForwardTraySide3TailHi  =   31.00 *fgkmm;
4488   const Double_t kForwardTraySide3HeadLen =  425.00 *fgkmm;
4489   const Double_t kForwardTraySide3HeadHi  =   72.00 *fgkmm;
4490   const Double_t kForwardTrayHorWingWide  =   10.50 *fgkmm;
4491   const Double_t kForwardTrayVertWingWide =   15.00 *fgkmm;
4492
4493   const Int_t    kForwardTraySideNpoints  =    9;
4494
4495
4496   // Local variables
4497   Double_t xprof[kForwardTraySideNpoints], yprof[kForwardTraySideNpoints];
4498   Double_t ylen, zlen;
4499   Double_t xloc, yloc, zloc;
4500
4501
4502   // The tray has a very complex shape, so it is made by assembling
4503   // different elements (with some small simplifications): the result
4504   // is a TGeoAssembly returned to the caller
4505   TGeoVolumeAssembly *forwardTray = new TGeoVolumeAssembly("ITSsuppSDDForwardTray");
4506
4507   // The tray base: a BBox
4508   zlen = (kForwardTraySideLength-kForwardTrayTailLength)/2;
4509   TGeoBBox *trayBase = new TGeoBBox(kForwardTrayBaseHalfWide,
4510                                     kForwardTrayThick/2, zlen);
4511
4512   // The first part of the side wall: a Xtru
4513   TGeoXtru *traySide1 = new TGeoXtru(2);
4514
4515   xprof[0] = 0;
4516   yprof[0] = kForwardTrayThick;
4517   xprof[1] = kForwardTraySideLength-kForwardTrayTailLength;
4518   yprof[1] = yprof[0];
4519   xprof[2] = kForwardTraySideLength;
4520   yprof[2] = kForwardTraySide1Height + kForwardTrayThick;
4521   xprof[3] = 0;
4522   yprof[3] = yprof[2];
4523
4524   traySide1->DefinePolygon(4, xprof, yprof);
4525   traySide1->DefineSection(0, 0);
4526   traySide1->DefineSection(1, kForwardTrayThick);
4527
4528   // The second part of the side wall: a Xtru
4529   TGeoXtru *traySide2 = new TGeoXtru(2);
4530
4531   xprof[0] = kForwardTrayBaseHalfWide - kForwardTrayThick;
4532   yprof[0] = traySide1->GetY(2);
4533   xprof[1] = kForwardTrayBaseHalfWide;
4534   yprof[1] = yprof[0];
4535   xprof[2] = xprof[1] + kForwardTraySide2Expand;
4536   yprof[2] = yprof[1] + kForwardTraySide2Height;
4537   xprof[3] = xprof[2] - kForwardTrayThick;
4538   yprof[3] = yprof[2];
4539
4540   traySide2->DefinePolygon(4, xprof, yprof);
4541   traySide2->DefineSection(0, 0);
4542   traySide2->DefineSection(1, kForwardTraySideLength);
4543
4544   // The third part of the side wall: a Xtru
4545   TGeoXtru *traySide3 = new TGeoXtru(2);
4546
4547   xprof[0] = 0;
4548   yprof[0] = traySide2->GetY(2);
4549   xprof[1] = kForwardTraySideLength;
4550   yprof[1] = yprof[0];
4551   xprof[2] = xprof[1];
4552   yprof[2] = yprof[1] + kForwardTraySide3TailHi - kForwardTrayThick;
4553   xprof[3] = xprof[2] - kForwardTraySide3TailLen - kForwardTrayThick;
4554   yprof[3] = yprof[2];
4555   xprof[4] = xprof[3];
4556   yprof[4] = yprof[3] + kForwardTraySide3HeadHi + kForwardTrayThick;
4557   xprof[5] = xprof[4] - kForwardTraySide3HeadLen;
4558   yprof[5] = yprof[4];
4559   xprof[6] = xprof[5];
4560   yprof[6] = yprof[5] - kForwardTrayNotchHeight;
4561   xprof[7] = xprof[6] + kForwardTrayNotchLength;
4562   yprof[7] = yprof[6];
4563   xprof[8] = xprof[7];
4564   yprof[8] = yprof[7] - kForwardTrayNotchDown;
4565
4566   traySide3->DefinePolygon(9, xprof, yprof);
4567   traySide3->DefineSection(0, 0);
4568   traySide3->DefineSection(1, kForwardTrayThick);
4569
4570   // The horizontal wing: a BBox
4571   TGeoBBox *trayHorWing = new TGeoBBox(kForwardTrayHorWingWide/2,
4572                                        kForwardTrayThick/2,
4573                                        kForwardTraySide3TailLen/2);
4574
4575   // The vertical wing: a BBox
4576   ylen = (traySide3->GetY(4) - traySide3->GetY(3))/2;
4577   TGeoBBox *trayVertWing = new TGeoBBox(kForwardTrayVertWingWide/2,
4578                                         ylen, kForwardTrayThick/2);
4579
4580
4581   // We have all shapes: now create the real volumes
4582   TGeoMedium *medAl    = mgr->GetMedium("ITS_ALUMINUM$");
4583
4584   TGeoVolume *forwTrayBase = new TGeoVolume("ITSsuppSDDSideAForwTrayBase",
4585                                             trayBase, medAl);
4586
4587   forwTrayBase->SetVisibility(kTRUE);
4588   forwTrayBase->SetLineColor(6); // Purple
4589   forwTrayBase->SetLineWidth(1);
4590   forwTrayBase->SetFillColor(forwTrayBase->GetLineColor());
4591   forwTrayBase->SetFillStyle(4000); // 0% transparent
4592
4593   TGeoVolume *forwTraySide1 = new TGeoVolume("ITSsuppSDDSideAForwTraySide1",
4594                                             traySide1, medAl);
4595
4596   forwTraySide1->SetVisibility(kTRUE);
4597   forwTraySide1->SetLineColor(6); // Purple
4598   forwTraySide1->SetLineWidth(1);
4599   forwTraySide1->SetFillColor(forwTraySide1->GetLineColor());
4600   forwTraySide1->SetFillStyle(4000); // 0% transparent
4601
4602   TGeoVolume *forwTraySide2 = new TGeoVolume("ITSsuppSDDSideAForwTraySide2",
4603                                             traySide2, medAl);
4604
4605   forwTraySide2->SetVisibility(kTRUE);
4606   forwTraySide2->SetLineColor(6); // Purple
4607   forwTraySide2->SetLineWidth(1);
4608   forwTraySide2->SetFillColor(forwTraySide2->GetLineColor());
4609   forwTraySide2->SetFillStyle(4000); // 0% transparent
4610
4611   TGeoVolume *forwTraySide3 = new TGeoVolume("ITSsuppSDDSideAForwTraySide3",
4612                                             traySide3, medAl);
4613
4614   forwTraySide3->SetVisibility(kTRUE);
4615   forwTraySide3->SetLineColor(6); // Purple
4616   forwTraySide3->SetLineWidth(1);
4617   forwTraySide3->SetFillColor(forwTraySide3->GetLineColor());
4618   forwTraySide3->SetFillStyle(4000); // 0% transparent
4619
4620   TGeoVolume *forwTrayHWing = new TGeoVolume("ITSsuppSDDSideAForwTrayHorWing",
4621                                             trayHorWing, medAl);
4622
4623   forwTrayHWing->SetVisibility(kTRUE);
4624   forwTrayHWing->SetLineColor(6); // Purple
4625   forwTrayHWing->SetLineWidth(1);
4626   forwTrayHWing->SetFillColor(forwTrayHWing->GetLineColor());
4627   forwTrayHWing->SetFillStyle(4000); // 0% transparent
4628
4629   TGeoVolume *forwTrayVWing = new TGeoVolume("ITSsuppSDDSideAForwTrayVertWing",
4630                                             trayVertWing, medAl);
4631
4632   forwTrayVWing->SetVisibility(kTRUE);
4633   forwTrayVWing->SetLineColor(6); // Purple
4634   forwTrayVWing->SetLineWidth(1);
4635   forwTrayVWing->SetFillColor(forwTrayVWing->GetLineColor());
4636   forwTrayVWing->SetFillStyle(4000); // 0% transparent
4637
4638
4639   // Now build up the tray
4640   yloc = kForwardTrayThick/2;
4641   zloc = zlen;
4642   forwardTray->AddNode(forwTrayBase, 1,
4643                        new TGeoTranslation(0, yloc, zloc) );
4644
4645   xloc = kForwardTrayBaseHalfWide;
4646   forwardTray->AddNode(forwTraySide1, 1,
4647                        new TGeoCombiTrans(xloc, 0, 0,
4648                                    new TGeoRotation("",90,-90,-90)));
4649   xloc = -xloc + kForwardTrayThick;
4650   forwardTray->AddNode(forwTraySide1, 2,
4651                        new TGeoCombiTrans(xloc, 0, 0,
4652                                    new TGeoRotation("",90,-90,-90)));
4653
4654   forwardTray->AddNode(forwTraySide2, 1, 0);
4655   zloc = kForwardTraySideLength;
4656   forwardTray->AddNode(forwTraySide2, 2,
4657                        new TGeoCombiTrans(0, 0, zloc,
4658                                    new TGeoRotation("",90,-180,-90)));
4659
4660   xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand;
4661   forwardTray->AddNode(forwTraySide3, 1,
4662                        new TGeoCombiTrans(xloc, 0, 0,
4663                                    new TGeoRotation("",90,-90,-90)));
4664   xloc = -xloc + kForwardTrayThick;
4665   forwardTray->AddNode(forwTraySide3, 2,
4666                        new TGeoCombiTrans(xloc, 0, 0,
4667                                    new TGeoRotation("",90,-90,-90)));
4668
4669   xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand
4670        - kForwardTrayHorWingWide/2;
4671   yloc = traySide3->GetY(2) + kForwardTrayThick/2;
4672   zloc = kForwardTraySideLength - trayHorWing->GetDZ();
4673   forwardTray->AddNode(forwTrayHWing, 1,
4674                        new TGeoTranslation( xloc, yloc, zloc) );
4675   forwardTray->AddNode(forwTrayHWing, 2,
4676                        new TGeoTranslation(-xloc, yloc, zloc) );
4677
4678   xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand
4679        - kForwardTrayVertWingWide/2;
4680   yloc = traySide3->GetY(2) + trayVertWing->GetDY();
4681   zloc = traySide3->GetX(3) + kForwardTrayThick/2;
4682   forwardTray->AddNode(forwTrayVWing, 1,
4683                        new TGeoTranslation( xloc, yloc, zloc) );
4684   forwardTray->AddNode(forwTrayVWing, 2,
4685                        new TGeoTranslation(-xloc, yloc, zloc) );
4686
4687
4688   return forwardTray;
4689 }
4690
4691 //______________________________________________________________________
4692 TGeoCompositeShape* AliITSv11GeometrySupport::CreateTrayAForwardCover(const Double_t coverLen){
4693 //
4694 // Creates the forward cover of the SDD and SSD cable trays on Side A
4695 // (0872/G/D/02)
4696 //
4697 // Input:
4698 //             coverLen: the total length of the cover
4699 //
4700 // Output:
4701 //
4702 // Return:     a TGeoCompositeShape for the cover
4703 //
4704 // Created:      03 Jan 2010  Mario Sitta
4705 //
4706 // Technical data are taken from AutoCAD drawings, L.Simonetti technical
4707 // drawings and other (oral) information given by F.Tosello
4708 //
4709
4710   // Dimensions and positions of the A-Side Cable Tray Forward Cover
4711   // (0872/G/D/02)
4712   const Double_t kForwardCoverWide        =  130.00 *fgkmm;
4713   const Double_t kForwardCoverSideWide    =   10.00 *fgkmm;
4714   const Double_t kForwardCoverHoleLen     =  160.00 *fgkmm;
4715   const Double_t kForwardCoverHoleWide    =   90.00 *fgkmm;
4716   const Double_t kForwardCoverHoleR10     =   10.00 *fgkmm;
4717   const Double_t kForwardCoverTotalThick  =    5.00 *fgkmm;
4718   const Double_t kForwardCoverSideThick   =    3.00 *fgkmm;
4719   const Double_t kForwardCoverInternThick =    2.00 *fgkmm;
4720
4721   const Double_t kForwardCoverHoleZTrans  =   40.00 *fgkmm;
4722
4723
4724   // Local variables
4725   Double_t xprof[16], yprof[16];
4726   Double_t yloc, zloc;
4727
4728
4729   // The main shape: a Xtru
4730   TGeoXtru *forwCoverMain = new TGeoXtru(2);
4731   forwCoverMain->SetName("ITSsuppForwCoverMain");
4732
4733   xprof[0] = kForwardCoverWide/2;
4734   yprof[0] = kForwardCoverTotalThick;
4735   xprof[1] = xprof[0];
4736   yprof[1] = yprof[0] - kForwardCoverSideThick;
4737   xprof[2] = xprof[1] - kForwardCoverSideWide;
4738   yprof[2] = yprof[1];
4739   xprof[3] = xprof[2];
4740   yprof[3] = 0;
4741
4742   // We did the right side, now reflex on the left side
4743   for (Int_t jp = 0; jp < 4; jp++) {
4744     xprof[4+jp] = -xprof[3-jp];
4745     yprof[4+jp] =  yprof[3-jp];
4746   }
4747
4748   // And now the actual Xtru
4749   forwCoverMain->DefinePolygon(8, xprof, yprof);
4750   forwCoverMain->DefineSection(0, 0);
4751   forwCoverMain->DefineSection(1, coverLen);
4752
4753   // The hole: another Xtru (rounded corners approximated with segments)
4754   TGeoXtru *forwCoverHole = new TGeoXtru(2);
4755   forwCoverHole->SetName("ITSsuppForwCoverHole");
4756
4757   CreateTrayACoverHolesShape(kForwardCoverHoleWide, kForwardCoverHoleLen,
4758                              kForwardCoverHoleR10 , xprof, yprof);
4759
4760   // And now the actual Xtru
4761   forwCoverHole->DefinePolygon(16, xprof, yprof);
4762   forwCoverHole->DefineSection(0, 0);
4763   forwCoverHole->DefineSection(1, kForwardCoverTotalThick-kForwardCoverInternThick);
4764
4765   // Now the proper rototranslation matrices for the two holes
4766   yloc = kForwardCoverTotalThick-kForwardCoverInternThick-0.01;//Precision fix
4767   zloc = kForwardCoverHoleZTrans;
4768   TGeoCombiTrans *mf1 = new TGeoCombiTrans(0, yloc, zloc,
4769                                            new TGeoRotation("", 0, 90, 0) );
4770   mf1->SetName("mf1");
4771   mf1->RegisterYourself();
4772
4773   zloc = coverLen - kForwardCoverHoleZTrans - kForwardCoverHoleLen;
4774   TGeoCombiTrans *mf2 = new TGeoCombiTrans(0, yloc, zloc,
4775                                            new TGeoRotation("", 0, 90, 0) );
4776   mf2->SetName("mf2");
4777   mf2->RegisterYourself();
4778
4779   // Finally the actual cover shape
4780   TGeoCompositeShape *cover = new TGeoCompositeShape("ITSsuppForwardCoverMain",
4781     "ITSsuppForwCoverMain-ITSsuppForwCoverHole:mf1-ITSsuppForwCoverHole:mf2");
4782
4783   return cover;
4784 }
4785
4786 //______________________________________________________________________
4787 TGeoCompositeShape* AliITSv11GeometrySupport::CreateTrayAExternalCover(const Double_t coverLen){
4788 //
4789 // Creates the external cover of the SDD and SSD cable trays on Side A
4790 // (0872/G/D/04)
4791 //
4792 // Input:
4793 //             coverLen: the total length of the cover
4794 //
4795 // Output:
4796 //
4797 // Return:     a TGeoCompositeShape for the cover
4798 //
4799 // Created:      03 Jan 2010  Mario Sitta
4800 //
4801 // Technical data are taken from AutoCAD drawings, L.Simonetti technical
4802 // drawings and other (oral) information given by F.Tosello
4803 //
4804
4805   // Dimensions and positions of the A-Side Cable Tray External Cover
4806   // (0872/G/D/04)
4807   const Double_t kExternalCoverWide        =  130.00 *fgkmm;
4808   const Double_t kExternalCoverSideWide    =   10.00 *fgkmm;
4809   const Double_t kExternalCoverHoleLen1    =  262.00 *fgkmm;
4810   const Double_t kExternalCoverHoleLen2    =  280.00 *fgkmm;
4811   const Double_t kExternalCoverHoleLen3    =  205.00 *fgkmm;
4812   const Double_t kExternalCoverHoleLen4    =   55.00 *fgkmm;
4813   const Double_t kExternalCoverHoleWide    =   90.00 *fgkmm;
4814   const Double_t kExternalCoverHoleR10     =   10.00 *fgkmm;
4815   const Double_t kExternalCoverTotalThick  =    5.00 *fgkmm;
4816   const Double_t kExternalCoverSideThick   =    3.00 *fgkmm;
4817   const Double_t kExternalCoverInternThick =    2.00 *fgkmm;
4818
4819   const Double_t kExternalCoverHole1ZTrans =   28.00 *fgkmm;
4820   const Double_t kExternalCoverHolesZTrans =   20.00 *fgkmm;
4821
4822
4823   // Local variables
4824   Double_t xprof[16], yprof[16];
4825   Double_t yloc, zloc;
4826
4827
4828   // The main shape: a Xtru
4829   TGeoXtru *externCoverMain = new TGeoXtru(2);
4830   externCoverMain->SetName("ITSsuppExternCoverMain");
4831
4832   xprof[0] = kExternalCoverWide/2;
4833   yprof[0] = kExternalCoverTotalThick;
4834   xprof[1] = xprof[0];
4835   yprof[1] = yprof[0] - kExternalCoverSideThick;
4836   xprof[2] = xprof[1] - kExternalCoverSideWide;
4837   yprof[2] = yprof[1];
4838   xprof[3] = xprof[2];
4839   yprof[3] = 0;
4840
4841   // We did the right side, now reflex on the left side
4842   for (Int_t jp = 0; jp < 4; jp++) {
4843     xprof[4+jp] = -xprof[3-jp];
4844     yprof[4+jp] =  yprof[3-jp];
4845   }
4846
4847   // And now the actual Xtru
4848   externCoverMain->DefinePolygon(8, xprof, yprof);
4849   externCoverMain->DefineSection(0, 0);
4850   externCoverMain->DefineSection(1, coverLen);
4851
4852   // The first hole: a Xtru (rounded corners approximated with segments)
4853   Double_t holethick = kExternalCoverTotalThick-kExternalCoverInternThick;
4854
4855   TGeoXtru *extCoverHole1 = new TGeoXtru(2);
4856   extCoverHole1->SetName("ITSsuppExtCoverHole1");
4857
4858   CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen1,
4859                              kExternalCoverHoleR10 , xprof, yprof);
4860
4861   extCoverHole1->DefinePolygon(16, xprof, yprof);
4862   extCoverHole1->DefineSection(0, 0);
4863   extCoverHole1->DefineSection(1, holethick);
4864
4865   // The second (and third) hole: another Xtru
4866   TGeoXtru *extCoverHole2 = new TGeoXtru(2);
4867   extCoverHole2->SetName("ITSsuppExtCoverHole2");
4868
4869   CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen2,
4870                              kExternalCoverHoleR10 , xprof, yprof);
4871
4872   extCoverHole2->DefinePolygon(16, xprof, yprof);
4873   extCoverHole2->DefineSection(0, 0);
4874   extCoverHole2->DefineSection(1, holethick);
4875
4876   // The fourth hole: another Xtru
4877   TGeoXtru *extCoverHole3 = new TGeoXtru(2);
4878   extCoverHole3->SetName("ITSsuppExtCoverHole3");
4879
4880   CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen3,
4881                              kExternalCoverHoleR10 , xprof, yprof);
4882
4883   extCoverHole3->DefinePolygon(16, xprof, yprof);
4884   extCoverHole3->DefineSection(0, 0);
4885   extCoverHole3->DefineSection(1, holethick);
4886
4887   // The fifth and last hole: another Xtru
4888   TGeoXtru *extCoverHole4 = new TGeoXtru(2);
4889   extCoverHole4->SetName("ITSsuppExtCoverHole4");
4890
4891   CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen4,
4892                              kExternalCoverHoleR10 , xprof, yprof);
4893
4894   extCoverHole4->DefinePolygon(16, xprof, yprof);
4895   extCoverHole4->DefineSection(0, 0);
4896   extCoverHole4->DefineSection(1, holethick);
4897
4898   // Now the proper rototranslation matrices for the holes
4899   yloc = kExternalCoverTotalThick - kExternalCoverInternThick-0.01;
4900   zloc = kExternalCoverHole1ZTrans;
4901   TGeoCombiTrans *me1 = new TGeoCombiTrans(0, yloc, zloc,
4902                                            new TGeoRotation("", 0, 90, 0) );
4903   me1->SetName("me1");
4904   me1->RegisterYourself();
4905
4906   zloc += (kExternalCoverHoleLen1 + kExternalCoverHolesZTrans);
4907   TGeoCombiTrans *me2 = new TGeoCombiTrans(0, yloc, zloc,
4908                                            new TGeoRotation("", 0, 90, 0) );
4909   me2->SetName("me2");
4910   me2->RegisterYourself();
4911
4912   zloc += (kExternalCoverHoleLen2 + kExternalCoverHolesZTrans);
4913   TGeoCombiTrans *me3 = new TGeoCombiTrans(0, yloc, zloc,
4914                                            new TGeoRotation("", 0, 90, 0) );
4915   me3->SetName("me3");
4916   me3->RegisterYourself();
4917
4918   zloc += (kExternalCoverHoleLen2 + kExternalCoverHolesZTrans);
4919   TGeoCombiTrans *me4 = new TGeoCombiTrans(0, yloc, zloc,
4920                                            new TGeoRotation("", 0, 90, 0) );
4921   me4->SetName("me4");
4922   me4->RegisterYourself();
4923
4924   zloc += (kExternalCoverHoleLen3 + kExternalCoverHolesZTrans);
4925   TGeoCombiTrans *me5 = new TGeoCombiTrans(0, yloc, zloc,
4926                                            new TGeoRotation("", 0, 90, 0) );
4927   me5->SetName("me5");
4928   me5->RegisterYourself();
4929
4930   // Finally the actual cover shape
4931   TGeoCompositeShape *cover = new TGeoCompositeShape("ITSsuppExternCoverMain",
4932     "ITSsuppExternCoverMain-ITSsuppExtCoverHole1:me1-ITSsuppExtCoverHole2:me2-ITSsuppExtCoverHole2:me3-ITSsuppExtCoverHole3:me4-ITSsuppExtCoverHole4:me5");
4933
4934   return cover;
4935 }
4936
4937 //______________________________________________________________________
4938 void AliITSv11GeometrySupport::CreateTrayACoverHolesShape(const Double_t wide,
4939                                const Double_t length, const Double_t r10,
4940                                Double_t *x, Double_t *y){
4941 //
4942 // Creates the proper sequence of X and Y coordinates to determine
4943 // the base XTru polygon for the holes in the SDD and SSD tray covers
4944 // (here the rounded corners are approximated with segments)
4945 //
4946 // Input:
4947 //        wide   : the hole wide
4948 //        length : the hole length
4949 //        r10    : the radius of the rounded corners
4950 //
4951 // Output:
4952 //        x, y : coordinate vectors [16]
4953 //
4954 // Created:      03 Jan 2010  Mario Sitta
4955 //
4956 // Caller must guarantee that x and y have the correct dimensions
4957 // (but being this a private method it's easy to tell)
4958 //
4959
4960   x[0] = wide/2 - r10;
4961   y[0] = length;
4962   x[1] = x[0] + r10*SinD(30);
4963   y[1] = y[0] - r10*(1 - CosD(30));
4964   x[2] = x[0] + r10*SinD(60);
4965   y[2] = y[0] - r10*(1 - CosD(60));
4966   x[3] = x[0] + r10;
4967   y[3] = y[0] - r10;
4968   x[4] = x[3];
4969   y[4] = r10;
4970   x[5] = x[4] - r10*(1 - CosD(30));
4971   y[5] = y[4] - r10*SinD(30);
4972   x[6] = x[4] - r10*(1 - CosD(60));
4973   y[6] = y[4] - r10*SinD(60);
4974   x[7] = x[4] - r10;
4975   y[7] = 0;
4976
4977   // We did the right side, now reflex on the left side
4978   for (Int_t jp = 0; jp < 8; jp++) {
4979     x[8+jp] = -x[7-jp];
4980     y[8+jp] =  y[7-jp];
4981   }
4982
4983   return;
4984 }
4985
4986 //______________________________________________________________________
4987 TGeoXtru* AliITSv11GeometrySupport::CreateSDDSSDTraysSideA(
4988                                               const Double_t trayLen,
4989                                               const Double_t trayHi){
4990 //
4991 // Creates parts of the SDD and SSD Trays on Side A which are identical
4992 // (0872/G/D/03, part of 0872/G/D/07, 0872/G/C/11)
4993 //
4994 // Input:
4995 //         trayLen : the length of the tray part
4996 //         trayHi  : the height of the tray part
4997 //
4998 // Output:
4999 //
5000 // Return:     a TGeoXtru
5001 //
5002 // Created:      26 Feb 2010  Mario Sitta
5003 //
5004 // Technical data are taken from AutoCAD drawings, L.Simonetti technical
5005 // drawings and other (oral) information given by F.Tosello
5006 //
5007
5008   // Dimensions and positions of the A-Side Cable Trays
5009   // (parts of 0872/G/C)
5010   const Double_t kTrayWidth              =  130.00 *fgkmm;
5011   const Double_t kTrayWingWidth          =   10.00 *fgkmm;
5012   const Double_t kTrayHeightToBend       =   20.00 *fgkmm;
5013   const Double_t kTrayThick              =    2.00 *fgkmm;
5014
5015   const Double_t kTrayBendAngle          =   22.00 *TMath::DegToRad();
5016
5017   const Int_t    kTrayNpoints            =   16;
5018
5019   // Local variables
5020   Double_t xprof[kTrayNpoints], yprof[kTrayNpoints];
5021
5022
5023   // The tray shape: a Xtru
5024   TGeoXtru *trayPart = new TGeoXtru(2);
5025
5026   xprof[2] = kTrayWidth/2 - kTrayThick;
5027   yprof[2] = trayHi - kTrayThick;
5028   xprof[3] = kTrayWidth/2 - kTrayWingWidth;
5029   yprof[3] = yprof[2];
5030   xprof[4] = xprof[3];
5031   yprof[4] = trayHi;
5032   xprof[5] = kTrayWidth/2;
5033   yprof[5] = yprof[4];
5034   xprof[6] = xprof[5];
5035   yprof[6] = kTrayHeightToBend;
5036   xprof[7] = xprof[6] - yprof[6]*TMath::Tan(kTrayBendAngle);
5037   yprof[7] = 0;
5038
5039   InsidePoint( xprof[5], yprof[5], xprof[6], yprof[6], xprof[7], yprof[7],
5040               -kTrayThick, xprof[1], yprof[1]);
5041
5042   xprof[8] = -xprof[7];
5043   yprof[8] =  yprof[7];
5044
5045   InsidePoint( xprof[6], yprof[6], xprof[7], yprof[7], xprof[8], yprof[8],
5046               -kTrayThick, xprof[0], yprof[0]);
5047
5048   // We did the right side, now reflex on the left side
5049   for (Int_t jp = 0; jp < 8; jp++) {
5050     xprof[8+jp] = -xprof[7-jp];
5051     yprof[8+jp] =  yprof[7-jp];
5052   }
5053
5054   // And now the actual Xtru
5055   trayPart->DefinePolygon(kTrayNpoints, xprof, yprof);
5056   trayPart->DefineSection(0, 0);
5057   trayPart->DefineSection(1, trayLen);
5058
5059
5060   return trayPart;
5061 }
5062