ITS/AliITSv11GeometrySSD.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
  17 //*************************************************************************
  18 // SSD geometry, based on ROOT geometrical modeler
  19 //
  20 // Enrico Cattaruzza                                    ecattar@ts.infn.it
  21 //*************************************************************************
  22 #include "TMath.h"
  23 #include "TGeoVolume.h"
  24 #include "TGeoMedium.h"
  25 #include "TGeoMatrix.h"
  26 #include <TGeoManager.h>
  27 #include "AliITSv11GeometrySSD.h"
  28 #include "TVector3.h"
  29 #include "TGeoArb8.h"
  30 #include "TList.h"
  31 #include "TGeoMatrix.h"
  32 #include "TGeoCompositeShape.h"
  33 #include "TGeoTube.h"
  34 #include "TGeoBBox.h"
  35 #include "TGeoTrd1.h"
  36 #include <iostream>
  37 using namespace std;
  38 /////////////////////////////////////////////////////////////////////////////////
  39 //Parameters for SSD Geometry
  40 /////////////////////////////////////////////////////////////////////////////////
  41 // Layer5 (lengths are in mm and angles in degrees)
  42 /////////////////////////////////////////////////////////////////////////////////
  43 const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength      = 950.7;
  44 const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber        =  22;
  45 const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber         =  34;
  46 const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin         = 378.0;
  47 const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax         = 384.0;
  48 const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition    = 467.85;
  49 /////////////////////////////////////////////////////////////////////////////////
  50 // Layer6 (lengths are in mm and angles in degrees)
  51 /////////////////////////////////////////////////////////////////////////////////
  52 const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength      = 1068.0;
  53 const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber        =   25;
  54 const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber         =   38;
  55 const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin         =  428.0;
  56 const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax         =  434.0;
  57 const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition    = 526.50;
  58 /////////////////////////////////////////////////////////////////////////////////
  59 // SSD Chips and Hybrid (lengths are in mm and angles in degrees)
  60 /////////////////////////////////////////////////////////////////////////////////
  61 const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber               =   6;
  62 const Double_t AliITSv11GeometrySSD::fgkSSDChipLength            =  11.100;
  63 const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth             =   3.850;
  64 const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight            =   0.180;
  65 const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength  =   1.000;
  66 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength        =   fgkSSDChipLength;
  67 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth         =   fgkSSDChipWidth;
  68 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight        =   0.030;
  69 /////////////////////////////////////////////////////////////////////////////////
  70 // Stiffener (lengths are in mm and angles in degrees)
  71 /////////////////////////////////////////////////////////////////////////////////
  72 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength       =  73.000;
  73 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth        =   6.500;
  74 //const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight       =   3.315;
  75 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight       =   0.315;
  76 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist   =   2.500;
  77 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length   =   1.600;
  78 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width    =   0.870;
  79 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height   =   0.800;
  80 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length   =   4.600;
  81 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width    =   3.400;
  82 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height   =   1.400;
  83 const Double_t AliITSv11GeometrySSD::fgkSSDWireLength            =  30.000;
  84 const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius            =   0.185;
  85 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2]  = {44.32, 0.33};
  86 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation   = 0.44;
  87 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength       = 2.16;
  88 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth        = 3.60;
  89 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight       =
  90                                                                                                           0.25*fgkSSDStiffenerHeight;
  91 /////////////////////////////////////////////////////////////////////////////////
  92 // Cooling Block (lengths are in mm and angles in degrees)
  93 /////////////////////////////////////////////////////////////////////////////////
  94 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength    =   3.000;
  95 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth     =   4.000;
  96 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
  97                                                                                                          {1.950, 0.240, 0.300};
  98 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
  99                                                                                                                     {1.000, 0.120};
 100 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
 101                                                                                                                         {1.900, 0.400};
 102 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter    =
 103                                                                                                                                          1.500;
 104 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight    =
 105                                                                                                                                          0.300;
 106 /////////////////////////////////////////////////////////////////////////////////
 107 // SSD Sensor (lengths are in mm and angles in degrees)
 108 /////////////////////////////////////////////////////////////////////////////////
 109 const char*  AliITSv11GeometrySSD::fgkSSDSensitiveVolName       =
 110                                                           "SSDSensorSensitiveVol";
 111 const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength          =  42.000;
 112 const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight          =   0.300;
 113 const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth           =  75.000;
 114 const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap         =
 115                                                                                                    fgkSSDSensorLength-39.1;
 116 const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength      = 1.;
 117 const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth       = 1.;
 118 /////////////////////////////////////////////////////////////////////////////////
 119 // Flex (lengths are in mm and angles in degrees)
 120 /////////////////////////////////////////////////////////////////////////////////
 121 const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength       =  106.000;
 122 const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4]        =
 123                         {0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
 124                                                 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
 125                          0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
 126                                                 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)-4.000,
 127                                                   9.500, 10.000};
 128 const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2]         =
 129                                                                                                                  {  9.340,  5.380};
 130 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2]        =
 131                                                                                                                  {  0.030,  0.020};
 132 const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle            =   30.000;
 133 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength       =    1.430;
 134 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth        =    3.000;
 135 const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
 136                                                                                    {3.30,4.12,4.22,1.70,0.75,7.18};
 137 const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
 138                                                                                                            {15.03,23.48,12.28};
 139 /////////////////////////////////////////////////////////////////////////////////
 140 // SSD Ladder Cable (lengths are in mm and angles in degrees)
 141 /////////////////////////////////////////////////////////////////////////////////
 142 const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth     =   23.5;
 143 const Double_t AliITSv11GeometrySSD::fgkSSDEndLadderCableLength =   50.000; /////to be modified
 144 /////////////////////////////////////////////////////////////////////////////////
 145 // SSD Module (lengths are in mm and angles in degrees)
 146 /////////////////////////////////////////////////////////////////////////////////
 147 const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2]  =
 148                                                                                                                    { 1.000, 3.900};
 149 const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
 150                                                                                                                                         45.600;
 151 const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor  =
 152                                                                                                                                          5.075;
 153 /////////////////////////////////////////////////////////////////////////////////
 154 // Sensor Support (lengths are in mm and angles in degrees)
 155 /////////////////////////////////////////////////////////////////////////////////
 156 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength                 =
 157                                                                                                                                            5.800;
 158 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth          =
 159                                                                                                                                            2.000;
 160 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2]      =
 161                                                                                                                      { 4.620, 5.180};
 162 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] =
 163                                                                                                                      { 0.450, 0.450};
 164 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition       =
 165                                                                           0.5*(fgkSSDModuleSensorSupportDistance
 166                                                                +    fgkSSDSensorSideSupportThickness[0])
 167                                                                    -           fgkSSDSensorSideSupportLength;
 168 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength       =
 169                                                                                                                                            5.250;
 170 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth        =
 171                                                                                                                                        1.680;
 172 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]    =
 173            {fgkSSDSensorSideSupportHeight[0]+fgkSSDSensorSideSupportThickness[0],
 174            fgkSSDSensorSideSupportHeight[1]+fgkSSDSensorSideSupportThickness[1]};
 175 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2] =
 176    {fgkSSDSensorSideSupportThickness[0],fgkSSDSensorSideSupportThickness[1]};
 177 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition     =
 178                                                                                                                                       19.000;
 179 /////////////////////////////////////////////////////////////////////////////////
 180 // Chip Cables (lengths are in mm and angles in degrees)
 181 /////////////////////////////////////////////////////////////////////////////////
 182 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2]   =
 183                                                  {73.12/fgkSSDChipNumber,fgkSSDChipLength+2.*0.19};
 184 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4]   =
 185                                                 {  0.014,  0.010, fgkSSDModuleCoolingBlockToSensor
 186   -  (fgkSSDSensorSideSupportHeight[1]-fgkSSDSensorSideSupportHeight[0])
 187   -   fgkSSDCoolingBlockHoleCenter-fgkSSDStiffenerHeight
 188   -   fgkSSDChipHeight-fgkSSDSensorHeight,
 189       fgkSSDModuleCoolingBlockToSensor
 190   -   fgkSSDCoolingBlockHoleCenter-fgkSSDStiffenerHeight
 191   -   fgkSSDChipHeight-fgkSSDSensorHeight};
 192 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3]    =
 193                                                                                                  { 11.000,  0.800,  0.600};
 194 /////////////////////////////////////////////////////////////////////////////////
 195 // Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
 196 /////////////////////////////////////////////////////////////////////////////////
 197 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          =
 198                                                                                                                                            3.820;
 199 //const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          =
 200 //                                                                                                                                         3.780;
 201 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth           =
 202                                                                           fgkSSDSensorLength-fgkSSDSensorOverlap;
 203 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2]         =
 204                                                                                                                          {  0.86,  0.30};
 205 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2]        =
 206                                                                                                                          { 30.00, 90.00};
 207 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
 208                                                                                                                                             1.78;
 209 /////////////////////////////////////////////////////////////////////////////////
 210 //Carbon Fiber Parameters (lengths are in mm and angles in degrees)
 211 /////////////////////////////////////////////////////////////////////////////////
 212 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength          =
 213   fgkSSDModuleSensorSupportDistance-2.*fgkCarbonFiberJunctionToSensorSupport;
 214 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle           =
 215                                                                                                                                            60.00;
 216 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2]   =
 217                                                                                                                    {  0.751,  0.482};
 218 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength       =
 219                                                                                                                                            1.630;
 220 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth            =
 221                                                                                                                                            0.950;
 222 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength      =
 223              fgkCarbonFiberTriangleLength-0.5*fgkCarbonFiberSupportTopEdgeDist[1]
 224                      / TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad());
 225 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength      =
 226                                   0.5*(fgkCarbonFiberJunctionWidth-fgkCarbonFiberSupportWidth)
 227                          - fgkCarbonFiberSupportTopEdgeDist[0]-fgkCarbonFiberSupportWidth;
 228 /////////////////////////////////////////////////////////////////////////////////
 229 // Carbon Fiber Lower Support Parameters (lengths are in mm)
 230 /////////////////////////////////////////////////////////////////////////////////
 231 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
 232                                                                                                                                           =  0.950;
 233 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
 234                                                                                                                                           =  1.600;
 235 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
 236                                                                                                                                           =  0.830;
 237 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
 238                                                                                           = 0.5*fgkCarbonFiberSupportWidth;
 239 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
 240                                                                  = fgkCarbonFiberJunctionWidth
 241                                  - 2.*(fgkCarbonFiberLowerSupportWidth
 242                                                                  + fgkCarbonFiberLowerSupportVolumeSeparation);
 243 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
 244                                                                  = {fgkCarbonFiberLowerSupportWidth
 245                                                                  +  fgkCarbonFiberLowerSupportVolumeSeparation,
 246                                                                         fgkCarbonFiberLowerSupportWidth
 247                                                                  +  fgkCarbonFiberLowerSupportVolumeSeparation
 248                                                                  +  fgkCarbonFiberLowerSupportTransverseWidth};
 249 /////////////////////////////////////////////////////////////////////////////////
 250 // End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
 251 /////////////////////////////////////////////////////////////////////////////////
 252 const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
 253   {0.5*(fgkSSDLay5LadderLength
 254           -fgkSSDLay5SensorsNumber*fgkCarbonFiberJunctionWidth
 255           -fgkCarbonFiberLowerSupportWidth),
 256        0.5*(fgkSSDLay5LadderLength
 257           -fgkSSDLay5SensorsNumber*fgkCarbonFiberJunctionWidth
 258           +fgkCarbonFiberLowerSupportWidth)};
 259 const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
 260                 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4,
 261                  fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6};
 262 const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
 263                                                    {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50,
 264                                                    fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50};
 265 /////////////////////////////////////////////////////////////////////////////////
 266 // Cooling Tube Support (lengths are in mm and angles in degrees)
 267 /////////////////////////////////////////////////////////////////////////////////
 268 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax          =  1.45;
 269 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
 270                                                                                           = fgkSSDCoolingBlockHoleRadius[0];
 271 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength        =  8.55;
 272 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight        =  0.85;
 273 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth         =  2.00;
 274 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation    =
 275                                       fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
 276 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber = 11.70;
 277 /////////////////////////////////////////////////////////////////////////////////
 278 // Cooling Tube (lengths are in mm and angles in degrees)
 279 /////////////////////////////////////////////////////////////////////////////////
 280 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax       =
 281                                                                                                           fgkCoolingTubeSupportRmin;
 282 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin       =  0.96;
 283 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength     =
 284                                                                                                         fgkCarbonFiberJunctionWidth;
 285 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
 286                                         fgkSSDModuleSensorSupportDistance+fgkSSDCoolingBlockLength;
 287 //const Double_t AliITSv11GeometrySSD_ct::fgkCoolingTubeLength               =  39.1;
 288 /////////////////////////////////////////////////////////////////////////////////
 289 // SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
 290 /////////////////////////////////////////////////////////////////////////////////
 291 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3]            =
 292                                                                                                                         { 60.0, 42.2, 34.0};
 293 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4]            =
 294                                                                                                           {  4.0,  8.0,  5.0,  0.2};
 295 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth                =
 296                                                                                                                                                    20.0;
 297 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle   =
 298                                                                                                                                                    40.0;
 299 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight  =
 300                    0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
 301 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
 302                                                                                                                                                         2.5;
 303 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2]    =
 304                                                                                                                                   { 56.0, 12.0};
 305 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2]     =
 306                                                                                                                                   {  5.0,  2.9};
 307 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius           =
 308                                                                                                                                                         1.0;
 309 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge        =
 310                                                                                                                                                         6.0;
 311 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth      =
 312                                                                                                                                                         4.0;
 313 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2]   =
 314                                                                         {  1.5,fgkSSDMountingBlockScrewHoleEdge/6.};
 315 /////////////////////////////////////////////////////////////////////////////////
 316 AliITSv11GeometrySSD::AliITSv11GeometrySSD(){
 317   /////////////////////////////////
 318   // Standard Default Constructor
 319   /////////////////////////////////
 320   // Initializing display colors
 321   //////////////////////////////
 322   fColorCarbonFiber =  4;
 323   fColorRyton       =  5;
 324   fColorPhynox      =  5;
 325   fColorSilicon     =  3;
 326   fColorAl          =  7;
 327   fColorKapton      =  6;
 328   fColorPolyhamide  =  5;
 329   fColorStiffener   =  9;
 330   fColorEpoxy       = 30;
 331   CreateMaterials();
 332 }
 333 /////////////////////////////////////////////////////////////////////////////////
 334 // Setting the transformation Matrices
 335 /////////////////////////////////////////////////////////////////////////////////
 336 void AliITSv11GeometrySSD::SetSSDSensorSupportCombiTransMatrix(){
 337   ////////////////////////////////////////////////////////
 338   //Translation Parameters SSDSensorSupportAssembly:
 339   ////////////////////////////////////////////////////////
 340   const Double_t SSDSensorSupportTransX[3] = {-0.5*fgkSSDSensorSideSupportWidth,
 341                                                                    0.5*fgkSSDSensorSideSupportWidth,
 342                                                            0.5*fgkSSDSensorCenterSupportThickness[0]
 343                                                                           -    fgkSSDSensorCenterSupportPosition};
 344   const Double_t SSDSensorSupportTransY[3] =
 345                                                                            {0.5*fgkSSDSensorSideSupportThickness[0],
 346                                                            -0.5*fgkSSDSensorSideSupportThickness[0]
 347                                                                -fgkSSDModuleSensorSupportDistance,
 348                                                             0.5*fgkSSDSensorCenterSupportWidth
 349                                                                            -0.5*fgkSSDModuleSensorSupportDistance};
 350   const Double_t SSDSensorSupportTransZ[3] = {0.,0.,
 351                                                                                 fgkSSDSensorCenterSupportThickness[0]};
 352   ////////////////////////////////////////////////////////
 353   //Rotational Parameters SSDSensorSupportAssembly:
 354   ////////////////////////////////////////////////////////
 355   const Double_t SSDSensorSupportRotPhi[3]   = {   0., 180., 270.};
 356   const Double_t SSDSensorSupportRotTheta[3] = {  90.,  90.,  90.};
 357   const Double_t SSDSensorSupportRotPsi[3]   = {- 90.,- 90.,- 90.};
 358   ////////////////////////////////////////////////////////////////
 359   //Name of CombiTrans Transformation of SSDSensorSupportAssembly:
 360   ////////////////////////////////////////////////////////////////
 361   char SSDSensorSupportCombiTransName[40];
 362   char SSDSensorSupportRotName[40];
 363   TGeoCombiTrans *SSDSensorSupportLocalMatrix[fgkSSDSensorSupportCombiTransNumber];
 364   for(Int_t i=0; i<fgkSSDSensorSupportCombiTransNumber; i++){
 365                 sprintf(SSDSensorSupportCombiTransName,"SSDSensorSupportCombiTrans%i",i);
 366                 sprintf(SSDSensorSupportRotName,"SSDSensorSupportRot%i",i);
 367                 SSDSensorSupportLocalMatrix[i] =
 368                                  new TGeoCombiTrans(SSDSensorSupportCombiTransName,
 369                                                                         SSDSensorSupportTransX[i],
 370                                                                         SSDSensorSupportTransY[i],
 371                                                                         SSDSensorSupportTransZ[i],
 372                                                                         new TGeoRotation(SSDSensorSupportRotName,
 373                                                                                                           SSDSensorSupportRotPhi[i],
 374                                                                                                         SSDSensorSupportRotTheta[i],
 375                                                                                                     SSDSensorSupportRotPsi[i]));
 376            SSDSensorSupportCombiTransMatrix[i] = SSDSensorSupportLocalMatrix[i];
 377   }
 378 }
 379 /////////////////////////////////////////////////////////////////////////////////
 380 void AliITSv11GeometrySSD::SetSSDModuleCombiTransMatrix(Double_t SSDChipCablesHeigth){
 381 /////////////////////////////////////////////////////////////////////////////////
 382 //Translation Parameters SSDModuleAssembly:
 383 ////////////////////////////////////////////////////////
 384   const Double_t SSDModuleTransX[7] = {0.5*fgkSSDStiffenerLength,
 385                                                  0.5*fgkSSDChipLength+0.5*(fgkSSDStiffenerLength
 386                                        - (fgkSSDChipNumber*fgkSSDChipLength+(fgkSSDChipNumber-1)
 387                                            * fgkSSDChipSeparationLength)),
 388                                        - fgkSSDModuleStiffenerPosition[0]+0.5*fgkSSDSensorWidth,
 389                                    0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
 390                                            -       (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
 391                                 0.5*fgkSSDStiffenerLength-0.5*fgkSSDModuleSensorSupportDistance
 392                            - fgkSSDCoolingBlockLength,
 393                                 0.5*(fgkSSDStiffenerLength+fgkSSDChipCablesLength[1]
 394                            + (fgkSSDChipNumber-1)*fgkSSDChipCablesLength[0]),
 395                                 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
 396                            +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)};
 397   const Double_t SSDModuleTransY[7] = {0.5*fgkSSDStiffenerWidth,
 398                                        0.5*fgkSSDChipWidth+(fgkSSDStiffenerWidth
 399                                          - fgkSSDStiffenerToChipDist-fgkSSDChipWidth),
 400                                      - fgkSSDModuleStiffenerPosition[1]+0.5*fgkSSDSensorLength,
 401                                        fgkSSDStiffenerWidth,
 402                                        0.,
 403                                        fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
 404                                          - fgkSSDStiffenerWidth
 405                                      + fgkSSDStiffenerToChipDist+fgkSSDChipWidth,
 406                                        fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
 407                                          - fgkSSDStiffenerWidth};
 408   const Double_t SSDModuleTransZ[7] = {0.5*fgkSSDStiffenerHeight,
 409                                      - 0.5*fgkSSDChipHeight,
 410                                        0.5*fgkSSDSensorHeight-fgkSSDStiffenerHeight-fgkSSDChipHeight
 411                                          - SSDChipCablesHeigth,
 412                                      - 0.5*fgkSSDFlexHeight[0],
 413                                        fgkSSDStiffenerHeight,
 414                                      - fgkSSDChipHeight,
 415                                      - 0.5*fgkSSDChipHeight};
 416   ////////////////////////////////////////////////////////
 417   //Rotational Parameters SSDModuleAssembly:
 418   ////////////////////////////////////////////////////////
 419   const Double_t SSDModuleRotPhi[7]   = {   0.,   0.,  90.,   0.,   0.,  90., 180.};
 420   const Double_t SSDModuleRotTheta[7] = {   0.,   0.,   0.,   0.,   0.,   0.,   0.};
 421   const Double_t SSDModuleRotPsi[7]   = {   0.,   0.,   0.,   0.,   0.,   0.,   0.};
 422   ////////////////////////////////////////////////////////
 423   //Name of CombiTrans Transformation of SSDModuleAssembly:
 424   ////////////////////////////////////////////////////////
 425   const char* SSDModuleCombiTransName[7] = {"SSDStiffenerCombiTrans",
 426                                                                                              "SSDChipCombiTrans",
 427                                                                                            "SSDSensorCombiTrans",
 428                                                                                             "SSDFlex0CombiTrans",
 429                                                                                  "SSDCoolingBlockCombiTrans",
 430                                                                                    "SSDChipCablesCombiTrans",
 431                                                                                         "SSDFlex1CombiTrans"};
 432   const char* SSDModuleRotName[7] = {"SSDStiffenerRotName",
 433                                                                                   "SSDChipRotName",
 434                                                                                 "SSDSensorRotName",
 435                                                                                  "SSDFlex0RotName",
 436                                                                   "SSDCoolingBlockRotName",
 437                                                                         "SSDChipCablesRotName",
 438                                                                                 "SSDFlex1RotName"};
 439   TGeoCombiTrans *SSDModuleLocalMatrix[fgkSSDModuleCombiTransNumber];
 440   for(Int_t i=0; i<fgkSSDModuleCombiTransNumber; i++){
 441                                         SSDModuleLocalMatrix[i] =
 442                                         new TGeoCombiTrans(SSDModuleCombiTransName[i],
 443                                                                            SSDModuleTransX[i],
 444                                                                            SSDModuleTransY[i],
 445                                                                            SSDModuleTransZ[i],
 446                                                                            new TGeoRotation(SSDModuleRotName[i],
 447                                                                                                                 SSDModuleRotPhi[i],
 448                                                                                                         SSDModuleRotTheta[i],
 449                                                                                                         SSDModuleRotPsi[i]));
 450     SSDModuleCombiTransMatrix[i] = SSDModuleLocalMatrix[i];
 451   }
 452 }
 453 /////////////////////////////////////////////////////////////////////////////////
 454 void AliITSv11GeometrySSD::SetCarbonFiberJunctionCombiTransMatrix(){
 455 /////////////////////////////////////////////////////////////////////////////////
 456   //Translation Parameters CarbonFiberJunction:
 457   ////////////////////////////////////////////////////////
 458   const Double_t CarbonFiberJunctionTransX[3] =
 459                                 {  0.0,fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength
 460                                  * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
 461   const Double_t CarbonFiberJunctionTransY[3] =
 462                                                                           {  0.0, 0.0,fgkCarbonFiberTriangleLength
 463                                  *   TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
 464   const Double_t CarbonFiberJunctionTransZ[3] = {  0.0,  0.0,  0.0};
 465   ////////////////////////////////////////////////////////
 466   //Rotational Parameters CarbonFiberJunction:
 467   ////////////////////////////////////////////////////////
 468   const Double_t CarbonFiberJunctionRotPhi[3]   = {   0., 120., 240.};
 469   const Double_t CarbonFiberJunctionRotTheta[3] = {   0.,   0.,   0.};
 470   const Double_t CarbonFiberJunctionRotPsi[3]   = {   0.,   0.,   0.};
 471   ///////////////////////////////////////////////////////////
 472   //Name of CombiTrans Transformation of CarbonFiberJunction:
 473   ///////////////////////////////////////////////////////////
 474   char CarbonFiberJunctionCombiTransName[40];
 475   char CarbonFiberJunctionRotName[40];
 476   TGeoCombiTrans *CarbonFiberJunctionLocalMatrix[fgkCarbonFiberJunctionCombiTransNumber];
 477   for(Int_t i=0; i<fgkCarbonFiberJunctionCombiTransNumber; i++) {
 478                 sprintf(CarbonFiberJunctionCombiTransName,"CarbonFiberJunctionCombiTrans%i",i);
 479                 sprintf(CarbonFiberJunctionRotName,"CarbonFiberJunctionRot%i",i);
 480                 CarbonFiberJunctionLocalMatrix[i] =
 481                                         new TGeoCombiTrans(CarbonFiberJunctionCombiTransName,
 482                                                                            CarbonFiberJunctionTransX[i],
 483                                                                            CarbonFiberJunctionTransY[i],
 484                                                                            CarbonFiberJunctionTransZ[i],
 485                                                                 new TGeoRotation(CarbonFiberJunctionRotName,
 486                                                                                                 CarbonFiberJunctionRotPhi[i],
 487                                                                                                 CarbonFiberJunctionRotTheta[i],
 488                                                                                                 CarbonFiberJunctionRotPsi[i]));
 489     CarbonFiberJunctionCombiTransMatrix[i] = CarbonFiberJunctionLocalMatrix[i];
 490   }
 491 }
 492 /////////////////////////////////////////////////////////////////////////////////
 493 void AliITSv11GeometrySSD::SetEndLadderCarbonFiberJunctionCombiTransMatrix(Int_t i){
 494 /////////////////////////////////////////////////////////////////////////////////
 495   //Translation Parameters EndLadderCarbonFiberJunction:
 496   ////////////////////////////////////////////////////////
 497   const Double_t EndLadderCarbonFiberJunctionTransX[3] =
 498                                 {  0.0,fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength
 499                 *            TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
 500   const Double_t EndLadderCarbonFiberJunctionTransY[3] =
 501                                                                                 {  0.0, 0.0,fgkCarbonFiberTriangleLength
 502                 *            TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
 503   const Double_t EndLadderCarbonFiberJunctionTransZ[3] = {  0.0,  0.0,
 504                                                    0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
 505                                                            -fgkEndLadderCarbonFiberUpperJunctionLength[i])};
 506   ////////////////////////////////////////////////////////
 507   //Rotational Parameters EndLadderCarbonFiberJunction:
 508   ////////////////////////////////////////////////////////
 509   const Double_t EndLadderCarbonFiberJunctionRotPhi[3]   = {   0., 120., 240.};
 510   const Double_t EndLadderCarbonFiberJunctionRotTheta[3] = {   0.,   0.,   0.};
 511   const Double_t EndLadderCarbonFiberJunctionRotPsi[3]   = {   0.,   0.,   0.};
 512   ///////////////////////////////////////////////////////////
 513   //Name of CombiTrans Transformation of CarbonFiberJunction:
 514   ///////////////////////////////////////////////////////////
 515   char EndLadderCarbonFiberJunctionCombiTransName[40];
 516   char EndLadderCarbonFiberJunctionRotName[40];
 517   TGeoCombiTrans *EndLadderCarbonFiberJunctionLocalMatrix[fgkEndLadderCarbonFiberJunctionCombiTransNumber];
 518   for(Int_t i=0; i<fgkEndLadderCarbonFiberJunctionCombiTransNumber; i++) {
 519         sprintf(EndLadderCarbonFiberJunctionCombiTransName,"EndLadderCarbonFiberJunctionCombiTrans%i",i);
 520         sprintf(EndLadderCarbonFiberJunctionRotName,"EndLadderCarbonFiberJunctionRot%i",i);
 521         EndLadderCarbonFiberJunctionLocalMatrix[i] =
 522         new TGeoCombiTrans(EndLadderCarbonFiberJunctionCombiTransName,
 523                                                                                   EndLadderCarbonFiberJunctionTransX[i],
 524                                                                                   EndLadderCarbonFiberJunctionTransY[i],
 525                                                                                   EndLadderCarbonFiberJunctionTransZ[i],
 526                                                 new TGeoRotation(EndLadderCarbonFiberJunctionRotName,
 527                                                                                   EndLadderCarbonFiberJunctionRotPhi[i],
 528                                                                                 EndLadderCarbonFiberJunctionRotTheta[i],
 529                                                                             EndLadderCarbonFiberJunctionRotPsi[i]));
 530     EndLadderCarbonFiberJunctionCombiTransMatrix[i] =
 531                                                                          EndLadderCarbonFiberJunctionLocalMatrix[i];
 532   }
 533 }
 534 ////////////////////////////////////////////////////////////////////////////////
 535 void AliITSv11GeometrySSD::SetCarbonFiberAssemblyCombiTransMatrix(){
 536 /////////////////////////////////////////////////////////////////////////////////
 537   //Translation Parameters CarbonFiberAssembly:
 538   ////////////////////////////////////////////////////////
 539   const Double_t CarbonFiberAssemblyTransX[3] = {  0.0,  0.0,  0.0};
 540   const Double_t CarbonFiberAssemblyTransY[3] =
 541                                                                                 {  0.5*fgkCarbonFiberJunctionWidth, 0.0,
 542                                         fgkCarbonFiberJunctionWidth-fgkCarbonFiberLowerSupportWidth
 543                            -    fgkCarbonFiberLowerSupportVolumePosition[0]
 544                            -    fgkCarbonFiberLowerSupportVolumePosition[1]};
 545   const Double_t CarbonFiberAssemblyTransZ[3] =
 546                                                   {  0.0,  0.0,-  0.5*fgkCarbonFiberLowerSupportHeight};
 547   ////////////////////////////////////////////////////////
 548   //Rotational Parameters CarbonFiberAssembly:
 549   ////////////////////////////////////////////////////////
 550   const Double_t CarbonFiberAssemblyRotPhi[3]   = {   0.,  90.,   0.};
 551   const Double_t CarbonFiberAssemblyRotTheta[3] = {  90.,
 552                                                                                         -fgkCarbonFiberTriangleAngle,   0.};
 553   const Double_t CarbonFiberAssemblyRotPsi[3]   = {   0.,- 90.,   0.};
 554   ///////////////////////////////////////////////////////////
 555   //Name of CombiTrans Transformation of CarbonFiberAssembly:
 556   ///////////////////////////////////////////////////////////
 557   char CarbonFiberAssemblyCombiTransName[30];
 558   char CarbonFiberAssemblyRotName[30];
 559   TGeoCombiTrans *CarbonFiberAssemblyLocalMatrix[fgkCarbonFiberAssemblyCombiTransNumber];
 560   for(Int_t i=0; i<fgkCarbonFiberAssemblyCombiTransNumber; i++) {
 561         sprintf(CarbonFiberAssemblyCombiTransName,"CarbonFiberAssemblyCombiTrans%i",i);
 562         sprintf(CarbonFiberAssemblyRotName,"CarbonFiberAssemblyRot%i",i);
 563         CarbonFiberAssemblyLocalMatrix[i] =
 564                                                 new TGeoCombiTrans(CarbonFiberAssemblyCombiTransName,
 565                                                                                    CarbonFiberAssemblyTransX[i],
 566                                                                                    CarbonFiberAssemblyTransY[i],
 567                                                                                    CarbonFiberAssemblyTransZ[i],
 568                                                  new TGeoRotation(CarbonFiberAssemblyRotName,
 569                                                                                    CarbonFiberAssemblyRotPhi[i],
 570                                                                                    CarbonFiberAssemblyRotTheta[i],
 571                                                                                    CarbonFiberAssemblyRotPsi[i]));
 572     CarbonFiberAssemblyCombiTransMatrix[i] = CarbonFiberAssemblyLocalMatrix[i];
 573   }
 574 }
 575 /////////////////////////////////////////////////////////////////////////////////
 576 void AliITSv11GeometrySSD::SetCoolingTubeSupportCombiTransMatrix(){
 577   ////////////////////////////////////////////////////////
 578   //Translation Parameters CoolingTubeSupport:
 579   ////////////////////////////////////////////////////////
 580   Double_t Phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
 581                                                                                                         /fgkCoolingTubeSupportRmax);
 582   const Double_t CoolingTubeSupportTransX[2] =
 583                                                   {0.,2.*fgkCoolingTubeSupportRmax*TMath::Cos(Phi)
 584                                                 +  2.*(fgkCoolingTubeSupportLength
 585                                                 -  fgkCoolingTubeSupportRmax*(1.+TMath::Cos(Phi)))
 586                                                 +  fgkCarbonFiberTriangleLength
 587                                                 -  2.0*fgkCarbonFiberJunctionLength};
 588   const Double_t CoolingTubeSupportTransY[2] = {  0.0,  0.0};
 589   const Double_t CoolingTubeSupportTransZ[2] = {  0.0,  0.0};
 590   ////////////////////////////////////////////////////////
 591   //Rotational Parameters CoolingTubeSupport:
 592   ////////////////////////////////////////////////////////
 593   const Double_t CoolingTubeSupportRotPhi[2]   = {   0., 180.};
 594   const Double_t CoolingTubeSupportRotTheta[2] = {   0.,   0.};
 595   const Double_t CoolingTubeSupportRotPsi[2]   = {   0.,   0.};
 596   ///////////////////////////////////////////////////////////
 597   //Name of CombiTrans Transformation of CarbonFiberJunction:
 598   ///////////////////////////////////////////////////////////
 599   char CoolingTubeSupportCombiTransName[40];
 600   char CoolingTubeSupportRotName[40];
 601   TGeoCombiTrans *CoolingTubeSupportLocalMatrix[fgkCoolingTubeSupportCombiTransNumber];
 602   for(Int_t i=0; i<fgkCoolingTubeSupportCombiTransNumber; i++) {
 603         sprintf(CoolingTubeSupportCombiTransName,"CoolingTubeSupportCombiTrans%i",i);
 604         sprintf(CoolingTubeSupportRotName,"CoolingTubeSupportRot%i",i);
 605         CoolingTubeSupportLocalMatrix[i] =
 606                         new TGeoCombiTrans(CoolingTubeSupportCombiTransName,
 607                                                            CoolingTubeSupportTransX[i],
 608                                                            CoolingTubeSupportTransY[i],
 609                                                            CoolingTubeSupportTransZ[i],
 610                                                            new TGeoRotation(CoolingTubeSupportRotName,
 611                                                                                                 CoolingTubeSupportRotPhi[i],
 612                                                                                                 CoolingTubeSupportRotTheta[i],
 613                                                                                                 CoolingTubeSupportRotPsi[i]));
 614     CoolingTubeSupportCombiTransMatrix[i] = CoolingTubeSupportLocalMatrix[i];
 615   }
 616 }
 617 /////////////////////////////////////////////////////////////////////////////////
 618 void AliITSv11GeometrySSD::SetCoolingTubeCombiTransMatrix(){
 619   ////////////////////////////////////////////////////////
 620   //Translation Parameters CoolingTube:
 621   ////////////////////////////////////////////////////////
 622   const Double_t CoolingTubeTransX[2] = {  0.,  fgkCoolingTubeSeparation};
 623   const Double_t CoolingTubeTransY[2] = {  fgkCoolingTubeLength/2.0, fgkCoolingTubeLength/2.0};
 624   const Double_t CoolingTubeTransZ[2] = {  0.0,  0.};
 625   ////////////////////////////////////////////////////////
 626   //Rotational Parameters CoolingTube:
 627   ////////////////////////////////////////////////////////
 628   const Double_t CoolingTubeRotPhi[2]   = {   0.,   0.};
 629   const Double_t CoolingTubeRotTheta[2] = {  90.,  90.};
 630   const Double_t CoolingTubeRotPsi[2]   = {   0.,   0.};
 631   ///////////////////////////////////////////////////////////
 632   //Name of CombiTrans Transformation of CarbonFiberJunction:
 633   ///////////////////////////////////////////////////////////
 634   const char* CoolingTubeCombiTransName[fgkCoolingTubeCombiTransNumber] =
 635                                                         {"CoolingTubeCombiTrans0","CoolingTubeCombiTrans1"};
 636   const char* CoolingTubeRorationName[fgkCoolingTubeCombiTransNumber] =
 637                                                                 {"CoolingTubeRotation0","CoolingTubeRotation1"};
 638   TGeoCombiTrans *CoolingTubeLocalMatrix[fgkCoolingTubeCombiTransNumber];
 639   for(Int_t i=0; i<fgkCoolingTubeCombiTransNumber; i++) {
 640         CoolingTubeLocalMatrix[i] =
 641                         new TGeoCombiTrans(CoolingTubeCombiTransName[i],
 642                                                            CoolingTubeTransX[i],
 643                                                            CoolingTubeTransY[i],
 644                                                            CoolingTubeTransZ[i],
 645                                                            new TGeoRotation(CoolingTubeRorationName[i],
 646                                                                             CoolingTubeRotPhi[i],
 647                                                                             CoolingTubeRotTheta[i],
 648                                                                             CoolingTubeRotPsi[i]    ) );
 649     CoolingTubeTransMatrix[i] = CoolingTubeLocalMatrix[i];
 650   }
 651 }
 652 /////////////////////////////////////////////////////////////////////////////////
 653 void AliITSv11GeometrySSD::SetLadderSegmentCombiTransMatrix(){
 654 /////////////////////////////////////////////////////////////////////////////////
 655   //Translation Parameters LadderSegment:
 656   ////////////////////////////////////////////////////////
 657         const Double_t LadderSegmentTransX[fgkLadderSegmentCombiTransNumber] = {  0.,
 658          -  0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
 659                          fgkCarbonFiberTriangleLength+fgkCarbonFiberJunctionToSensorSupport,
 660                          fgkCarbonFiberJunctionLength-(fgkCoolingTubeSupportLength
 661          -       fgkCoolingTubeSupportRmax),
 662                 0.5*(fgkCarbonFiberTriangleLength-fgkCoolingTubeSeparation)};
 663         const Double_t LadderSegmentTransY[fgkLadderSegmentCombiTransNumber] = {  0.,
 664          -      (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 665                          fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 666          +               0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 667          -               0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
 668          -            fgkSSDSensorCenterSupportThickness[0]),
 669                                   fgkCarbonFiberJunctionWidth-0.5*(fgkCarbonFiberLowerSupportWidth
 670          +            fgkSSDSensorCenterSupportLength
 671          -            fgkSSDSensorCenterSupportThickness[0])
 672          -                        fgkSSDSensorCenterSupportPosition,
 673                                   fgkCarbonFiberJunctionWidth-fgkCarbonFiberLowerSupportWidth
 674          -                        fgkCoolingTubeSupportToCarbonFiber,
 675                                                                                                  0.0};
 676         const Double_t LadderSegmentTransZ[fgkLadderSegmentCombiTransNumber] = {  0.,
 677          -        (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
 678          -         fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight),
 679                                                                                                                                                          0.,
 680          -     0.5*fgkCoolingTubeSupportHeight,
 681          -     0.5*fgkCoolingTubeSupportHeight};
 682 //////////////////////////////////////////////////
 683   //Rotational Parameters LadderSegment:
 684   ////////////////////////////////////////////////////////
 685   const Double_t LadderSegmentRotPhi[fgkLadderSegmentCombiTransNumber]   =
 686                                                                                                           {   0.,   0.,- 90.,   0.,  0.};
 687   const Double_t LadderSegmentRotTheta[fgkLadderSegmentCombiTransNumber] =
 688                                                                                                           {   0.,   0.,   0.,  90.,  0.};
 689   const Double_t LadderSegmentRotPsi[fgkLadderSegmentCombiTransNumber]   =
 690                                                                                                           {   0.,   0.,   0.,   0.,  0.};
 691   //////////////////////////////////////////////////////
 692   //Name of CombiTrans Transformation of LadderSegment:
 693   //////////////////////////////////////////////////////
 694   char LadderSegmentCombiTransName[40];
 695   char LadderSegmentRotName[40];
 696   TGeoCombiTrans *LadderSegmentLocalMatrix[fgkLadderSegmentCombiTransNumber];
 697   for(Int_t i=0; i<fgkLadderSegmentCombiTransNumber; i++) {
 698                 sprintf(LadderSegmentCombiTransName,"LadderSegmentCombiTrans%i",i);
 699                 sprintf(LadderSegmentRotName,"LadderSegmentRot%i",i);
 700                 LadderSegmentLocalMatrix[i] =
 701                                         new TGeoCombiTrans(LadderSegmentCombiTransName,
 702                                                                            LadderSegmentTransX[i],
 703                                                                            LadderSegmentTransY[i],
 704                                                                            LadderSegmentTransZ[i],
 705                                                                            new TGeoRotation(LadderSegmentRotName,
 706                                                                                                                 LadderSegmentRotPhi[i],
 707                                                                                                                 LadderSegmentRotTheta[i],
 708                                                                                                                 LadderSegmentRotPsi[i]));
 709     LadderSegmentCombiTransMatrix[i] = LadderSegmentLocalMatrix[i];
 710   }
 711 }
 712 /////////////////////////////////////////////////////////////////////////////////
 713 void AliITSv11GeometrySSD::SetEndLadderSegmentCombiTransMatrix(Int_t i){
 714 /////////////////////////////////////////////////////////////////////////////////
 715   //Translation Parameters EndLadderSegment:
 716   ////////////////////////////////////////////////////////
 717   const Double_t EndLadderSegmentTransX[4] = {0.0,
 718                                                                                           0.0,
 719                  -  0.25*(fgkSSDMountingBlockLength[0]
 720                          +      fgkSSDMountingBlockLength[1])
 721                          +  0.5*fgkCarbonFiberTriangleLength,
 722                                                                                           0.0};
 723   const Double_t EndLadderSegmentTransY[4] =
 724                                                          {0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],
 725                                                   i==0 ? 0. : fgkCarbonFiberLowerSupportWidth,
 726                                                          fgkEndLadderMountingBlockPosition[i],
 727                                                    (1-i)*(fgkEndLadderMountingBlockPosition[i]
 728                                                                                  +  0.5*fgkSSDMountingBlockWidth)};
 729   const Double_t EndLadderSegmentTransZ[4] = {0.0,
 730                                                                                           0.0,
 731                                                                                 -  fgkSSDMountingBlockHeight[1]
 732                                                                                 +  0.5*fgkSSDMountingBlockHeight[0],
 733                                                                             -  0.5*fgkCarbonFiberLowerSupportHeight};
 734   ////////////////////////////////////////////////////////
 735   //Rotational Parameters EndLadderSegment:
 736   ////////////////////////////////////////////////////////
 737   const Double_t EndLadderSegmentRotPhi[4]   = {   0.,  90.,   0.,   0.};
 738   const Double_t EndLadderSegmentRotTheta[4] = {  90.,-fgkCarbonFiberTriangleAngle,
 739                                                                                                    0.,   0.};
 740   const Double_t EndLadderSegmentRotPsi[4]   = {   0.,- 90.,   0.,   0.};
 741   ////////////////////////////////////////////////////////
 742   //Name of CombiTrans Transformation of EndLadderSegment:
 743   ////////////////////////////////////////////////////////
 744   char EndLadderSegmentCombiTransName[30];
 745   char EndLadderSegmentRotName[30];
 746   TGeoCombiTrans *EndLadderSegmentLocalMatrix[fgkEndLadderSegmentCombiTransNumber];
 747   for(Int_t i=0; i<fgkEndLadderSegmentCombiTransNumber; i++){
 748                 sprintf(EndLadderSegmentCombiTransName,"EndLadderSegmentCombiTrans%i",i);
 749                 sprintf(EndLadderSegmentRotName,"EndLadderSegmentRot%i",i);
 750                 EndLadderSegmentLocalMatrix[i] =
 751                                 new TGeoCombiTrans(EndLadderSegmentCombiTransName,
 752                                                                    EndLadderSegmentTransX[i],
 753                                                                    EndLadderSegmentTransY[i],
 754                                                                    EndLadderSegmentTransZ[i],
 755                                                                    new TGeoRotation(EndLadderSegmentRotName,
 756                                                                                                         EndLadderSegmentRotPhi[i],
 757                                                                                                         EndLadderSegmentRotTheta[i],
 758                                                                                                         EndLadderSegmentRotPsi[i]));
 759     EndLadderSegmentCombiTransMatrix[i] = EndLadderSegmentLocalMatrix[i];
 760   }
 761 }
 762 /////////////////////////////////////////////////////////////////////////////////
 763 void AliITSv11GeometrySSD::SetLadderCableCombiTransMatrix(Int_t iLayer){
 764 ////////////////////////////////////////////////////////////////////////////////
 765 // Translation Parameters for LadderCable
 766 /////////////////////////////////////////
 767   Double_t SSDFlexRadius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
 768                                              + fgkSSDFlexHeight[1];
 769   Double_t SSDFlexRadiusMax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
 770                                                         /  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
 771   Double_t SSDLadderCableTransX[3];
 772   SSDLadderCableTransX[0] = (SSDFlexRadiusMax-fgkSSDFlexHeight[1]-SSDFlexRadius)
 773                                                   *   TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad())
 774                                                   *       TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad());
 775   SSDLadderCableTransX[1] = ((SSDFlexRadiusMax-fgkSSDFlexHeight[1]-SSDFlexRadius)
 776                                                   -     SSDLadderCableTransX[0]
 777                                                   /     TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad()))
 778                                                   *     TMath::Cos(fgkSSDFlexAngle*TMath::DegToRad());
 779   SSDLadderCableTransX[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
 780                                                   *       TMath::DegToRad()*SSDFlexRadiusMax
 781                                                   -     fgkSSDFlexLength[2]-TMath::Pi()
 782                                                   *       fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
 783                                                   -       fgkSSDLadderCableWidth)
 784                                                   *       TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad());
 785   Double_t SSDLadderCableTransZ[3] = {SSDLadderCableTransX[0]
 786                                                   *     TMath::Tan(2.*fgkSSDFlexAngle*TMath::DegToRad()),
 787                                                         SSDLadderCableTransX[1]
 788                                                   *     TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad()),
 789                                                         SSDLadderCableTransX[2]
 790                                                   *     TMath::Tan(2.*fgkSSDFlexAngle*TMath::DegToRad())};
 791   TGeoRotation* LocalLadderCableRot[3];
 792   LocalLadderCableRot[0] = new TGeoRotation("LocalLadderCableRot0",90.,0.,0.);
 793   LocalLadderCableRot[1] = new TGeoRotation("LocalLadderCableRot1",90.,60.,-90.);
 794   LocalLadderCableRot[2] = new TGeoRotation("LocalLadderCableRot2");
 795   LocalLadderCableRot[2]->SetRotation((*LocalLadderCableRot[1])
 796                                                  *                        (*LocalLadderCableRot[0]));
 797 ////////////////////////////////////////////
 798 // LocalLadderCableCombiTransMatrix
 799 ////////////////////////////////////////////
 800   const Int_t LocalLadderSideCablesNumber = 2;
 801   const Int_t LocalLadderCombiTransNumber = 5;
 802   TGeoCombiTrans** LocalLadderCableCombiTransMatrix[LocalLadderSideCablesNumber];
 803   for(Int_t i=0; i<LocalLadderSideCablesNumber; i++)
 804         LocalLadderCableCombiTransMatrix[i] =
 805                                                            new TGeoCombiTrans*[LocalLadderCombiTransNumber];
 806 ///////////////////////////////////////////
 807 // Left Side Ladder Cables Transformations
 808 ///////////////////////////////////////////
 809   LocalLadderCableCombiTransMatrix[0][0]  =
 810                                                 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
 811                                                 0.,0.,NULL);
 812   LocalLadderCableCombiTransMatrix[0][1] = LadderSegmentCombiTransMatrix[1];
 813   LocalLadderCableCombiTransMatrix[0][2] =
 814                                                 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
 815                                                                                    fgkSSDModuleStiffenerPosition[1],0.,0);
 816   LocalLadderCableCombiTransMatrix[0][3] = SSDModuleCombiTransMatrix[6];
 817   LocalLadderCableCombiTransMatrix[0][4] =
 818                                                 new TGeoCombiTrans(-SSDLadderCableTransX[0]
 819                                                 -     SSDLadderCableTransX[1]-SSDLadderCableTransX[2]
 820                                                 +     fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
 821                                                           0.,
 822                                                           0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
 823                                                 +         fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
 824                                                 +     SSDLadderCableTransZ[0]-SSDLadderCableTransZ[1]
 825                                                 +         SSDLadderCableTransZ[2],LocalLadderCableRot[2]);
 826 ///////////////////////////////////////////
 827 // Rigth Side Ladder Cables Transformations
 828 ///////////////////////////////////////////
 829  for(Int_t i=0; i<LocalLadderCombiTransNumber; i++)
 830    LocalLadderCableCombiTransMatrix[1][i] =
 831                         (i!=3 ? LocalLadderCableCombiTransMatrix[0][i]:
 832                                         SSDModuleCombiTransMatrix[3]);
 833 ///////////////////////////////////////////
 834 // Setting LadderCableCombiTransMatrix
 835 ///////////////////////////////////////////
 836 Int_t BeamAxisTrans[3] = {0,0,0};
 837 switch(iLayer){
 838 case 5:
 839         BeamAxisTrans[0] = fgkSSDLay5SensorsNumber/2;
 840         BeamAxisTrans[1] = BeamAxisTrans[0]+1;
 841         BeamAxisTrans[2] = BeamAxisTrans[0]-1;
 842         break;
 843 case 6:
 844         BeamAxisTrans[0] = (fgkSSDLay6SensorsNumber-1)/2;
 845         BeamAxisTrans[1] = BeamAxisTrans[0]+1;
 846         BeamAxisTrans[2] = BeamAxisTrans[0];
 847         break;
 848 }
 849  TGeoHMatrix* LocalLadderCableHMatrix[LocalLadderSideCablesNumber];
 850  TGeoRotation* LadderCableRot;
 851  TGeoTranslation* LadderCableTrans;
 852  for(Int_t i=0; i<LocalLadderSideCablesNumber; i++){
 853         LocalLadderCableHMatrix[i] = new TGeoHMatrix();
 854         for(Int_t j=0; j<LocalLadderCombiTransNumber; j++){
 855                   LocalLadderCableHMatrix[i]->MultiplyLeft(
 856                   LocalLadderCableCombiTransMatrix[i][LocalLadderCombiTransNumber-j-1]);
 857         }
 858         LadderCableRot = new TGeoRotation();
 859         LadderCableRot->SetMatrix(LocalLadderCableHMatrix[i]->GetRotationMatrix());
 860     LadderCableTrans = new TGeoTranslation();
 861     Double_t* LadderCableTransVector = LocalLadderCableHMatrix[i]->GetTranslation();
 862     LadderCableTrans->SetTranslation(LadderCableTransVector[0],
 863                                                                          LadderCableTransVector[1]
 864                                         +                (i==0 ? BeamAxisTrans[0] : 0.)
 865                                         *                                fgkCarbonFiberJunctionWidth,
 866                                                                          LadderCableTransVector[2]);
 867         LadderCableCombiTransMatrix[i] = new TGeoCombiTrans(*LadderCableTrans,
 868                                                                                                    *LadderCableRot);
 869         }
 870         LadderCableCombiTransMatrix[2] =
 871                                         AddTranslationToCombiTrans(LadderCableCombiTransMatrix[1],0.,
 872                                         BeamAxisTrans[1]*fgkCarbonFiberJunctionWidth,0.);
 873         LadderCableCombiTransMatrix[3] =
 874                                         AddTranslationToCombiTrans(LadderCableCombiTransMatrix[0],0.,
 875                                         BeamAxisTrans[2]*fgkCarbonFiberJunctionWidth,0.);
 876  }
 877 /////////////////////////////////////////////////////////////////////////////////
 878 TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupportShape(Double_t length,
 879                                                         Double_t height,Double_t width,Double_t* thickness){
 880 ////////////////////////////////////////////////////////////////////////////////
 881   const Int_t VertexNumber = 4;
 882   const Int_t ShapesNumber = 2;
 883   Double_t Width[2] = {width,width};
 884   TVector3** VertexPosition[ShapesNumber];
 885   for(Int_t i = 0; i<ShapesNumber; i++) VertexPosition[i] =
 886                                                                                                         new TVector3*[VertexNumber];
 887   //First Shape Vertex Positioning
 888   VertexPosition[0][0] = new TVector3();
 889   VertexPosition[0][1] = new TVector3(height);
 890   VertexPosition[0][2] = new TVector3(thickness[0]);
 891   VertexPosition[0][3] = new TVector3(*VertexPosition[0][1]);
 892   //Second Shape Vertex Positioning
 893   VertexPosition[1][0] = new TVector3(*VertexPosition[0][0]);
 894   VertexPosition[1][1] = new TVector3(length);
 895   VertexPosition[1][2] = new TVector3(thickness[1]);
 896   VertexPosition[1][3] = new TVector3(VertexPosition[1][1]->X());
 897   char* SSDSensorSupportShapeName[ShapesNumber] =
 898                                                         {"SSDSensorSupportShape1","SSDSensorSupportShape2"};
 899   TGeoArb8* SSDSensorSupportShape[ShapesNumber];
 900   for(Int_t i = 0; i< ShapesNumber; i++) SSDSensorSupportShape[i] =
 901                                            GetArbShape(VertexPosition[i],Width,i==0 ?
 902                                                                                                          thickness[1]: thickness[0],
 903                                                                                                   SSDSensorSupportShapeName[i]);
 904   /////////////////////////////////////
 905   //Setting Translations and Rotations:
 906   /////////////////////////////////////
 907   TGeoRotation* SSDSensorSupportShapeRot[2];
 908   SSDSensorSupportShapeRot[0] =
 909                                          new TGeoRotation("SSDSensorSupportShapeRot1",180.,0.,0.);
 910   SSDSensorSupportShapeRot[1] =
 911                                          new TGeoRotation("SSDSensorSupportShapeRot2",90.,90.,-90.);
 912   TGeoTranslation* SSDSensorSupportShapeTrans =
 913                                          new TGeoTranslation("SSDSensorSupportShapeTrans",0.,0.,
 914                                                                                                                           0.5*thickness[0]);
 915   TGeoCombiTrans* SSDSensorSupportCombiTrans =
 916           new TGeoCombiTrans("SSDSensorSupportCombiTrans",0.5*thickness[0],width,0.,
 917                                                   new TGeoRotation((*SSDSensorSupportShapeRot[1])
 918                                                 *                  (*SSDSensorSupportShapeRot[0])));
 919   TGeoVolume* SSDSensorSupportCompVolume =
 920                                                   new TGeoVolumeAssembly("SSDSensorSupportCompVolume");
 921   SSDSensorSupportCompVolume->AddNode(new TGeoVolume("SSDSensorSupportVolume1",
 922                                                         SSDSensorSupportShape[0],fgkSSDSensorSupportMedium),1,
 923                                                         SSDSensorSupportShapeTrans);
 924   SSDSensorSupportCompVolume->AddNode(new TGeoVolume("SSDSensorSupportVolume2",
 925                                                         SSDSensorSupportShape[1],fgkSSDSensorSupportMedium),1,
 926                                                         SSDSensorSupportCombiTrans);
 927   return SSDSensorSupportCompVolume;
 928 }
 929 /////////////////////////////////////////////////////////////////////////////////
 930 TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Int_t VolumeKind, Int_t n){
 931 ////////////////////////////////////////////////////////////////////////////////
 932   TGeoVolume* SSDSensorSupport;
 933   Double_t SideSupportThickness[2] = {fgkSSDSensorSideSupportThickness[0],
 934                                                                                    fgkSSDSensorSideSupportThickness[1]};
 935   VolumeKind == 0 ? SSDSensorSupport = GetSSDSensorSupportShape(
 936                                                                 fgkSSDSensorSideSupportLength,
 937                                                                 fgkSSDSensorSideSupportHeight[(n==0 ? 0 : 1)],
 938                                                                 fgkSSDSensorSideSupportWidth,
 939                                                                 SideSupportThickness) :
 940     SSDSensorSupport = GetSSDSensorSupportShape(fgkSSDSensorCenterSupportLength,
 941                                                         fgkSSDSensorCenterSupportHeight[(n==0 ? 0 : 1)],
 942                                                             fgkSSDSensorCenterSupportWidth,
 943                                                             SideSupportThickness);
 944   return SSDSensorSupport;
 945 }
 946 /////////////////////////////////////////////////////////////////////////////////
 947 TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupportAssembly(Int_t n){
 948 ////////////////////////////////////////////////////////////////////////////////
 949   TGeoVolume* SSDSensorSupportAssembly =
 950                                                          new TGeoVolumeAssembly("SSDSensorSupportAssembly");
 951   const Int_t VolumeNumber = 2;
 952   TGeoVolume* SSDSensorSupport[VolumeNumber];
 953   for(Int_t i=0; i<VolumeNumber; i++) SSDSensorSupport[i] =
 954                                                                                                                 GetSSDSensorSupport(i,n);
 955   SetSSDSensorSupportCombiTransMatrix();
 956   for(Int_t i=0; i<fgkSSDSensorSupportCombiTransNumber; i++)
 957         SSDSensorSupportAssembly->AddNode((i<2 ? SSDSensorSupport[0]:
 958                                                                                          SSDSensorSupport[1]),
 959                                                                                  i+1,SSDSensorSupportCombiTransMatrix[i]);
 960   return SSDSensorSupportAssembly;
 961 }
 962 /////////////////////////////////////////////////////////////////////////////////
 963 TGeoVolume* AliITSv11GeometrySSD::GetSSDModule(Int_t iChipCablesHeight){
 964 ////////////////////////////////////////////////////////////////////////////////
 965   TGeoVolume* SSDModuleVolume[fgkSSDModuleCombiTransNumber-1];
 966   SSDModuleVolume[0] = GetSSDStiffenerAssembly();
 967   SSDModuleVolume[1] = GetSSDChipAssembly();
 968   SSDModuleVolume[2] = GetSSDSensor();
 969   SSDModuleVolume[3] = GetSSDFlexAssembly();
 970   SSDModuleVolume[4] = GetSSDCoolingBlockAssembly();
 971   SSDModuleVolume[5] = GetSSDChipCablesAssembly(fgkSSDChipCablesHeight[iChipCablesHeight+2]);
 972   SetSSDModuleCombiTransMatrix(fgkSSDChipCablesHeight[iChipCablesHeight+2]);
 973   TGeoCombiTrans* SSDModuleGlobalCombiTrans =
 974                                                                    new TGeoCombiTrans("SSDModuleGlobalCombiTrans",
 975                                                                            fgkSSDModuleStiffenerPosition[0],
 976                                                                            fgkSSDModuleStiffenerPosition[1],0.,NULL);
 977   TGeoHMatrix* SSDModuleHMatrix[fgkSSDModuleCombiTransNumber];
 978   TGeoVolume* SSDModule = new TGeoVolumeAssembly("SSDModule");
 979   for(Int_t i=0; i<fgkSSDModuleCombiTransNumber; i++){
 980         SSDModuleHMatrix[i] = new TGeoHMatrix((*SSDModuleGlobalCombiTrans)
 981                                                 *                                 (*SSDModuleCombiTransMatrix[i]));
 982         SSDModule->AddNode(i==fgkSSDModuleCombiTransNumber-1 ? SSDModuleVolume[3] :
 983                                                   SSDModuleVolume[i],i!=fgkSSDModuleCombiTransNumber-1?1:2,
 984                                                   SSDModuleHMatrix[i]);
 985   }
 986   return SSDModule;
 987 }
 988 /////////////////////////////////////////////////////////////////////////////////
 989 TGeoVolume* AliITSv11GeometrySSD::GetSSDSensor(){
 990 ////////////////////////////////////////////////////////////////////////////////
 991   Double_t fgkSSDSensorSensitiveLength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
 992   Double_t fgkSSDSensorSensitiveWidth  = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
 993   TGeoBBox* SSDSensorSensitiveShape = new TGeoBBox("SSDSensorSensitiveShape",
 994                                                 0.5*fgkSSDSensorSensitiveLength,
 995                                                 0.5*fgkSSDSensorSensitiveWidth,
 996                                                 0.5*fgkSSDSensorHeight);
 997   TGeoVolume* SSDSensorSensitive =
 998       new TGeoVolume(fgkSSDSensitiveVolName,SSDSensorSensitiveShape,fgkSSDSensorMedium);
 999   SSDSensorSensitive->SetLineColor(fColorSilicon);
1000   TGeoBBox* SSDSensorInsensitiveShape[2];
1001   SSDSensorInsensitiveShape[0] = new TGeoBBox("SSDSensorInSensitiveShape1",
1002                                                 0.5*fgkSSDSensorLength,
1003                                                 0.5*fgkSSDSensorInsensitiveWidth,
1004                                                 0.5*fgkSSDSensorHeight);
1005   SSDSensorInsensitiveShape[1] = new TGeoBBox("SSDSensorInSensitiveShape2",
1006                                                 0.5*fgkSSDSensorInsensitiveWidth,
1007                                                 0.5*fgkSSDSensorSensitiveWidth,
1008                                                 0.5*fgkSSDSensorHeight);
1009   const char* SSDSensorInsensitiveName[2] = {"SSDSensorInsensitive1",
1010                                              "SSDSensorInsensitive2"};
1011   TGeoVolume* SSDSensorInsensitive[2];
1012   for(Int_t i=0; i<2; i++){ SSDSensorInsensitive[i] =
1013       new TGeoVolume(SSDSensorInsensitiveName[i],SSDSensorInsensitiveShape[i],
1014                      fgkSSDSensorMedium);
1015       SSDSensorInsensitive[i]->SetLineColor(fColorCarbonFiber);
1016   }
1017   TGeoVolume* SSDSensorInsensitiveVol =
1018                               new TGeoVolumeAssembly("SSDSensorInsensitiveVol");
1019   for(Int_t i=0; i<4; i++)
1020             SSDSensorInsensitiveVol->AddNode(i%2==0 ? SSDSensorInsensitive[0]:
1021             SSDSensorInsensitive[1],i<2?1:2,
1022                   new TGeoTranslation(0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1023       *     (SSDSensorSensitiveShape->GetDX()+SSDSensorInsensitiveShape[1]->GetDX()),
1024                         0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1025       *     (SSDSensorSensitiveShape->GetDY()+SSDSensorInsensitiveShape[0]->GetDY()),0.));
1026   TGeoVolume* SSDSensor = new TGeoVolumeAssembly("SSDSensor");
1027   SSDSensor->AddNode(SSDSensorSensitive,1),SSDSensor->AddNode(SSDSensorInsensitiveVol,1);
1028   return SSDSensor;
1029 }
1030 /////////////////////////////////////////////////////////////////////////////////
1031 TGeoVolume* AliITSv11GeometrySSD::GetSSDChipAssembly(){
1032 ////////////////////////////////////////////////////////////////////////////////
1033   const Int_t SSDChipRowNumber = 2;
1034   TGeoBBox* SSDChipCompShape[2];
1035   SSDChipCompShape[0] =  new TGeoBBox("SSDChipCompShape",
1036                                                                                 0.5*fgkSSDChipLength,
1037                                                                                 0.5*fgkSSDChipWidth,
1038                                                                                 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
1039   SSDChipCompShape[1] =  new TGeoBBox("SSDChipGlueCompShape",
1040                                                                                 0.5*fgkSSDChipLength,
1041                                                                                 0.5*fgkSSDChipWidth,
1042                                                                                 0.5*fgkSSDChipGlueHeight);
1043   TGeoVolume* SSDChipComp[2];
1044   SSDChipComp[0] = new TGeoVolume("SSDChipComp",SSDChipCompShape[0],fgkSSDChipMedium);
1045   SSDChipComp[1] = new TGeoVolume("SSDChipGlueComp",SSDChipCompShape[1],
1046                                                                   fgkSSDChipGlueMedium);
1047   SSDChipComp[0]->SetLineColor(fColorSilicon);
1048   SSDChipComp[1]->SetLineColor(fColorEpoxy);
1049   TGeoTranslation* SSDChipCompTrans[2];
1050   SSDChipCompTrans[0] = new TGeoTranslation(0.,0.,-SSDChipCompShape[1]->GetDZ());
1051   SSDChipCompTrans[1] = new TGeoTranslation(0.,0.,SSDChipCompShape[0]->GetDZ());
1052   TGeoVolume* SSDChip = new TGeoVolumeAssembly("SSDChip");
1053   for(Int_t i=0; i<2; i++) SSDChip->AddNode(SSDChipComp[i],1,SSDChipCompTrans[i]);
1054   Double_t SSDChipSeparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength,
1055                                                   fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1056                                    -  2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
1057                                    -  0.5*fgkSSDChipWidth)};
1058   TGeoVolume* SSDChipAssembly = new TGeoVolumeAssembly("SSDChipAssembly");
1059   for(Int_t i=0; i<SSDChipRowNumber; i++)
1060     for(Int_t j=0; j<fgkSSDChipNumber; j++)
1061                 SSDChipAssembly->AddNode(SSDChip,fgkSSDChipNumber*i+j+1,
1062                 new TGeoTranslation(j*SSDChipSeparation[0],i*SSDChipSeparation[1],0.));
1063   return SSDChipAssembly;
1064 }
1065 /////////////////////////////////////////////////////////////////////////////////
1066 TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerAssembly(){
1067 ////////////////////////////////////////////////////////////////////////////////
1068   const Int_t SSDStiffenerNumber = 2;
1069   Double_t SSDStiffenerSeparation = fgkSSDSensorLength
1070                                                                   - 2.*fgkSSDModuleStiffenerPosition[1]
1071                                                                   -    fgkSSDStiffenerWidth;
1072   TGeoVolume* SSDStiffener = new TGeoVolumeAssembly("SSDStiffener");
1073 ////////////////////////////
1074 // Stiffener Volumes
1075 ///////////////////////////
1076   const Int_t StiffenerBoxNumber = 6;
1077   TGeoBBox* SSDStiffenerBoxShapes[StiffenerBoxNumber];
1078   SSDStiffenerBoxShapes[0] = new TGeoBBox("SSDStiffenerBoxShape1",
1079                                                                                   0.5* fgkSSDStiffenerLength,
1080                                                                                   0.5* fgkSSDStiffenerWidth,
1081                                                                                   0.5*(fgkSSDStiffenerHeight
1082                                                    -                   fgkSSDConnectorHeight));
1083   SSDStiffenerBoxShapes[1] = new TGeoBBox("SSDStiffenerBoxShape2",
1084                                                                                   0.5*(fgkSSDConnectorPosition[0]
1085                                                    -              2.0* fgkSSDConnectorLength
1086                                                    -                               fgkSSDConnectorSeparation),
1087                                                                                   0.5* fgkSSDStiffenerWidth,
1088                                                                                   0.5* fgkSSDConnectorHeight);
1089   SSDStiffenerBoxShapes[2] = new TGeoBBox("SSDStiffenerBoxShape3",
1090                                                                                   0.5*(fgkSSDConnectorSeparation
1091                                                    +              2.*  fgkSSDConnectorLength),
1092                                                                                   0.5* fgkSSDConnectorPosition[1],
1093                                                                                   0.5* fgkSSDConnectorHeight);
1094   SSDStiffenerBoxShapes[3] = new TGeoBBox("SSDStiffenerBoxShape4",
1095                                                                                         SSDStiffenerBoxShapes[2]->GetDX(),
1096                                                                                   0.5*(fgkSSDStiffenerWidth
1097                                                    -                   fgkSSDConnectorPosition[1]
1098                                                    -                   fgkSSDConnectorWidth),
1099                                                                                   0.5* fgkSSDConnectorHeight);
1100    SSDStiffenerBoxShapes[4] = new TGeoBBox("SSDStiffenerBoxShape5",
1101                                                                                   0.5* fgkSSDConnectorSeparation,
1102                                                                                   0.5* fgkSSDConnectorWidth,
1103                                                                                   0.5* fgkSSDConnectorHeight);
1104    SSDStiffenerBoxShapes[5] = new TGeoBBox("SSDStiffenerBoxShape6",
1105                                                                                   0.5*(fgkSSDStiffenerLength
1106                                                          -                                 fgkSSDConnectorPosition[0]),
1107                                                                                   0.5* fgkSSDStiffenerWidth,
1108                                                                                   0.5* fgkSSDConnectorHeight);
1109   TGeoVolume* SSDStiffenerBox[StiffenerBoxNumber];
1110   char SSDStiffenerBoxName[30];
1111   for(Int_t i=0; i<StiffenerBoxNumber; i++){
1112         sprintf(SSDStiffenerBoxName,"SSDStiffenerBox%i",i+1);
1113     SSDStiffenerBox[i] = new TGeoVolume(SSDStiffenerBoxName,SSDStiffenerBoxShapes[i],
1114                                                                           fgkSSDStiffenerMedium);
1115         SSDStiffenerBox[i]->SetLineColor(fColorStiffener);
1116   }
1117 ////////////////////////////
1118 // Connector
1119 ///////////////////////////
1120   TGeoBBox* SSDConnectorShape =  new TGeoBBox("SSDConnectorShape",
1121                                                                                          0.5*fgkSSDConnectorLength,
1122                                                                                          0.5*fgkSSDConnectorWidth,
1123                                                                                          0.5*fgkSSDConnectorHeight);
1124   TGeoVolume* SSDConnector    = new TGeoVolume("SSDConnector",SSDConnectorShape,
1125                                                                                                 fgkSSDStiffenerConnectorMedium);
1126   SSDConnector->SetLineColor(fColorAl);
1127   const Int_t SSDConnectorNumber = 2;
1128   TGeoTranslation* SSDConnectorTrans[SSDConnectorNumber];
1129   SSDConnectorTrans[0] = new TGeoTranslation("SSDConnectorTrans1",
1130         -  SSDStiffenerBoxShapes[0]->GetDX()+fgkSSDConnectorPosition[0]
1131                 -  fgkSSDConnectorSeparation-1.5*fgkSSDConnectorLength,
1132                    SSDStiffenerBoxShapes[0]->GetDY()-fgkSSDConnectorPosition[1]
1133                 -  SSDConnectorShape->GetDY(),
1134                    SSDStiffenerBoxShapes[0]->GetDZ()+SSDConnectorShape->GetDZ());
1135   SSDConnectorTrans[1] = new TGeoTranslation("SSDConnectorTrans2",
1136         -  SSDStiffenerBoxShapes[0]->GetDX()+fgkSSDConnectorPosition[0]
1137         -  0.5*fgkSSDConnectorLength,
1138            SSDStiffenerBoxShapes[0]->GetDY()-fgkSSDConnectorPosition[1]
1139                 -  SSDConnectorShape->GetDY(),
1140                    SSDStiffenerBoxShapes[0]->GetDZ()+SSDConnectorShape->GetDZ());
1141   for(Int_t i=0; i<SSDConnectorNumber; i++)
1142                         SSDStiffener->AddNode(SSDConnector,i+1,SSDConnectorTrans[i]);
1143 //////////////////////////////////////
1144 // TGeoTranslation for Stiffener Boxes
1145 //////////////////////////////////////
1146   TGeoTranslation* SSDStiffenerBoxTrans[StiffenerBoxNumber];
1147   SSDStiffenerBoxTrans[0] = new TGeoTranslation("SSDStiffenerBoxTrans1",0.,0.,0.);
1148   SSDStiffenerBoxTrans[1] = new TGeoTranslation("SSDStiffenerBoxTrans2",
1149                  - (SSDStiffenerBoxShapes[0]->GetDX()-SSDStiffenerBoxShapes[1]->GetDX()),
1150                     0.,
1151                         SSDStiffenerBoxShapes[0]->GetDZ()+SSDStiffenerBoxShapes[1]->GetDZ());
1152   SSDStiffenerBoxTrans[2] = new TGeoTranslation("SSDStiffenerBoxTrans3",
1153          - SSDStiffenerBoxShapes[0]->GetDX()-SSDStiffenerBoxShapes[2]->GetDX()
1154                  + fgkSSDConnectorPosition[0],
1155                    SSDStiffenerBoxShapes[0]->GetDY()-SSDStiffenerBoxShapes[2]->GetDY(),
1156                    SSDStiffenerBoxShapes[0]->GetDZ()+SSDStiffenerBoxShapes[2]->GetDZ());
1157   SSDStiffenerBoxTrans[3] = new TGeoTranslation("SSDStiffenerBoxTrans4",
1158          - SSDStiffenerBoxShapes[0]->GetDX()-SSDStiffenerBoxShapes[3]->GetDX()
1159                  + fgkSSDConnectorPosition[0],
1160                  - SSDStiffenerBoxShapes[0]->GetDY()+SSDStiffenerBoxShapes[3]->GetDY(),
1161                    SSDStiffenerBoxShapes[0]->GetDZ()+SSDStiffenerBoxShapes[3]->GetDZ());
1162   SSDStiffenerBoxTrans[4] = new TGeoTranslation("SSDStiffenerBoxTrans5",
1163                  - SSDStiffenerBoxShapes[0]->GetDX()+fgkSSDConnectorPosition[0]
1164                  - 0.5*fgkSSDConnectorSeparation-2.*SSDConnectorShape->GetDX(),
1165                    SSDStiffenerBoxShapes[0]->GetDY()-fgkSSDConnectorPosition[1]
1166                  - SSDConnectorShape->GetDY(),
1167                    SSDStiffenerBoxShapes[0]->GetDZ()+SSDConnectorShape->GetDZ());
1168   SSDStiffenerBoxTrans[5] = new TGeoTranslation("SSDStiffenerBoxTrans6",
1169          - SSDStiffenerBoxShapes[0]->GetDX()+fgkSSDConnectorPosition[0]
1170                  + SSDStiffenerBoxShapes[5]->GetDX(),
1171                    0.,
1172                    SSDStiffenerBoxShapes[0]->GetDZ()+SSDStiffenerBoxShapes[5]->GetDZ());
1173   for(Int_t i=0; i<StiffenerBoxNumber; i++)
1174                 SSDStiffener->AddNode(SSDStiffenerBox[i],1,SSDStiffenerBoxTrans[i]);
1175   TGeoCombiTrans* SSDStiffenerCombiTrans[SSDStiffenerNumber];
1176   char SSDStiffenerCombiTransName[30];
1177     for(Int_t i=0; i<SSDStiffenerNumber; i++){
1178         sprintf(SSDStiffenerCombiTransName,"SSDStiffenerCombiTrans%i",i+1);
1179     SSDStiffenerCombiTrans[i] = new TGeoCombiTrans(SSDStiffenerCombiTransName,
1180                         0.,i*SSDStiffenerSeparation,0.,new TGeoRotation("",180*(1-i),0.,0.));
1181   }
1182 ////////////////////////////
1183 // Capacitor 0603-2200 nF
1184 ///////////////////////////
1185   const Int_t Capacitor0603Number = 5;
1186   TGeoBBox* Capacitor0603Shape =  new TGeoBBox("Capacitor0603Shape",
1187                                                                                          0.5*fgkSSDCapacitor0603Length,
1188                                                                                          0.5*fgkSSDCapacitor0603Width,
1189                                                                                          0.5*fgkSSDCapacitor0603Height);
1190   TGeoVolume* Capacitor0603 = new TGeoVolume("Capacitor0603",Capacitor0603Shape,
1191                                              fgkSSDStiffener0603CapacitorMedium);
1192   Capacitor0603->SetLineColor(fColorAl);
1193 ////////////////////////////
1194 // Capacitor 1812-330 nF
1195 ///////////////////////////
1196   TGeoBBox* Capacitor1812Shape =  new TGeoBBox("Capacitor1812Shape",
1197                                                                                          0.5*fgkSSDCapacitor1812Length,
1198                                                                                          0.5*fgkSSDCapacitor1812Width,
1199                                                                                          0.5*fgkSSDCapacitor1812Height);
1200   TGeoVolume* Capacitor1812 = new TGeoVolume("Capacitor1812",Capacitor1812Shape,
1201                                              fgkSSDStiffener1812CapacitorMedium);
1202   Capacitor1812->SetLineColor(fColorAl);
1203   TGeoTranslation* Capacitor1812Trans = new TGeoTranslation("Capacitor1812Trans",
1204                           0.,
1205                           0.5*fgkSSDStiffenerWidth+SSDStiffenerSeparation
1206                -  Capacitor1812Shape->GetDY()-fgkSSDConnectorPosition[1],
1207                           SSDStiffenerBoxShapes[0]->GetDZ()+fgkSSDConnectorHeight
1208                    +  0.5*fgkSSDCapacitor1812Height);
1209 ////////////////////////////
1210 //Hybrid Wire
1211 ////////////////////////////
1212   Double_t WireX = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
1213                                  - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
1214                                  - fgkSSDConnectorSeparation;
1215   Double_t WireY = SSDStiffenerSeparation+fgkSSDStiffenerWidth
1216                                  - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
1217   Double_t SSDWireRadius = TMath::Sqrt(TMath::Power(WireX,2.)
1218                                          + TMath::Power(WireY,2));
1219   Double_t WireAngle = TMath::ATan(WireX/WireY);
1220   TGeoTube *HybridWireShape = new TGeoTube("HybridWireShape", 0.,
1221                                                 fgkSSDWireRadius, 0.5*SSDWireRadius);
1222   TGeoVolume* HybridWire = new TGeoVolume("HybridWire",HybridWireShape,
1223                                              fgkSSDStiffenerHybridWireMedium);
1224   HybridWire->SetLineColor(fColorPhynox);
1225   TGeoCombiTrans* HybridWireCombiTrans[2];
1226   HybridWireCombiTrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
1227                    0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
1228                                  + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
1229                    0.5*SSDWireRadius-0.5*fgkSSDStiffenerWidth
1230                                  + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
1231                                    SSDStiffenerBoxShapes[0]->GetDZ()+fgkSSDConnectorHeight
1232                                  + fgkSSDWireRadius,
1233                    new TGeoRotation("HybridWireRot1",0.,90.,0.));
1234   HybridWireCombiTrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
1235                                    0.,
1236                                  - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
1237                                    0.,
1238                    new TGeoRotation("HybridWireRot2",
1239                                  -                  WireAngle*TMath::RadToDeg(),0.,0.));
1240   TGeoHMatrix* HybridWireMatrix = new TGeoHMatrix();
1241   HybridWireMatrix->MultiplyLeft(HybridWireCombiTrans[0]);
1242   HybridWireMatrix->MultiplyLeft(HybridWireCombiTrans[1]);
1243 ////////////////////////////
1244 // Stiffener Assembly
1245 ///////////////////////////
1246   TGeoVolume* SSDStiffenerAssembly =
1247                                                                 new TGeoVolumeAssembly("SSDStiffenerAssembly");
1248   SSDStiffenerAssembly->AddNode(HybridWire,1,HybridWireMatrix);
1249   for(Int_t i=0; i<SSDStiffenerNumber; i++) {
1250         SSDStiffenerAssembly->AddNode(SSDStiffener,i+1,SSDStiffenerCombiTrans[i]);
1251         for(Int_t j=1; j<Capacitor0603Number+1; j++){
1252     SSDStiffenerAssembly->AddNode(Capacitor0603,Capacitor0603Number*i+j,new TGeoTranslation("",(j-3.
1253         )/6*fgkSSDStiffenerLength,
1254                                         i*SSDStiffenerSeparation+
1255                                         0.5*((i==0? 1:-1)*fgkSSDStiffenerWidth
1256                                         +(i==0? -1:+1)*fgkSSDCapacitor0603Width),
1257                                         -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
1258         }
1259         if(i==1) SSDStiffenerAssembly->AddNode(Capacitor1812,1,Capacitor1812Trans);
1260 }
1261   return SSDStiffenerAssembly;
1262 }
1263 /////////////////////////////////////////////////////////////////////////////////
1264 TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth,
1265                                                                                                                                         char* side){
1266 ////////////////////////////////////////////////////////////////////////////////
1267   const Int_t SSDChipCablesLayNumber = 2;
1268   Int_t SSDChipCablesColor[2] = {fColorAl,fColorPolyhamide};
1269   Double_t SSDChipCablesRadius[2];
1270   SSDChipCablesRadius[0] = 0.25*(SSDChipCablesHeigth
1271                                                  -  fgkSSDChipCablesHeight[0]
1272                                                  -  fgkSSDChipCablesHeight[1]);
1273   SSDChipCablesRadius[1] = SSDChipCablesRadius[0]-fgkSSDChipCablesHeight[0];
1274   Double_t SSDChipCablesPieceLength = 0.5*(fgkSSDChipCablesWidth[0]
1275                                                                     - 2.*TMath::Pi()*SSDChipCablesRadius[0]
1276                                                                         - SSDChipCablesRadius[0]
1277                                                                         - fgkSSDChipCablesWidth[1]
1278                                                                         - fgkSSDChipCablesWidth[2]
1279                                                                         - (side=="Right" ? 0 :
1280                                                                           fgkSSDModuleStiffenerPosition[1]
1281                                                                         + TMath::Pi()*(0.5*fgkSSDSensorHeight
1282                                                                         + fgkSSDChipCablesHeight[0]
1283                                                                         + fgkSSDChipCablesHeight[1])));
1284   //////////////////////////
1285   //Box and Tube Seg Shapes
1286   //////////////////////////
1287   char* SSDChipCablesBoxShapeName[2*SSDChipCablesLayNumber] =
1288                                           {"SSDChipCablesBoxLay0Shape0","SSDChipCablesBoxLay0Shape1",
1289                                            "SSDChipCablesBoxLay1Shape0","SSDChipCablesBoxLay1Shape1"};
1290   char* SSDChipCablesTubeSegShapeName[2*SSDChipCablesLayNumber] =
1291                           {"SSDChipCablesTubeSegLay0Shape0","SSDChipCablesTubeSegLay0Shape1",
1292                            "SSDChipCablesTubeSegLay1Shape0","SSDChipCablesTubeSegLay1Shape1"};
1293   TGeoBBox** SSDChipCablesBoxShape[SSDChipCablesLayNumber];
1294   TGeoTubeSeg** SSDChipCablesTubeSegShape[SSDChipCablesLayNumber];
1295   for(Int_t i=0; i<SSDChipCablesLayNumber; i++){
1296     SSDChipCablesBoxShape[i]        = new TGeoBBox*[2];
1297     SSDChipCablesTubeSegShape[i]    = new TGeoTubeSeg*[2+(side=="Right" ? 0 : 1)];
1298     SSDChipCablesBoxShape[i][0]     = new TGeoBBox(SSDChipCablesBoxShapeName[2*i],
1299                                                                                                    0.5*SSDChipCablesPieceLength,
1300                                                                                                    0.5*fgkSSDChipCablesLength[1],
1301                                                                                                    0.5*fgkSSDChipCablesHeight[i]);
1302     SSDChipCablesBoxShape[i][1]     = new TGeoBBox(SSDChipCablesBoxShapeName[2*i+1],
1303                                                    0.5*(SSDChipCablesPieceLength+SSDChipCablesRadius[0]
1304                                          + (side=="Right" ? 0. : fgkSSDModuleStiffenerPosition[1])),
1305                                     0.5*fgkSSDChipCablesLength[1],0.5*fgkSSDChipCablesHeight[i]);
1306     SSDChipCablesTubeSegShape[i][0] =
1307                                            new TGeoTubeSeg(SSDChipCablesTubeSegShapeName[2*i],
1308                                                    SSDChipCablesRadius[1]-i*fgkSSDChipCablesHeight[1],
1309                                                    SSDChipCablesRadius[i],0.5*fgkSSDChipCablesLength[1],
1310                                                    0.,180.);
1311     SSDChipCablesTubeSegShape[i][1] =
1312                                            new TGeoTubeSeg(SSDChipCablesTubeSegShapeName[2*i+1],
1313                                                  SSDChipCablesRadius[0]+i*fgkSSDChipCablesHeight[0],
1314                                                          SSDChipCablesRadius[0]+fgkSSDChipCablesHeight[0]
1315                                          +               i*fgkSSDChipCablesHeight[1],
1316                                                          0.5*fgkSSDChipCablesLength[1],0.,180.);
1317     if(side!="Right") SSDChipCablesTubeSegShape[i][2] =
1318                                          new TGeoTubeSeg(SSDChipCablesTubeSegShapeName[2*i],
1319                                                  0.5*fgkSSDSensorHeight+(1-i)*fgkSSDChipCablesHeight[1],
1320                                                  0.5*fgkSSDSensorHeight+(1-i)*fgkSSDChipCablesHeight[0]
1321                                          +   fgkSSDChipCablesHeight[1],
1322                                                  0.5*fgkSSDChipCablesLength[1],0.,180.);
1323   }
1324   //////////////////////////
1325   //Box under Chip
1326   //////////////////////////
1327   char SSDUnderChipCablesBoxShapeName[30];
1328   char SSDUnderChipCablesBoxName[30];
1329   char SSDUnderChipCablesBoxTransName[30];
1330   TGeoBBox* SSDUnderChipCablesBoxShape[SSDChipCablesLayNumber];
1331   TGeoVolume* SSDUnderChipCablesBox[SSDChipCablesLayNumber];
1332   TGeoTranslation* SSDUnderChipCablesBoxTrans[SSDChipCablesLayNumber];
1333   for(Int_t i=0; i<SSDChipCablesLayNumber; i++){
1334                 sprintf(SSDUnderChipCablesBoxShapeName,"SSDUnderChipCablesBoxShape%i",i+1);
1335                 sprintf(SSDUnderChipCablesBoxName,"SSDUnderChipCablesBox%i",i+1);
1336                 sprintf(SSDUnderChipCablesBoxTransName,"SSDUnderChipCablesBoxTrans%i",i+1);
1337                 SSDUnderChipCablesBoxShape[i] =
1338                                                                    new TGeoBBox(SSDUnderChipCablesBoxShapeName,
1339                                                                    0.5*fgkSSDChipWidth,
1340                                                                    0.5*fgkSSDChipCablesLength[1],
1341                                                                    0.5*fgkSSDChipCablesHeight[i]);
1342                 SSDUnderChipCablesBox[i] = new TGeoVolume(SSDUnderChipCablesBoxName,
1343                                                                         SSDUnderChipCablesBoxShape[i],
1344                                                                         (i==0?fgkSSDAlTraceChipCableMedium:fgkSSDKaptonChipCableMedium));
1345         SSDUnderChipCablesBox[i]->SetLineColor(SSDChipCablesColor[i]);
1346                 SSDUnderChipCablesBoxTrans[i] =
1347                                                 new TGeoTranslation(SSDUnderChipCablesBoxTransName,
1348                                                 (side=="Right"?-1.:1.)*0.5*fgkSSDChipWidth,
1349                                                 0.5*(fgkSSDChipCablesLength[0]-fgkSSDChipCablesLength[1])
1350                                                 +0.5*fgkSSDChipCablesLength[1],
1351                                                 (i==0?1.:-1.)*0.5*fgkSSDChipCablesHeight[1-i]);
1352   }
1353   //////////////////
1354   //Trapezoid Shapes
1355   //////////////////
1356   const Int_t SSDChipCablesVertexNumber = 2;
1357   const Int_t SSDChipCablesTrapezoidNumber = 2;
1358   TVector3** SSDChipCablesTrapezoidVertex[SSDChipCablesVertexNumber];
1359   for(Int_t i = 0; i< SSDChipCablesTrapezoidNumber; i++)
1360          SSDChipCablesTrapezoidVertex[i] = new TVector3*[SSDChipCablesVertexNumber];
1361   //First Shape Vertex Positioning
1362   SSDChipCablesTrapezoidVertex[0][0] = new TVector3();
1363   SSDChipCablesTrapezoidVertex[0][1] =
1364                 new TVector3(0.5*(fgkSSDChipCablesLength[0]-fgkSSDChipCablesLength[1]));
1365   //Second Shape Vertex Positioning
1366   SSDChipCablesTrapezoidVertex[1][0] =
1367                                                           new TVector3(*SSDChipCablesTrapezoidVertex[0][0]);
1368   SSDChipCablesTrapezoidVertex[1][1] =
1369                                                           new TVector3(*SSDChipCablesTrapezoidVertex[0][1]);
1370   //Setting the names of shapes and volumes
1371   char* SSDChipCablesTrapezoidBoxShapeName[SSDChipCablesTrapezoidNumber] =
1372                   {"SSDChipCablesTrapezoidBoxShape1","SSDChipCablesTrapezoidBoxShape2"};
1373   char* SSDChipCablesTrapezoidShapeName[SSDChipCablesTrapezoidNumber] =
1374                   {"SSDChipCablesTrapezoidShape1","SSDChipCablesTrapezoidShape2"};
1375   char* SSDChipCablesTrapezoidBoxName[SSDChipCablesTrapezoidNumber] =
1376                   {"SSDChipCablesTrapezoidBox1","SSDChipCablesTrapezoidBox2"};
1377   char* SSDChipCablesTrapezoidName[SSDChipCablesTrapezoidNumber] =
1378                   {"SSDChipCablesTrapezoid1","SSDChipCablesTrapezoid2"};
1379   char* SSDChipCablesTrapezoidAssemblyName[SSDChipCablesTrapezoidNumber] =
1380                   {"SSDChipCablesTrapezoidAssembly1","SSDChipCablesTrapezoidAssembly2"};
1381   //Setting the Shapes
1382   TGeoBBox* SSDChipCablesTrapezoidBoxShape[SSDChipCablesTrapezoidNumber];
1383   TGeoArb8* SSDChipCablesTrapezoidShape[SSDChipCablesTrapezoidNumber];
1384   //Setting the Volumes
1385   TGeoVolume* SSDChipCablesTrapezoidBox[SSDChipCablesTrapezoidNumber];
1386   TGeoVolume* SSDChipCablesTrapezoid[SSDChipCablesTrapezoidNumber];
1387   TGeoVolume* SSDChipCablesTrapezoidAssembly[SSDChipCablesTrapezoidNumber];
1388   Double_t SSDChipCablesTrapezoidWidth[SSDChipCablesVertexNumber] =
1389    {fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2],fgkSSDChipCablesWidth[1]};
1390   for(Int_t i=0; i<SSDChipCablesTrapezoidNumber; i++){
1391     SSDChipCablesTrapezoidBoxShape[i] =
1392                                         new TGeoBBox(SSDChipCablesTrapezoidBoxShapeName[i],
1393                                                 0.5*fgkSSDChipCablesLength[1],
1394                                             0.5*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]),
1395                                                 0.5*fgkSSDChipCablesHeight[i]);
1396     SSDChipCablesTrapezoidShape[i] =
1397                                                           GetTrapezoidShape(SSDChipCablesTrapezoidVertex[i],
1398                                                           SSDChipCablesTrapezoidWidth,
1399                                                           fgkSSDChipCablesHeight[i],
1400                                                           SSDChipCablesTrapezoidShapeName[i]);
1401     SSDChipCablesTrapezoidBox[i] =
1402                                                 new TGeoVolume(SSDChipCablesTrapezoidBoxName[i],
1403                                                                            SSDChipCablesTrapezoidBoxShape[i],
1404                                                                            (i==0?fgkSSDAlTraceChipCableMedium:fgkSSDKaptonChipCableMedium));
1405     SSDChipCablesTrapezoid[i] = new TGeoVolume(SSDChipCablesTrapezoidName[i],
1406                                                                                            SSDChipCablesTrapezoidShape[i],
1407                                                                                            (i==0?fgkSSDAlTraceChipCableMedium:fgkSSDKaptonChipCableMedium));
1408     SSDChipCablesTrapezoidBox[i]->SetLineColor(SSDChipCablesColor[i]);
1409     SSDChipCablesTrapezoid[i]->SetLineColor(SSDChipCablesColor[i]);
1410     SSDChipCablesTrapezoidAssembly[i] =
1411                                 new TGeoVolumeAssembly(SSDChipCablesTrapezoidAssemblyName[i]);
1412     SSDChipCablesTrapezoidAssembly[i]->AddNode(SSDChipCablesTrapezoidBox[i],1,
1413                                 new TGeoTranslation(0.5*fgkSSDChipCablesLength[1],
1414                                    0.5*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]),0.));
1415     SSDChipCablesTrapezoidAssembly[i]->AddNode(SSDChipCablesTrapezoid[i],0,
1416                         new TGeoCombiTrans(0.,0.,0.,new TGeoRotation("",90.,180.,-90.)));
1417     SSDChipCablesTrapezoidAssembly[i]->AddNode(SSDChipCablesTrapezoid[i],1,
1418                         new TGeoTranslation(fgkSSDChipCablesLength[1],0.,0.));
1419   }
1420   /////////////////////////////
1421   //Box and Tube Seg CombiTrans
1422   /////////////////////////////
1423   TGeoTranslation* SSDChipCablesBoxTrans[2*SSDChipCablesLayNumber];
1424   SSDChipCablesBoxTrans[0] =
1425                                         new TGeoTranslation("SSDChipCablesLay1Box1Trans",0.,0.,0.);
1426   SSDChipCablesBoxTrans[1] =
1427                                         new TGeoTranslation("SSDChipCablesLay1Box2Trans",
1428                                                                                  SSDChipCablesBoxShape[0][1]->GetDX()
1429                                                    -             0.5*SSDChipCablesPieceLength,
1430                        0.0,
1431                                                    -             2.*SSDChipCablesRadius[0]
1432                                                    -             fgkSSDChipCablesHeight[0]);
1433   SSDChipCablesBoxTrans[2] = new TGeoTranslation("SSDChipCablesLay2Box1Trans",
1434                                                                                  0.0,
1435                                                                                  0.0,
1436                                                                                  0.5*(fgkSSDChipCablesHeight[0]
1437                                                    +                     fgkSSDChipCablesHeight[1]));
1438   SSDChipCablesBoxTrans[3] =
1439                                                          new TGeoTranslation("SSDChipCablesLay2Box2Trans",
1440                                                                                  SSDChipCablesBoxShape[1][1]->GetDX()
1441                                                    -                     0.5*SSDChipCablesPieceLength,
1442                                                                                  0.0,
1443                                                    -                     2.*SSDChipCablesRadius[0]
1444                                                    -                     0.5*fgkSSDChipCablesHeight[1]
1445                                                    -                     1.5*fgkSSDChipCablesHeight[0]);
1446   TGeoRotation* SSDChipCablesRot[3];
1447   SSDChipCablesRot[0] = new TGeoRotation("SSDChipCablesRot1",0.,90.,0.);
1448   SSDChipCablesRot[1] = new TGeoRotation("SSDChipCablesRot2",90.,90.,-90.);
1449   SSDChipCablesRot[2] = new TGeoRotation("SSDChipCablesRot3",90.,-90.,-90.);
1450   TGeoCombiTrans* SSDChipCablesTubeSegCombiTrans[2*(SSDChipCablesLayNumber+
1451                                                                                                           (side=="Right" ? 0 : 1))];
1452   SSDChipCablesTubeSegCombiTrans[0] =
1453                                 new TGeoCombiTrans("SSDChipCablesLay1TubeSeg1CombiTrans",
1454                                 0.5*SSDChipCablesPieceLength,
1455                                 0.0,
1456                                 SSDChipCablesRadius[0]
1457                         -   0.5*fgkSSDChipCablesHeight[0],
1458                                 new TGeoRotation((*SSDChipCablesRot[1])*(*SSDChipCablesRot[0])));
1459   SSDChipCablesTubeSegCombiTrans[1] =
1460                                 new TGeoCombiTrans("SSDChipCablesLay1TubeSeg2CombiTrans",
1461                         -   0.5*SSDChipCablesPieceLength,
1462                                 0.0,
1463                         -   SSDChipCablesRadius[0]-0.5*fgkSSDChipCablesHeight[0],
1464                                 new TGeoRotation((*SSDChipCablesRot[2])*(*SSDChipCablesRot[0])));
1465   SSDChipCablesTubeSegCombiTrans[2] =
1466   new TGeoCombiTrans("SSDChipCablesLay2TubeSeg1CombiTrans",
1467                                 0.5*SSDChipCablesPieceLength,
1468                                 0.0,
1469                                 SSDChipCablesRadius[0]-0.5*fgkSSDChipCablesHeight[0],
1470                                 new TGeoRotation((*SSDChipCablesRot[1])*(*SSDChipCablesRot[0])));
1471   SSDChipCablesTubeSegCombiTrans[3] =
1472                                 new TGeoCombiTrans("SSDChipCablesLay2TubeSeg2CombiTrans",
1473                         -       0.5*SSDChipCablesPieceLength,
1474                                 0.0,
1475                         -       SSDChipCablesRadius[0]+0.5*fgkSSDChipCablesHeight[0]
1476                         -   fgkSSDChipCablesHeight[0],
1477                                 new TGeoRotation((*SSDChipCablesRot[2])*(*SSDChipCablesRot[0])));
1478   SSDChipCablesTubeSegCombiTrans[4] =
1479                                 new TGeoCombiTrans("SSDChipCablesLay1TubeSeg4CombiTrans",
1480                                 0.5*SSDChipCablesPieceLength+SSDChipCablesRadius[0]
1481                         +   fgkSSDModuleStiffenerPosition[1],
1482                                 0.0,
1483                         -       2.*SSDChipCablesRadius[0]-0.5*fgkSSDChipCablesHeight[0]
1484                         -   (0.5*fgkSSDSensorHeight+fgkSSDChipCablesHeight[0]
1485                         +       fgkSSDChipCablesHeight[1]),
1486                         new TGeoRotation((*SSDChipCablesRot[1])*(*SSDChipCablesRot[0])));
1487   SSDChipCablesTubeSegCombiTrans[5] =
1488                         new TGeoCombiTrans("SSDChipCablesLay2TubeSeg5CombiTrans",
1489                                 0.5*SSDChipCablesPieceLength+SSDChipCablesRadius[0]
1490                         +       fgkSSDModuleStiffenerPosition[1],
1491                                 0.0,
1492                         -       2.*SSDChipCablesRadius[0]-0.5*fgkSSDChipCablesHeight[0]
1493                         -       (0.5*fgkSSDSensorHeight+fgkSSDChipCablesHeight[0]
1494                         +       fgkSSDChipCablesHeight[1]),
1495                         new TGeoRotation((*SSDChipCablesRot[1])*(*SSDChipCablesRot[0])));
1496   TGeoCombiTrans* SSDChipCablesTrapezoidCombiTrans[SSDChipCablesLayNumber];
1497   SSDChipCablesTrapezoidCombiTrans[0] = (side=="Right" ?
1498                         new TGeoCombiTrans("SSDChipCableLay1TrapezoidRightCombiTrans",
1499                                 0.5*SSDChipCablesPieceLength+SSDChipCablesTrapezoidWidth[0]
1500                         +       SSDChipCablesRadius[0],
1501                         -       0.5*fgkSSDChipCablesLength[1],
1502                         -       fgkSSDChipCablesHeight[0]-2.*SSDChipCablesRadius[0],
1503                         new TGeoRotation("",90.,0.,0.)) :
1504                         new TGeoCombiTrans("SSDChipCableLay1TrapezoidLeftCombiTrans",
1505                         -       2.*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2])
1506                         +       0.5*SSDChipCablesPieceLength+SSDChipCablesTrapezoidWidth[0]
1507                         +       SSDChipCablesRadius[0]+fgkSSDModuleStiffenerPosition[1],
1508                                 0.5*fgkSSDChipCablesLength[1],
1509                         -       2.*(fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1])
1510                         -       2.*SSDChipCablesRadius[0]-fgkSSDSensorHeight,
1511                         new TGeoRotation("",-90.,0.,0.)));
1512   SSDChipCablesTrapezoidCombiTrans[1] = (side=="Right" ?
1513                         new TGeoCombiTrans("SSDChipCableLay2TrapezoidRightCombiTrans",
1514                                 0.5*SSDChipCablesPieceLength+SSDChipCablesTrapezoidWidth[0]
1515                         +       SSDChipCablesRadius[0],
1516                         -       0.5*fgkSSDChipCablesLength[1],
1517                         -       0.5*(fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1])
1518                         -       fgkSSDChipCablesHeight[0]-2.*SSDChipCablesRadius[0],
1519                                 new TGeoRotation("",90.,0.,0.)) :
1520                                 new TGeoCombiTrans("SSDChipCableLay2TrapezoidLeftCombiTrans",
1521                         -       2.*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2])
1522                         +       0.5*SSDChipCablesPieceLength+SSDChipCablesTrapezoidWidth[0]
1523                         +       SSDChipCablesRadius[0]+fgkSSDModuleStiffenerPosition[1],
1524                                 0.5*fgkSSDChipCablesLength[1],-0.5*(fgkSSDChipCablesHeight[0]
1525                         +       fgkSSDChipCablesHeight[1])-fgkSSDChipCablesHeight[1]
1526                         -       fgkSSDChipCablesHeight[0]-2.*SSDChipCablesRadius[0]
1527                         -       fgkSSDSensorHeight,new TGeoRotation("",-90.,0.,0.)));
1528   //////////////////////////
1529   //Box and Tube Seg Volumes
1530   //////////////////////////
1531   char* SSDChipCablesBoxName[2*SSDChipCablesLayNumber] =
1532                                                          {"SSDChipCablesLay1Box1","SSDChipCablesLay1Box2",
1533                                                           "SSDChipCablesLay2Box1","SSDChipCablesLay2Box2"};
1534   char* SSDChipRightCablesTubeSegName[2*SSDChipCablesLayNumber] =
1535                           {"SSDChipRightCablesLay1TubeSeg1","SSDChipRightCablesLay1TubeSeg2",
1536                            "SSDChipRightCablesLay2TubeSeg1","SSDChipRightCablesLay2TubeSeg2"};
1537   char* SSDChipLeftCablesTubeSegName[2*SSDChipCablesLayNumber] =
1538                           {"SSDChipLeftCablesLay1TubeSeg1","SSDChipLeftCablesLay1TubeSeg2",
1539                            "SSDChipLeftCablesLay2TubeSeg1","SSDChipLeftCablesLay2TubeSeg2"};
1540   char* SSDChipCablesLayAssemblyName[SSDChipCablesLayNumber] =
1541                           {"SSDChipCablesLay1","SSDChipCablesLay2"};
1542   TGeoVolume** SSDChipCablesBox[SSDChipCablesLayNumber];
1543   TGeoVolume** SSDChipCablesTubeSeg[SSDChipCablesLayNumber];
1544   TGeoVolume* SSDChipCablesLayAssembly[SSDChipCablesLayNumber];
1545   for(Int_t i=0; i<SSDChipCablesLayNumber; i++){
1546     TGeoMedium* SSDChipCablesLayMed =
1547             (i==0?fgkSSDAlTraceChipCableMedium:fgkSSDKaptonChipCableMedium);
1548     SSDChipCablesBox[i] = new TGeoVolume*[2];
1549     SSDChipCablesTubeSeg[i] = new TGeoVolume*[2+(side=="Right" ? 0 : 1)];
1550     SSDChipCablesBox[i][0] = new TGeoVolume(SSDChipCablesBoxName[2*i],
1551                                            SSDChipCablesBoxShape[i][0],SSDChipCablesLayMed);
1552     SSDChipCablesBox[i][1] = new TGeoVolume(SSDChipCablesBoxName[2*i+1],
1553                                            SSDChipCablesBoxShape[i][1],SSDChipCablesLayMed);
1554     SSDChipCablesTubeSeg[i][0] = new TGeoVolume(SSDChipRightCablesTubeSegName[2*i],
1555                                            SSDChipCablesTubeSegShape[i][0],SSDChipCablesLayMed);
1556     SSDChipCablesTubeSeg[i][1] = new TGeoVolume(SSDChipRightCablesTubeSegName[2*i+1],
1557                                            SSDChipCablesTubeSegShape[i][1],SSDChipCablesLayMed);
1558     SSDChipCablesBox[i][0]->SetLineColor(SSDChipCablesColor[i]);
1559     SSDChipCablesBox[i][1]->SetLineColor(SSDChipCablesColor[i]);
1560     SSDChipCablesTubeSeg[i][0]->SetLineColor(SSDChipCablesColor[i]);
1561     SSDChipCablesTubeSeg[i][1]->SetLineColor(SSDChipCablesColor[i]);
1562     SSDChipCablesLayAssembly[i] = new TGeoVolumeAssembly(SSDChipCablesLayAssemblyName[i]);
1563     SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesBox[i][0],1,
1564                                                                                  SSDChipCablesBoxTrans[2*i]);
1565     SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesBox[i][1],1,
1566                                                                                  SSDChipCablesBoxTrans[2*i+1]);
1567     SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesTubeSeg[i][0],1,
1568                                                                                  SSDChipCablesTubeSegCombiTrans[2*i]);
1569     SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesTubeSeg[i][1],1,
1570                                                                                  SSDChipCablesTubeSegCombiTrans[2*i+1]);
1571     if(side!="Right"){
1572       SSDChipCablesTubeSeg[i][2] = new TGeoVolume(SSDChipLeftCablesTubeSegName[2*i],
1573                                                                                                   SSDChipCablesTubeSegShape[i][2],
1574                                                                                                   SSDChipCablesLayMed);
1575       SSDChipCablesTubeSeg[i][2]->SetLineColor(SSDChipCablesColor[i]);
1576       SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesTubeSeg[i][2],1,
1577                                                                                    SSDChipCablesTubeSegCombiTrans[4+i]);
1578     }
1579     SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesTrapezoidAssembly[i],1,
1580                                                                                  SSDChipCablesTrapezoidCombiTrans[i]);
1581   }
1582   TGeoCombiTrans* SSDChipCablesCombiTrans[SSDChipCablesLayNumber];
1583   SSDChipCablesCombiTrans[0] = new TGeoCombiTrans("SSDChipCablesCombiTrans1",
1584                                            (side=="Right" ? -1 : 1)*0.5*SSDChipCablesPieceLength,
1585                                                 0.5*fgkSSDChipCablesLength[0],
1586                                         -       (2.*SSDChipCablesRadius[0]-fgkSSDChipCablesHeight[0]
1587                                         -       0.5*fgkSSDChipCablesHeight[1]),
1588                                                 new TGeoRotation("",(side=="Right" ? 0 : 1)*180.,0.,0.));
1589   SSDChipCablesCombiTrans[1] = new TGeoCombiTrans("SSDChipCablesCombiTrans2",
1590                                                 (side=="Right" ? -1 : 1)*0.5*SSDChipCablesPieceLength,
1591                                                 0.5*fgkSSDChipCablesLength[0],
1592                                         -       (2.*SSDChipCablesRadius[0]-fgkSSDChipCablesHeight[0]
1593                                         -       0.5*fgkSSDChipCablesHeight[1]),
1594                                                 new TGeoRotation("",(side=="Right" ? 0 : 1)*180.,0.,0.));
1595   TGeoVolume* SSDChipCablesAssembly =
1596                                                 new TGeoVolumeAssembly("SSDChipCables");
1597   for(Int_t i=0; i<SSDChipCablesLayNumber; i++){
1598                 SSDChipCablesAssembly->AddNode(SSDChipCablesLayAssembly[i],1,
1599                                                                                                         SSDChipCablesCombiTrans[i]);
1600                 SSDChipCablesAssembly->AddNode(SSDUnderChipCablesBox[i],1,SSDUnderChipCablesBoxTrans[i]);
1601   }
1602   return SSDChipCablesAssembly;
1603 }
1604 /////////////////////////////////////////////////////////////////////////////////
1605 TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCablesAssembly(Double_t SSDChipCablesHeigth){
1606 ////////////////////////////////////////////////////////////////////////////////
1607   const Int_t ChipCablesNumber = 2;
1608   Double_t ChipCablesTransVector = fgkSSDSensorLength
1609                                                                  - 2.*fgkSSDModuleStiffenerPosition[1]
1610                                                                  - 2.*(fgkSSDStiffenerWidth
1611                                                                  - fgkSSDStiffenerToChipDist-fgkSSDChipWidth);
1612   char* SSDChipCablesName[ChipCablesNumber] = {"Right","Left"};
1613   TGeoVolume* SSDChipCables[ChipCablesNumber];
1614   TGeoVolume* SSDChipCablesAssembly =
1615                                          new TGeoVolumeAssembly("SSDChipCablesAssembly");
1616   for(Int_t i=0; i<ChipCablesNumber; i++) SSDChipCables[i] =
1617                                          GetSSDChipCables(SSDChipCablesHeigth,SSDChipCablesName[i]);
1618   for(Int_t i=0; i<ChipCablesNumber; i++)
1619     for(Int_t j=0; j<fgkSSDChipNumber; j++)
1620       SSDChipCablesAssembly->AddNode(SSDChipCables[i],fgkSSDChipNumber*i+j+1,
1621                         new TGeoTranslation(-(SSDChipCablesName[i]=="Left" ? 1. : 0.)
1622                 *       ChipCablesTransVector,(j-0.5)*fgkSSDChipCablesLength[0]
1623                 +       0.5*fgkSSDChipCablesLength[1],0.));
1624   return SSDChipCablesAssembly;
1625 }
1626 /////////////////////////////////////////////////////////////////////////////////
1627 TGeoVolume* AliITSv11GeometrySSD::GetSSDFlex(Double_t SSDFlexRadius, Double_t SSDFlexHeigth){
1628 ////////////////////////////////////////////////////////////////////////////////
1629   const Int_t SSDFlexVolumeNumber = 3;
1630   TGeoVolume* SSDFlexVolume[SSDFlexVolumeNumber];
1631   ////////////////////////
1632   // Setting Display Color
1633   ////////////////////////
1634   Int_t SSDFlexColor;
1635   SSDFlexColor = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fColorAl: fColorPolyhamide);
1636   TGeoMedium* SSDFlexMed = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fgkSSDAlTraceFlexMedium :
1637                             fgkSSDKaptonFlexMedium);
1638   ////////////////////////
1639   // SSDFlexTrapezoidShape
1640   ////////////////////////
1641   const Int_t SSDFlexVertexNumber = 2;
1642   Double_t SSDFlexWidth[SSDFlexVertexNumber] = {fgkSSDFlexWidth[1],
1643                                                                                                 fgkSSDFlexWidth[0]};
1644   TVector3* SSDFlexVertex[SSDFlexVertexNumber];
1645   SSDFlexVertex[0] = new TVector3();
1646   SSDFlexVertex[1] = new TVector3(fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
1647   TGeoArb8* SSDFlexTrapezoidShape = GetTrapezoidShape(SSDFlexVertex,
1648                                                                                                           SSDFlexWidth,SSDFlexHeigth,
1649                                                                                                           "SSDFlexTrapezoidShape");
1650   SSDFlexVolume[0] = new TGeoVolume("SSDFlexTrapezoid",SSDFlexTrapezoidShape,SSDFlexMed);
1651   SSDFlexVolume[0]->SetLineColor(SSDFlexColor);
1652   /////////////////////////
1653   //SSDFlexTubeSeg Assembly
1654   /////////////////////////
1655   const Int_t SSDFlexTubeSegNumber = 2;
1656   TGeoTubeSeg* SSDFlexTubeSegShape[SSDFlexTubeSegNumber];
1657   Double_t SSDFlexRadiusMax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1658                                                         /  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1659   SSDFlexTubeSegShape[0] = new TGeoTubeSeg("SSDFlexTubeSegShape1",
1660                                                    SSDFlexRadius,SSDFlexRadius+SSDFlexHeigth,
1661                                                    0.5*fgkSSDFlexWidth[0],0.,180.);
1662   SSDFlexTubeSegShape[1] = new TGeoTubeSeg("SSDFlexTubeSegShape2",
1663                                                    SSDFlexRadiusMax-SSDFlexRadius-SSDFlexHeigth,
1664                                                    SSDFlexRadiusMax-SSDFlexRadius,0.5*fgkSSDFlexWidth[0],
1665                                                    0.,2.*fgkSSDFlexAngle);
1666   TGeoRotation** SSDFlexTubSegRot[SSDFlexTubeSegNumber];
1667   for(Int_t i = 0; i<SSDFlexTubeSegNumber; i++)
1668                                                                           SSDFlexTubSegRot[i] = new TGeoRotation*[2];
1669   SSDFlexTubSegRot[0][0] = new TGeoRotation("SSDFlexTubeSeg1Rot1", 0., 90.,  0.);
1670   SSDFlexTubSegRot[0][1] = new TGeoRotation("SSDFlexTubeSeg1Rot2",90., 90.,-90.);
1671   SSDFlexTubSegRot[1][0] = new TGeoRotation("SSDFlexTubeSeg2Rot1", 0.,-90.,  0.);
1672   SSDFlexTubSegRot[1][1] = new TGeoRotation("SSDFlexTubeSeg2Rot2",90., 90.,-90.);
1673   TGeoCombiTrans* SSDFlexTubeSegCombiTrans[SSDFlexTubeSegNumber];
1674   SSDFlexTubeSegCombiTrans[0] = new TGeoCombiTrans("SSDFlexTubeSegCombiTrans1",
1675                                                                 fgkSSDFlexLength[0],0.5*fgkSSDFlexWidth[0],
1676                                                                 SSDFlexRadius+0.5*SSDFlexHeigth,
1677                                                                 new TGeoRotation((*SSDFlexTubSegRot[0][1])
1678                                                         *       (*SSDFlexTubSegRot[0][0])));
1679   SSDFlexTubeSegCombiTrans[1] = new TGeoCombiTrans("SSDFlexTubeSegCombiTrans2",
1680                                                                 fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1681                                                                 0.5*fgkSSDFlexWidth[0],
1682                                                                 SSDFlexRadiusMax+0.5*SSDFlexHeigth+SSDFlexRadius,
1683                                                                 new TGeoRotation((*SSDFlexTubSegRot[1][1])
1684                                                         *       (*SSDFlexTubSegRot[1][0])));
1685   SSDFlexVolume[1] = new TGeoVolumeAssembly("SSDFlexTubeSegAssembly");
1686   TGeoVolume* SSDFlexTubeSeg[SSDFlexTubeSegNumber];
1687   char SSDFlexTubeSegName[30];
1688   for(Int_t i=0; i<SSDFlexTubeSegNumber; i++){
1689                 sprintf(SSDFlexTubeSegName,"SSDFlexTubeSeg%i",i+1);
1690                 SSDFlexTubeSeg[i] = new TGeoVolume(SSDFlexTubeSegName,SSDFlexTubeSegShape[i],
1691                                      SSDFlexMed);
1692                 SSDFlexTubeSeg[i]->SetLineColor(SSDFlexColor);
1693         SSDFlexVolume[1]->AddNode(SSDFlexTubeSeg[i],1,SSDFlexTubeSegCombiTrans[i]);
1694   }
1695   ///////////
1696   //Box Shape
1697   ///////////
1698   const Int_t SSDFlexBoxNumber = 7;
1699   Double_t SSDFlexBoxLength[SSDFlexBoxNumber];
1700   SSDFlexBoxLength[0] = 0.5*(fgkSSDChipNumber
1701                                           *     fgkSSDChipLength+(fgkSSDChipNumber-1)
1702                                           *     fgkSSDChipSeparationLength
1703                                           - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
1704                                           - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
1705   SSDFlexBoxLength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
1706   SSDFlexBoxLength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
1707                                           -     fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
1708   SSDFlexBoxLength[3] = fgkSSDFlexHoleWidth;
1709   SSDFlexBoxLength[4] = fgkSSDFlexLength[1]-SSDFlexBoxLength[0]
1710                                           -     SSDFlexBoxLength[1];
1711   SSDFlexBoxLength[5] = fgkSSDFlexLength[2];
1712   SSDFlexBoxLength[6] = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1713                                           *     TMath::DegToRad()*SSDFlexRadiusMax
1714                                           - fgkSSDFlexLength[2]-TMath::Pi()
1715                                           *     fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
1716   Double_t SSDFlexBoxWidth[SSDFlexBoxNumber];
1717   SSDFlexBoxWidth[0] = fgkSSDFlexWidth[0];
1718   SSDFlexBoxWidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
1719   SSDFlexBoxWidth[2] = fgkSSDFlexHoleWidth;
1720   SSDFlexBoxWidth[3] = SSDFlexBoxWidth[2]-fgkSSDFlexHoleLength;
1721   SSDFlexBoxWidth[4] = fgkSSDFlexWidth[0];
1722   SSDFlexBoxWidth[5] = fgkSSDFlexWidth[0];
1723   SSDFlexBoxWidth[6] = fgkSSDFlexWidth[0];
1724   TGeoBBox* SSDFlexBoxShape[SSDFlexBoxNumber+1];
1725   for(Int_t i=0; i<SSDFlexBoxNumber+1; i++) SSDFlexBoxShape[i] =
1726                                                 (i!= SSDFlexBoxNumber ? new TGeoBBox("SSDFlexBoxShape",
1727                                                                 0.5*SSDFlexBoxLength[i],
1728                                                                 0.5*SSDFlexBoxWidth[i],0.5*SSDFlexHeigth) :
1729                                                                 SSDFlexBoxShape[2]);
1730   //////////////////////////////
1731   //SSDFlex Box Shape CombiTrans
1732   //////////////////////////////
1733   TGeoCombiTrans* SSDFlexBoxCombiTrans[SSDFlexBoxNumber+1];
1734   SSDFlexBoxCombiTrans[0] = new TGeoCombiTrans("SSDFlexBoxCombiTrans0",
1735                                                                 SSDFlexVertex[1]->X()+0.5*SSDFlexBoxLength[0],
1736                                                                 0.5*fgkSSDFlexWidth[0],0.,0);
1737   SSDFlexBoxCombiTrans[1] = new TGeoCombiTrans("SSDFlexBoxCombiTrans1",
1738                                                                 SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
1739                                                         +       0.5*SSDFlexBoxLength[1],
1740                                                                 fgkSSDFlexHoleWidth+0.5*SSDFlexBoxWidth[1],0.,0);
1741   SSDFlexBoxCombiTrans[2] = new TGeoCombiTrans("SSDFlexBoxCombiTrans2",
1742                                                                 SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
1743                                                         +       fgkSSDFlexHoleLength+0.5*SSDFlexBoxLength[2],
1744                                                                 0.5*SSDFlexBoxWidth[2],0.,0);
1745   SSDFlexBoxCombiTrans[3] = new TGeoCombiTrans("SSDFlexBoxCombiTrans3",
1746                                                                 SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
1747                                                         +       fgkSSDFlexHoleLength+SSDFlexBoxLength[2]
1748                                                         +       0.5*fgkSSDFlexHoleWidth,
1749                                                                 fgkSSDFlexHoleLength+0.5*SSDFlexBoxWidth[3],0.,0);
1750   SSDFlexBoxCombiTrans[4] = new TGeoCombiTrans("SSDFlexBoxCombiTrans4",
1751                                                                 SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
1752                                                         +       SSDFlexBoxLength[1]+0.5*SSDFlexBoxLength[4],
1753                                                                 0.5*fgkSSDFlexWidth[0],0.,0);
1754   SSDFlexBoxCombiTrans[5] = new TGeoCombiTrans("SSDFlexBoxCombiTrans5",
1755                                                         -       0.5*fgkSSDFlexLength[2]+fgkSSDFlexLength[0],
1756                                                                 0.5*fgkSSDFlexWidth[0],
1757                                                                 2.*SSDFlexRadius+SSDFlexHeigth,0);
1758   SSDFlexBoxCombiTrans[6] = new TGeoCombiTrans("SSDFlexBoxCombiTrans6",
1759                                                         -       SSDFlexBoxShape[6]->GetDX()
1760                                                         +       SSDFlexBoxShape[6]->GetDX()
1761                                                         *       TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad())
1762                                                         +       fgkSSDFlexLength[0]-fgkSSDFlexLength[2]
1763                                                         -       (SSDFlexRadiusMax-SSDFlexRadius-0.5*SSDFlexHeigth)
1764                                                         *       TMath::Cos(fgkSSDFlexAngle*TMath::DegToRad()),
1765                                                                 0.5*fgkSSDFlexWidth[0],SSDFlexBoxShape[6]->GetDX()
1766                                                                 *TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad())
1767                                                         +       SSDFlexHeigth+2.*SSDFlexRadius+(SSDFlexRadiusMax
1768                                                         -       SSDFlexRadius-0.5*SSDFlexHeigth)
1769                                                         *       TMath::Sin(fgkSSDFlexAngle*TMath::DegToRad()),
1770                                                                 new TGeoRotation("",90.,2.*fgkSSDFlexAngle,-90.));
1771   SSDFlexBoxCombiTrans[7] = new TGeoCombiTrans("SSDFlexBoxCombiTrans7",
1772                                                                 SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
1773                                                         +       fgkSSDFlexHoleLength+1.5*SSDFlexBoxLength[2]
1774                                                         +       SSDFlexBoxLength[3],
1775                                                                 0.5*SSDFlexBoxWidth[2],0.,0);
1776   ////////////////////////////
1777   //SSDFlex Box Shape Assembly
1778   ////////////////////////////
1779   SSDFlexVolume[2] = new TGeoVolumeAssembly("SSDFlexBoxAssembly");
1780   TGeoVolume* SSDFlexBox[SSDFlexBoxNumber+1];
1781   TGeoVolume* SSDEndFlex = GetSSDEndFlex(SSDFlexBoxLength[6],SSDFlexHeigth);
1782   TGeoHMatrix* SSDEndFlexHMatrix = new TGeoHMatrix();
1783   TGeoRotation* SSDEndFlexRot= new TGeoRotation("SSDEndFlexRot",180.,0.,0);
1784   SSDEndFlexHMatrix->MultiplyLeft(SSDEndFlexRot);
1785   SSDEndFlexHMatrix->MultiplyLeft(SSDFlexBoxCombiTrans[6]);
1786   char SSDFlexBoxName[30];
1787   for(Int_t i=0; i<SSDFlexBoxNumber+1; i++){
1788         sprintf(SSDFlexBoxName,"SSDFlexBox%i",i!=SSDFlexBoxNumber?i+1:7);
1789         if(i==6){SSDFlexVolume[2]->AddNode(SSDEndFlex,1,SSDEndFlexHMatrix);}
1790         else{
1791     SSDFlexBox[i] = new TGeoVolume(SSDFlexBoxName,SSDFlexBoxShape[i],
1792                                    SSDFlexMed);
1793         SSDFlexBox[i]->SetLineColor(SSDFlexColor);
1794         SSDFlexVolume[2]->AddNode(SSDFlexBox[i],1,SSDFlexBoxCombiTrans[i]);}
1795  }
1796   //////////////////////
1797   //SSDFlex Construction
1798   //////////////////////
1799   TGeoVolume* SSDFlex = new TGeoVolumeAssembly("SSDFlex");
1800   for(Int_t i =0; i<SSDFlexVolumeNumber; i++) SSDFlex->AddNode(SSDFlexVolume[i],1);
1801   return SSDFlex;
1802 }
1803 /////////////////////////////////////////////////////////////////////////////////
1804 TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(Double_t SSDEndFlexLength,
1805                                                                                                                 Double_t SSDFlexHeigth){
1806   /////////////////////////////////////////
1807   // Setting Display Color, Media and Index
1808   /////////////////////////////////////////
1809   Int_t SSDFlexColor;
1810   SSDFlexColor = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fColorAl: fColorPolyhamide);
1811   TGeoMedium* SSDFlexMed = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fgkSSDAlTraceFlexMedium :
1812                             fgkSSDKaptonFlexMedium);
1813   ////////////////////////
1814   const Int_t SSDEndFlexBoxNumber = 5;
1815   TGeoBBox* SSDEndFlexBBoxShape[SSDEndFlexBoxNumber];
1816   SSDEndFlexBBoxShape[0] = new TGeoBBox("SSDFlexBoxShape1",
1817                                                                    0.5*SSDEndFlexLength,0.5*fgkSSDFlexWidth[0],
1818                                                                    0.5*SSDFlexHeigth);
1819   SSDEndFlexBBoxShape[1] = new TGeoBBox("SSDFlexBoxShape2",
1820                                     0.5*fgkSSDEndFlexCompLength[1],
1821                                         0.5*(fgkSSDEndFlexCompWidth[0]-fgkSSDFlexWidth[0])/2,
1822                                         0.5*SSDFlexHeigth);
1823   SSDEndFlexBBoxShape[2] = new TGeoBBox("SSDFlexBoxShape3",
1824                                     0.5*fgkSSDEndFlexCompLength[2],
1825                                         0.5*(fgkSSDEndFlexCompWidth[1]-fgkSSDFlexWidth[0])/2,
1826                                         0.5*SSDFlexHeigth);
1827   SSDEndFlexBBoxShape[3] = new TGeoBBox("SSDFlexBoxShape4",
1828                                     0.5*fgkSSDEndFlexCompLength[3],
1829                                         0.5*(fgkSSDEndFlexCompWidth[0]-fgkSSDFlexWidth[0])/2,
1830                                         0.5*SSDFlexHeigth);
1831   SSDEndFlexBBoxShape[4] = new TGeoBBox("SSDFlexBoxShape5",
1832                                     0.5*(fgkSSDEndFlexCompLength[4]+fgkSSDEndFlexCompLength[5]),
1833                                         0.25*(fgkSSDEndFlexCompWidth[2]-fgkSSDFlexWidth[0])/2,
1834                                         0.5*SSDFlexHeigth);
1835   TGeoVolume* SSDEndFlexBBox[SSDEndFlexBoxNumber];
1836   char SSDEndFlexBBoxName[30];
1837   for(Int_t i=0; i<SSDEndFlexBoxNumber; i++){
1838         sprintf(SSDEndFlexBBoxName,"SSDEndFlexBBox%i",i+1);
1839         SSDEndFlexBBox[i] = new TGeoVolume(SSDEndFlexBBoxName,
1840                      SSDEndFlexBBoxShape[i],
1841                      SSDFlexMed);
1842         SSDEndFlexBBox[i]->SetLineColor(SSDFlexColor);
1843   }
1844   TGeoVolume* SSDEndFlex = new TGeoVolumeAssembly("SSDEndFlex");
1845   Double_t PartialSumLength = 0.;
1846   for(Int_t i=0; i<SSDEndFlexBoxNumber+1; i++) PartialSumLength += fgkSSDEndFlexCompLength[i];
1847   Double_t ReferenceLength = SSDEndFlexLength-PartialSumLength;
1848   SSDEndFlex->AddNode(SSDEndFlexBBox[0],1);
1849   SSDEndFlex->AddNode(SSDEndFlexBBox[1],1,new TGeoTranslation(
1850                                         -  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
1851                                         +  0.5*fgkSSDEndFlexCompLength[1],
1852                                            0.5*fgkSSDFlexWidth[0]+SSDEndFlexBBoxShape[1]->GetDY(),
1853                                            0.));
1854   SSDEndFlex->AddNode(SSDEndFlexBBox[1],2,new TGeoTranslation(
1855                                         -  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
1856                                         +  0.5*fgkSSDEndFlexCompLength[1],
1857                                         -  0.5*fgkSSDFlexWidth[0]-SSDEndFlexBBoxShape[1]->GetDY(),
1858                                            0.));
1859   SSDEndFlex->AddNode(SSDEndFlexBBox[2],1,new TGeoTranslation(
1860                                         -  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
1861                                         +  fgkSSDEndFlexCompLength[1]+0.5*fgkSSDEndFlexCompLength[2],
1862                                         +  0.5*fgkSSDFlexWidth[0]+SSDEndFlexBBoxShape[2]->GetDY(),
1863                                            0.));
1864   SSDEndFlex->AddNode(SSDEndFlexBBox[2],2,new TGeoTranslation(
1865                                         -  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
1866                                         +  fgkSSDEndFlexCompLength[1]+0.5*fgkSSDEndFlexCompLength[2],
1867                                         -  0.5*fgkSSDFlexWidth[0]-SSDEndFlexBBoxShape[2]->GetDY(),
1868                                            0.));
1869   SSDEndFlex->AddNode(SSDEndFlexBBox[3],1,new TGeoTranslation(
1870                                         -  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
1871                                         +  fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
1872                                         +  0.5*fgkSSDEndFlexCompLength[3],
1873                                         +  0.5*fgkSSDFlexWidth[0]+SSDEndFlexBBoxShape[3]->GetDY(),
1874                                            0.));
1875   SSDEndFlex->AddNode(SSDEndFlexBBox[3],2,new TGeoTranslation(
1876                                         -  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
1877                                         +  fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
1878                                         +  0.5*fgkSSDEndFlexCompLength[3],
1879                                         -  0.5*fgkSSDFlexWidth[0]-SSDEndFlexBBoxShape[3]->GetDY(),
1880                                            0.));
1881   SSDEndFlex->AddNode(SSDEndFlexBBox[4],1,new TGeoTranslation(
1882                                         -  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
1883                                         +  fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
1884                                         +  fgkSSDEndFlexCompLength[3]+0.5*(fgkSSDEndFlexCompLength[4]+fgkSSDEndFlexCompLength[5]),
1885                                         +  0.5*fgkSSDFlexWidth[0]+SSDEndFlexBBoxShape[4]->GetDY(),
1886                                            0.));
1887   SSDEndFlex->AddNode(SSDEndFlexBBox[4],2,new TGeoTranslation(
1888                                         -  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
1889                                         +  fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
1890                                         +  fgkSSDEndFlexCompLength[3]+0.5*(fgkSSDEndFlexCompLength[4]
1891                                         +  fgkSSDEndFlexCompLength[5]),
1892                                         -  0.5*fgkSSDFlexWidth[0]-SSDEndFlexBBoxShape[4]->GetDY(),
1893                                            0.));
1894   return SSDEndFlex;
1895 }
1896 /////////////////////////////////////////////////////////////////////////////////
1897 TGeoVolume* AliITSv11GeometrySSD::GetSSDFlexAssembly(){
1898 ////////////////////////////////////////////////////////////////////////////////
1899   TGeoVolume* SSDFlexAssembly = new TGeoVolumeAssembly("SSDFlexAssembly");
1900   const Int_t SSDFlexLayerNumber = 4;
1901   Double_t SSDFlexHeight[SSDFlexLayerNumber];
1902   Double_t SSDFlexRadius[SSDFlexLayerNumber];
1903   TGeoTranslation* SSDFlexTrans[SSDFlexLayerNumber];
1904   for(Int_t i=0; i<SSDFlexLayerNumber; i++){
1905     SSDFlexHeight[i] = (i%2==0 ? fgkSSDFlexHeight[0] : fgkSSDFlexHeight[1]);
1906     SSDFlexRadius[i] = (i==0 ? fgkSSDStiffenerHeight : SSDFlexRadius[i-1]
1907                                          +                                         SSDFlexHeight[i-1]);
1908     SSDFlexTrans[i]  = new TGeoTranslation(0.,0.,-0.5*i*(SSDFlexHeight[0]
1909                                          +                                         SSDFlexHeight[1]));
1910     SSDFlexAssembly->AddNode(GetSSDFlex(SSDFlexRadius[i],SSDFlexHeight[i]),i+1,
1911                                                                                    SSDFlexTrans[i]);
1912   }
1913   return SSDFlexAssembly;
1914 }
1915 /////////////////////////////////////////////////////////////////////////////////
1916 TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlockAssembly(){
1917 ////////////////////////////////////////////////////////////////////////////////
1918   const Int_t SSDCoolingBlockTransNumber = 2;
1919   Double_t SSDCoolingBlockTransVector[SSDCoolingBlockTransNumber] =
1920                                         {fgkSSDModuleSensorSupportDistance+fgkSSDCoolingBlockLength,
1921                                          fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1922                                 -        fgkSSDCoolingBlockWidth};
1923   TGeoVolume* SSDCoolingBlock = GetSSDCoolingBlock();
1924   TGeoVolume* SSDCoolingBlockAssembly =
1925                                                           new TGeoVolumeAssembly("SSDCoolingBlockAssembly");
1926   for(Int_t i=0; i<SSDCoolingBlockTransNumber; i++)
1927     for(Int_t j=0; j<SSDCoolingBlockTransNumber; j++)
1928                 SSDCoolingBlockAssembly->AddNode(SSDCoolingBlock,
1929                                                   SSDCoolingBlockTransNumber*i+j+1,
1930                                                   new TGeoTranslation(i*SSDCoolingBlockTransVector[0],
1931                                                   j*SSDCoolingBlockTransVector[1],0.));
1932   return SSDCoolingBlockAssembly;
1933 }
1934 /////////////////////////////////////////////////////////////////////////////////
1935 TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(){
1936 /////////////////////////////////////////////////////////////////////////////////
1937   // Center Cooling Block Hole
1938   ////////////////////////////
1939   Double_t CoolingBlockHoleAngle = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
1940                                                         /fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
1941   Double_t CoolingBlockHoleWidth = fgkSSDCoolingBlockWidth;
1942   /*TGeoTubeSeg* CoolingBlockHoleShape = */ new TGeoTubeSeg("CoolingBlockHoleShape",
1943                                                 0.,
1944                                                 fgkSSDCoolingBlockHoleRadius[0],
1945                                                 0.5*CoolingBlockHoleWidth,
1946                                                 180.-CoolingBlockHoleAngle,360.+CoolingBlockHoleAngle);
1947   TVector3* CoolingBlockHoleVertex[3];
1948   CoolingBlockHoleVertex[0] = new TVector3();
1949   CoolingBlockHoleVertex[1] = new TVector3(fgkSSDCoolingBlockHoleRadius[0]
1950                                         *       TMath::Cos((90.-CoolingBlockHoleAngle)*TMath::DegToRad()),
1951                                                 fgkSSDCoolingBlockHoleRadius[0]
1952                                         *       TMath::Sin((90.-CoolingBlockHoleAngle)*TMath::DegToRad()));
1953   CoolingBlockHoleVertex[2] = new TVector3(CoolingBlockHoleVertex[1]->X(),
1954                                         -       CoolingBlockHoleVertex[1]->Y());
1955   /* TGeoArb8* CoolingBlockTriangleHoleShape = */
1956                                                 GetTriangleShape(CoolingBlockHoleVertex,
1957                                                 CoolingBlockHoleWidth,"CoolingBlockTriangleHoleShape");
1958   TGeoRotation* CoolingBlockHoleRot =
1959                                                           new TGeoRotation("CoolingBlockHoleRot",90,0.,0.);
1960   CoolingBlockHoleRot->RegisterYourself();
1961   /* TGeoCompositeShape* CoolingTubeHoleShape  = */
1962                               new TGeoCompositeShape("CoolingTubeHoleShape",
1963                                                           "CoolingBlockTriangleHoleShape:CoolingBlockHoleRot+"
1964                                                           "CoolingBlockHoleShape");
1965   ///////////////////////////
1966   // Cooling Block Trapezoids
1967   ///////////////////////////
1968   const Int_t VertexNumber = 4;
1969   const Int_t TrapezoidNumber = 2;
1970   TVector3** CoolingBlockTrapezoidVertex[TrapezoidNumber];
1971   for(Int_t i = 0; i<TrapezoidNumber; i++) CoolingBlockTrapezoidVertex[i] =
1972                                                 new TVector3*[VertexNumber];
1973   Double_t CoolingBlockComponentHeight    = fgkSSDCoolingBlockHeight[0]
1974                                     -   fgkSSDCoolingBlockHoleCenter
1975                                         -       fgkSSDCoolingBlockHoleRadius[0]
1976                                         *       TMath::Sin(CoolingBlockHoleAngle*TMath::DegToRad());
1977   Double_t CoolingBlockTrapezoidLength[TrapezoidNumber] =
1978                                         {       fgkSSDCoolingBlockLength,
1979                                                 0.5*(fgkSSDCoolingBlockLength-2.
1980                                         *       (fgkSSDCoolingBlockHoleLength[1]
1981                                         -       fgkSSDCoolingBlockHoleRadius[1])
1982                                         -       fgkSSDCoolingBlockHoleLength[0])};
1983   Double_t CoolingBlockTrapezoidHeigth[TrapezoidNumber] =
1984                                         {       fgkSSDCoolingBlockHeight[0]-CoolingBlockComponentHeight
1985                                         -       fgkSSDCoolingBlockHeight[1]-fgkSSDCoolingBlockHeight[2]
1986                                         -       fgkSSDCoolingBlockHoleRadius[1],
1987                                                 CoolingBlockComponentHeight};
1988   Double_t CoolingBlockTrapezoidWidth[TrapezoidNumber]  =
1989                                                 {fgkSSDCoolingBlockWidth,fgkSSDCoolingBlockWidth};
1990   //////////////////////////
1991   //Vertex Positioning Shape
1992   //////////////////////////
1993   CoolingBlockTrapezoidVertex[0][0] = new TVector3();
1994   CoolingBlockTrapezoidVertex[0][1] = new TVector3(CoolingBlockTrapezoidLength[0]);
1995   CoolingBlockTrapezoidVertex[0][2] = new TVector3(
1996                                                 0.5*(CoolingBlockTrapezoidVertex[0][1]->X()
1997                                         -       2.*CoolingBlockTrapezoidLength[1]
1998                                         -       fgkSSDCoolingBlockHoleLength[0]));
1999   CoolingBlockTrapezoidVertex[0][3] =
2000                                                 new TVector3(CoolingBlockTrapezoidVertex[0][1]->X()
2001                                         -       CoolingBlockTrapezoidVertex[0][2]->X());
2002   CoolingBlockTrapezoidVertex[1][0] = new TVector3();
2003   CoolingBlockTrapezoidVertex[1][1] = new TVector3(CoolingBlockTrapezoidLength[1]);
2004   CoolingBlockTrapezoidVertex[1][2] =
2005                                                 new TVector3(CoolingBlockTrapezoidHeigth[1]
2006                                         /                                CoolingBlockTrapezoidHeigth[0]
2007                                         *       CoolingBlockTrapezoidVertex[0][2]->X());
2008   CoolingBlockTrapezoidVertex[1][3] =
2009                                                 new TVector3(CoolingBlockTrapezoidVertex[1][1]->X());
2010   char* CoolingBlockTrapezoidShapeName[TrapezoidNumber] =
2011                                         {"CoolingBlockTrapezoidShape0","CoolingBlockTrapezoidShape1"};
2012   TGeoArb8* CoolingBlockTrapezoidShape[TrapezoidNumber];
2013   for(Int_t i = 0; i< TrapezoidNumber; i++) CoolingBlockTrapezoidShape[i] =
2014                                                 GetArbShape(CoolingBlockTrapezoidVertex[i],
2015                                                 CoolingBlockTrapezoidWidth,
2016                                                 CoolingBlockTrapezoidHeigth[i],
2017                                                 CoolingBlockTrapezoidShapeName[i]);
2018   TGeoTranslation* CoolingBlockTrapezoidTrans =
2019                                                 new TGeoTranslation("CoolingBlockTrapezoidTrans",
2020                                                 CoolingBlockTrapezoidVertex[0][2]->X(),
2021                                                 0.0,
2022                                                 0.5*(CoolingBlockTrapezoidHeigth[0]
2023                                         +       CoolingBlockTrapezoidHeigth[1]));
2024   CoolingBlockTrapezoidTrans->RegisterYourself();
2025   TGeoCombiTrans* CoolingBlockTrapezoidCombiTrans =
2026                                                 new TGeoCombiTrans("CoolingBlockTrapezoidCombiTrans",
2027                                                 CoolingBlockTrapezoidVertex[0][3]->X(),
2028                                                 fgkSSDCoolingBlockWidth,
2029                                                 0.5*(CoolingBlockTrapezoidHeigth[0]
2030                                         +       CoolingBlockTrapezoidHeigth[1]),
2031                                                 new TGeoRotation("",180.,0.,0.));
2032   CoolingBlockTrapezoidCombiTrans->RegisterYourself();
2033   /* TGeoCompositeShape* CoolingBlockTrapezoidCompositeShape = */
2034         new TGeoCompositeShape("CoolingBlockTrapezoidCompositeShape",
2035         "CoolingBlockTrapezoidShape0+CoolingBlockTrapezoidShape1:CoolingBlockTrapezoidTrans+"
2036         "CoolingBlockTrapezoidShape1:CoolingBlockTrapezoidCombiTrans");
2037   /////////////////////////////
2038   // Cooling Block Boxes Shapes
2039   /////////////////////////////
2040   const Int_t BoxNumber = 3;
2041   TGeoBBox* CoolingBlockBoxShape[BoxNumber];
2042   CoolingBlockBoxShape[0] = new TGeoBBox("CoolingBlockBoxShape0",
2043                                                 0.5*fgkSSDCoolingBlockLength,
2044                                                 0.5*fgkSSDCoolingBlockWidth,
2045                                                 0.5*fgkSSDCoolingBlockHoleRadius[1]);
2046   CoolingBlockBoxShape[1] = new TGeoBBox("CoolingBlockBoxShape1",
2047                                                 0.5*(fgkSSDCoolingBlockLength
2048                                         -       2.*fgkSSDCoolingBlockHoleLength[1]),
2049                                                 0.5*fgkSSDCoolingBlockWidth,
2050                                                 0.5*fgkSSDCoolingBlockHeight[2]);
2051   CoolingBlockBoxShape[2] = new TGeoBBox("CoolingBlockBoxShape2",
2052                                                 0.5*fgkSSDCoolingBlockLength,
2053                                                 0.5*fgkSSDCoolingBlockWidth,
2054                                                 0.5*fgkSSDCoolingBlockHeight[1]);
2055   TGeoTranslation* CoolingBlockBoxTrans[BoxNumber-1];
2056   CoolingBlockBoxTrans[0] = new TGeoTranslation("CoolingBlockBoxTrans0",0.,0.,
2057                                                 0.5*(fgkSSDCoolingBlockHeight[1]
2058                                         +       fgkSSDCoolingBlockHoleRadius[1])
2059                                         +       fgkSSDCoolingBlockHeight[2]);
2060   CoolingBlockBoxTrans[1] = new TGeoTranslation("CoolingBlockBoxTrans1",
2061                                                 0.0,
2062                                                 0.0,
2063                                                 0.5*(fgkSSDCoolingBlockHeight[1]
2064                                         +       fgkSSDCoolingBlockHeight[2]));
2065   for(Int_t i=0; i<BoxNumber-1; i++) CoolingBlockBoxTrans[i]->RegisterYourself();
2066   /* TGeoCompositeShape* CoolingBlockBoxCompositeShape = */
2067         new TGeoCompositeShape("CoolingBlockBoxCompositeShape",
2068                                                    "CoolingBlockBoxShape0:CoolingBlockBoxTrans0+"
2069          "CoolingBlockBoxShape1:CoolingBlockBoxTrans1+CoolingBlockBoxShape2");
2070   ///////////////////////
2071   // Cooling Block Shape
2072   //////////////////////
2073   TGeoCombiTrans* CoolingTubeHoleShapeCombiTrans =
2074                                                 new TGeoCombiTrans("CoolingTubeHoleShapeCombiTrans",
2075                                                 0.5*fgkSSDCoolingBlockLength,
2076                                                 0.5*fgkSSDCoolingBlockWidth,
2077                                                 fgkSSDCoolingBlockHoleCenter,
2078                                                 new TGeoRotation("",0.,90.,0.));
2079   CoolingTubeHoleShapeCombiTrans->RegisterYourself();
2080   TGeoTranslation* CoolingBlockTrapezoidCompositeShapeTrans =
2081                                                 new TGeoTranslation("CoolingBlockTrapezoidCompositeShapeTrans",
2082                                                 0.0,
2083                                                 0.0,
2084                                                 0.5*CoolingBlockTrapezoidHeigth[0]+fgkSSDCoolingBlockHeight[1]+
2085                                                 fgkSSDCoolingBlockHeight[2]+fgkSSDCoolingBlockHoleRadius[1]);
2086   CoolingBlockTrapezoidCompositeShapeTrans->RegisterYourself();
2087   TGeoTranslation* CoolingBlockBoxCompositeShapeTrans =
2088                                                 new TGeoTranslation("CoolingBlockBoxCompositeShapeTrans",
2089                                                 0.5*fgkSSDCoolingBlockLength,
2090                                                 0.5*fgkSSDCoolingBlockWidth,
2091                                                 0.5*fgkSSDCoolingBlockHeight[1]);
2092   CoolingBlockBoxCompositeShapeTrans->RegisterYourself();
2093   TGeoCompositeShape* SSDCoolingBlockShape =
2094                 new TGeoCompositeShape("SSDCoolingBlockShape",
2095                 "CoolingBlockBoxCompositeShape:CoolingBlockBoxCompositeShapeTrans+"
2096                 "CoolingBlockTrapezoidCompositeShape:CoolingBlockTrapezoidCompositeShapeTrans-"
2097                 "CoolingTubeHoleShape:CoolingTubeHoleShapeCombiTrans");
2098   TGeoVolume* SSDCoolingBlock = new TGeoVolume("SSDCoolingBlock",
2099                 SSDCoolingBlockShape,fgkSSDAlCoolBlockMedium);
2100   return SSDCoolingBlock;
2101 }
2102 /////////////////////////////////////////////////////////////////////////////////
2103 TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
2104 ////////////////////////////////////////////////////////////////////////////////
2105   const Int_t VertexNumber = 4;
2106   TVector3* Vertex[VertexNumber];
2107   Vertex[0] = new TVector3();
2108   Vertex[1] = new TVector3(fgkCarbonFiberJunctionLength,0.);
2109   Vertex[2] = new TVector3(fgkCarbonFiberJunctionLength
2110                 -         fgkCarbonFiberJunctionEdge[1]
2111                         *         TMath::Cos(fgkCarbonFiberJunctionAngle[1]*TMath::DegToRad()),
2112                                   fgkCarbonFiberJunctionEdge[1]*TMath::Sin(fgkCarbonFiberJunctionAngle[1]
2113                         *     TMath::DegToRad()));
2114   Vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
2115                         *         TMath::Cos(fgkCarbonFiberJunctionAngle[0]*TMath::DegToRad()),
2116                                   fgkCarbonFiberJunctionEdge[0]
2117                         *         TMath::Sin(fgkCarbonFiberJunctionAngle[0]*TMath::DegToRad()));
2118   TGeoArb8* CarbonFiberJunctionShapePiece =
2119                                                 new TGeoArb8("CarbonFiberJunctionShapePiece",0.5*width);
2120   //////////////////////////////////
2121   //Setting the vertices in TGeoArb8
2122   //////////////////////////////////
2123   for(Int_t i = 0; i<2*VertexNumber; i++)
2124         CarbonFiberJunctionShapePiece->SetVertex(i,
2125                                                         Vertex[(i < VertexNumber ? i: i-VertexNumber)]->X(),
2126                                                         Vertex[(i < VertexNumber ? i : i-VertexNumber)]->Y());
2127   TGeoRotation* CarbonFiberJunctionRot =
2128                                                 new TGeoRotation("CarbonFiberJunctionRot",
2129                                                                                   180.,
2130                                                                                   180.,
2131                                                                                   180-2.*fgkCarbonFiberJunctionAngle[0]);
2132   TGeoVolume* CarbonFiberJunctionPiece =
2133                                                 new TGeoVolume("CarbonFiberJunctionPiece",
2134                                                 CarbonFiberJunctionShapePiece,fgkSSDCarbonFiberMedium);
2135   TGeoVolume* CarbonFiberJunction =
2136                                                 new TGeoVolumeAssembly("CarbonFiberJunction");
2137   CarbonFiberJunctionPiece->SetLineColor(fColorCarbonFiber);
2138   CarbonFiberJunction->AddNode(CarbonFiberJunctionPiece,1);
2139   CarbonFiberJunction->AddNode(CarbonFiberJunctionPiece,2,CarbonFiberJunctionRot);
2140   return CarbonFiberJunction;
2141 }
2142 /////////////////////////////////////////////////////////////////////////////////
2143 TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunctionAssembly(){
2144 ////////////////////////////////////////////////////////////////////////////////
2145   SetCarbonFiberJunctionCombiTransMatrix();
2146   TGeoVolume* CarbonFiberJunctionAssembly =
2147                                                   new TGeoVolumeAssembly("CarbonFiberJunctionAssembly");
2148   TGeoVolume* CarbonFiberJunction =
2149                                                   GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth);
2150   for(Int_t i=0; i<fgkCarbonFiberJunctionCombiTransNumber;i++)
2151     CarbonFiberJunctionAssembly->AddNode(CarbonFiberJunction,i+1,
2152                                                                                  CarbonFiberJunctionCombiTransMatrix[i]);
2153   return CarbonFiberJunctionAssembly;
2154 }
2155 /////////////////////////////////////////////////////////////////////////////////
2156 TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t SSDEndLadderCableLength){
2157 /////////////////////////////////////////////////////////////////////////////////
2158 const Int_t LadderCableSegmentNumber = 2;
2159 /////////////////////////////////////////
2160 // LadderSegmentBBox Volume
2161 /////////////////////////////////////////
2162   TGeoBBox* LadderCableSegmentBBoxShape[LadderCableSegmentNumber];
2163   const char* LadderCableSegmentBBoxShapeName[LadderCableSegmentNumber] =
2164                                 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
2165   for(Int_t i=0; i<LadderCableSegmentNumber; i++) LadderCableSegmentBBoxShape[i] =
2166                                                   new TGeoBBox(LadderCableSegmentBBoxShapeName[i],
2167                                                                            0.5*fgkSSDFlexWidth[0],
2168                                                                            0.5*fgkSSDLadderCableWidth,
2169                                                                            0.5*fgkSSDFlexHeight[i]);
2170   const char* LadderCableSegmentBBoxName[LadderCableSegmentNumber] =
2171                                                   {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
2172   TGeoVolume* LadderCableSegmentBBox[LadderCableSegmentNumber];
2173   for(Int_t i=0; i<LadderCableSegmentNumber; i++){
2174                         LadderCableSegmentBBox[i] =
2175                                                   new TGeoVolume(LadderCableSegmentBBoxName[i],
2176                                                                                  LadderCableSegmentBBoxShape[i],
2177                                                                                  (i==0?fgkSSDAlTraceLadderCableMedium:
2178             fgkSSDKaptonLadderCableMedium));
2179                         LadderCableSegmentBBox[i]->SetLineColor(i==0 ? fColorAl :
2180                                                                                                                    fColorPolyhamide);
2181   }
2182   TGeoTranslation* LadderCableSegmentBBoxTrans[LadderCableSegmentNumber];
2183   LadderCableSegmentBBoxTrans[0] =
2184                                                    new TGeoTranslation("LadderCableSegmentBBoxTrans1",
2185                                                                                            0.5*fgkSSDFlexWidth[0],
2186                                                                                            0.5*fgkSSDLadderCableWidth,
2187                                                                                            0.5*fgkSSDFlexHeight[0]);
2188   LadderCableSegmentBBoxTrans[1] =
2189                                                    new TGeoTranslation("LadderCableSegmentBBoxTrans2",
2190                                                                                            0.5*fgkSSDFlexWidth[0],
2191                                                                                            0.5*fgkSSDLadderCableWidth,
2192                                                                                            fgkSSDFlexHeight[0]
2193                                                                                            +0.5*fgkSSDFlexHeight[1]);
2194   TGeoVolume* LadderCableSegmentBBoxAssembly =
2195                                                    new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly");
2196   for(Int_t i=0; i<LadderCableSegmentNumber; i++)
2197                 LadderCableSegmentBBoxAssembly->AddNode(LadderCableSegmentBBox[i],1,
2198                                                                                             LadderCableSegmentBBoxTrans[i]);
2199 /////////////////////////////////////////
2200 // LadderSegmentArb8 Volume
2201 /////////////////////////////////////////
2202   const Int_t VertexNumber = 4;
2203   TVector3** LadderCableSegmentVertexPosition[LadderCableSegmentNumber];
2204   for(Int_t i = 0; i<LadderCableSegmentNumber; i++) LadderCableSegmentVertexPosition[i] =
2205                                                                                                   new TVector3*[VertexNumber];
2206 //Shape Vertex Positioning
2207   for(Int_t i=0; i<LadderCableSegmentNumber; i++){
2208         LadderCableSegmentVertexPosition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
2209         LadderCableSegmentVertexPosition[i][1] = new TVector3(fgkSSDLadderCableWidth,
2210                                                                                                                   i*fgkSSDFlexHeight[0]);
2211         LadderCableSegmentVertexPosition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
2212                                                                                    +                         fgkSSDFlexHeight[1]
2213                                                                                    +                      i*fgkSSDFlexHeight[0]);
2214         LadderCableSegmentVertexPosition[i][3] =
2215                                                    new TVector3(LadderCableSegmentVertexPosition[i][1]->X(),
2216                                                                                 LadderCableSegmentVertexPosition[i][2]->Y());
2217   }
2218   Double_t LadderCableSegmentWidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
2219                                                                             {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
2220   char* LadderCableSegmentArbShapeName[LadderCableSegmentNumber] =
2221                                         {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
2222   TGeoArb8* LadderCableSegmentArbShape[LadderCableSegmentNumber];
2223   for(Int_t i = 0; i< LadderCableSegmentNumber; i++) LadderCableSegmentArbShape[i] =
2224                                         GetArbShape(LadderCableSegmentVertexPosition[i],
2225                                                                 LadderCableSegmentWidth[i],
2226                                                                 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
2227                                                                 LadderCableSegmentArbShapeName[i]);
2228   const char* LadderCableSegmentArbName[LadderCableSegmentNumber] =
2229                                                   {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
2230   TGeoVolume* LadderCableSegmentArb[LadderCableSegmentNumber];
2231   for(Int_t i=0; i<LadderCableSegmentNumber; i++){
2232                          LadderCableSegmentArb[i] =
2233                                                    new TGeoVolume(LadderCableSegmentArbName[i],
2234                                                                                   LadderCableSegmentArbShape[i],
2235                                                                                   (i==0?fgkSSDAlTraceLadderCableMedium:
2236             fgkSSDKaptonLadderCableMedium));
2237                          LadderCableSegmentArb[i]->SetLineColor(i==0 ? fColorAl :
2238                                                                                                                    fColorPolyhamide);
2239 }
2240   TGeoRotation* LadderCableSegmentArbRot[LadderCableSegmentNumber];
2241   LadderCableSegmentArbRot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
2242                                                                                                  90.,90,-90.);
2243   LadderCableSegmentArbRot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
2244                                                                                                   0.,90.,0.);
2245   TGeoCombiTrans* LadderCableSegmentArbCombiTrans =
2246                                                    new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
2247                                                            0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
2248                                                          + fgkSSDFlexWidth[0],0.,0.,
2249                                                    new TGeoRotation((*LadderCableSegmentArbRot[1])
2250                                                      *(*LadderCableSegmentArbRot[0])));
2251   TGeoVolume* LadderCableSegmentArbAssembly =
2252                                                    new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
2253   for(Int_t i=0; i<LadderCableSegmentNumber; i++)
2254   LadderCableSegmentArbAssembly->AddNode(LadderCableSegmentArb[i],1,
2255                                                                                    LadderCableSegmentArbCombiTrans);
2256 /////////////////////////////////////////
2257 // End Ladder Cable Volume
2258 /////////////////////////////////////////
2259   TGeoBBox* LadderEndCableSegmentBBoxShape[LadderCableSegmentNumber];
2260   const char* LadderEndCableSegmentBBoxShapeName[LadderCableSegmentNumber] =
2261                                 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
2262   for(Int_t i=0; i<LadderCableSegmentNumber; i++) LadderEndCableSegmentBBoxShape[i] =
2263                                                   new TGeoBBox(LadderEndCableSegmentBBoxShapeName[i],
2264                                                                            0.5*SSDEndLadderCableLength,
2265                                                                            0.5*fgkSSDLadderCableWidth,
2266                                                                            0.5*fgkSSDFlexHeight[i]);
2267   const char* LadderEndCableSegmentBBoxName[LadderCableSegmentNumber] =
2268                                                   {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
2269   TGeoVolume* LadderEndCableSegmentBBox[LadderCableSegmentNumber];
2270   for(Int_t i=0; i<LadderCableSegmentNumber; i++){
2271                         LadderEndCableSegmentBBox[i] =
2272                                                   new TGeoVolume(LadderEndCableSegmentBBoxName[i],
2273                                                                                  LadderEndCableSegmentBBoxShape[i],
2274                                                                                  (i==0?fgkSSDAlTraceLadderCableMedium:
2275             fgkSSDKaptonLadderCableMedium));
2276                         LadderEndCableSegmentBBox[i]->SetLineColor(i==0 ? fColorAl :
2277                                                                                                                    fColorPolyhamide);
2278   }
2279   TGeoTranslation* LadderEndCableSegmentBBoxTrans[LadderCableSegmentNumber];
2280   LadderEndCableSegmentBBoxTrans[0] =
2281                                                    new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
2282                                                                                            0.5*SSDEndLadderCableLength,
2283                                                                                            0.5*fgkSSDLadderCableWidth,
2284                                                                                            0.5*fgkSSDFlexHeight[0]);
2285   LadderEndCableSegmentBBoxTrans[1] =
2286                                                    new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
2287                                                                                            0.5*SSDEndLadderCableLength,
2288                                                                                            0.5*fgkSSDLadderCableWidth,
2289                                                                                            fgkSSDFlexHeight[0]
2290                                                                                            +0.5*fgkSSDFlexHeight[1]);
2291   TGeoVolume* LadderEndCableSegmentBBoxAssembly =
2292                                                    new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
2293   for(Int_t i=0; i<LadderCableSegmentNumber; i++)
2294                 LadderEndCableSegmentBBoxAssembly->AddNode(LadderEndCableSegmentBBox[i],1,
2295                                                                                             LadderEndCableSegmentBBoxTrans[i]);
2296 /////////////////////////////////////////
2297   TList* LadderCableSegmentList = new TList();
2298   LadderCableSegmentList->Add(LadderCableSegmentBBoxAssembly);
2299   LadderCableSegmentList->Add(LadderCableSegmentArbAssembly);
2300   LadderCableSegmentList->Add(LadderEndCableSegmentBBoxAssembly);
2301   return LadderCableSegmentList;
2302   }
2303 /////////////////////////////////////////////////////////////////////////////////
2304 TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t SSDEndLadderCableLength){
2305 /////////////////////////////////////////////////////////////////////////////////
2306   TList* LadderCableSegmentList = GetLadderCableSegment(SSDEndLadderCableLength);
2307   TGeoVolume* LadderCable = new TGeoVolumeAssembly("LadderCable");
2308   for(Int_t i=0; i<n; i++){
2309         TGeoTranslation* LadderCableTrans = new TGeoTranslation(
2310                                                         i*(fgkCarbonFiberJunctionWidth),
2311                                                         fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
2312                                                         i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
2313     LadderCable->AddNode((TGeoVolume*)LadderCableSegmentList->At(0),i+1,LadderCableTrans);
2314         if(i!=n-1) LadderCable->AddNode((TGeoVolume*)LadderCableSegmentList->At(1),i+1,LadderCableTrans);
2315   }
2316   TGeoTranslation* EndLadderCableTrans = new TGeoTranslation("EndLadderCableTrans",
2317                                           (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
2318                                                                  fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
2319                                           (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
2320   LadderCable->AddNode((TGeoVolume*)LadderCableSegmentList->At(2),1,EndLadderCableTrans);
2321   return LadderCable;
2322 }
2323 /////////////////////////////////////////////////////////////////////////////////
2324 TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t SSDEndLadderCableLength){
2325 /////////////////////////////////////////////////////////////////////////////////
2326   TGeoVolume* LadderCableAssembly = new TGeoVolumeAssembly("LadderCableAssembly");
2327   char LadderCableTransName[30];
2328   for(Int_t i=0; i<n; i++){
2329         sprintf(LadderCableTransName,"LadderCableTrans%i",i+1);
2330     LadderCableAssembly->AddNode(GetLadderCable(n-i,SSDEndLadderCableLength),i+1,
2331         new TGeoTranslation(LadderCableTransName,i*fgkCarbonFiberJunctionWidth,0.,0.));
2332   }
2333   return LadderCableAssembly;
2334 }
2335 /////////////////////////////////////////////////////////////////////////////////
2336 TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t SSDEndLadderCableLength){
2337 /////////////////////////////////////////////////////////////////////////////////
2338   const Int_t LadderCableAssemblyNumber = 2;
2339   TGeoVolume* LadderCableAssembly = GetLadderCableAssembly(n,SSDEndLadderCableLength);
2340   TGeoVolume* LadderCable[LadderCableAssemblyNumber];
2341   char LadderCableAssemblyName[30];
2342   TList* LadderCableAssemblyList = new TList();
2343   for(Int_t i=0; i<LadderCableAssemblyNumber; i++){
2344         sprintf(LadderCableAssemblyName,"LadderCableAssembly%i",i+1);
2345         LadderCable[i] = new TGeoVolumeAssembly(LadderCableAssemblyName);
2346         LadderCable[i]->AddNode(LadderCableAssembly,i+1,i==0 ? NULL :
2347                                          new TGeoCombiTrans((n-1)
2348                                          *       fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
2349                                              2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
2350                                                                                         0.,new TGeoRotation("",180,0.,0.)));
2351         LadderCableAssemblyList->Add(LadderCable[i]);
2352 }
2353   return LadderCableAssemblyList;
2354 }
2355 /////////////////////////////////////////////////////////////////////////////////
2356 TList* AliITSv11GeometrySSD::GetEndLadderCarbonFiberJunctionAssembly(){
2357 ////////////////////////////////////////////////////////////////////////////////
2358   const Int_t EndLabberCarbonFiberJunctionNumber = 2;
2359   TGeoVolume* EndLadderCarbonFiberJunctionAssembly[EndLabberCarbonFiberJunctionNumber];
2360   EndLadderCarbonFiberJunctionAssembly[0] =
2361                                 new TGeoVolumeAssembly("EndLadderCarbonFiberJunctionAssembly1");
2362   EndLadderCarbonFiberJunctionAssembly[1] =
2363                                 new TGeoVolumeAssembly("EndLadderCarbonFiberJunctionAssembly2");
2364   TGeoVolume** EndLadderCarbonFiberJunction[EndLabberCarbonFiberJunctionNumber];
2365   for(Int_t i=0; i<EndLabberCarbonFiberJunctionNumber; i++)
2366                                                    EndLadderCarbonFiberJunction[i] = new TGeoVolume*[2];
2367   for(Int_t i=0; i<EndLabberCarbonFiberJunctionNumber; i++){
2368     EndLadderCarbonFiberJunction[i][0] =
2369                   GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]);
2370     EndLadderCarbonFiberJunction[i][1] =
2371                   GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]);
2372   }
2373   TList* EndLadderCarbonFiberJunctionList = new TList();
2374   for(Int_t i=0; i<EndLabberCarbonFiberJunctionNumber; i++){
2375     SetEndLadderCarbonFiberJunctionCombiTransMatrix(i);
2376     for(Int_t j=0; j<fgkCarbonFiberJunctionCombiTransNumber; j++)
2377       EndLadderCarbonFiberJunctionAssembly[i]->AddNode(j==2 ?
2378                                                  EndLadderCarbonFiberJunction[i][1] :
2379                                                  EndLadderCarbonFiberJunction[i][0],
2380                                                  j+1,EndLadderCarbonFiberJunctionCombiTransMatrix[j]);
2381     EndLadderCarbonFiberJunctionList->Add(EndLadderCarbonFiberJunctionAssembly[i]);
2382   }
2383   return EndLadderCarbonFiberJunctionList;
2384 }
2385 ////////////////////////////////////////////////////////////////////////////////
2386 TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberSupport(){
2387 ////////////////////////////////////////////////////////////////////////////////
2388   const Int_t VertexNumber = 4;
2389   const Int_t ShapesNumber = 2;
2390   TVector3** VertexPosition[ShapesNumber];
2391   for(Int_t i=0; i<ShapesNumber; i++) VertexPosition[i] = new TVector3*[VertexNumber];
2392   Double_t CarbonFiberSupportXAxisEdgeProj =
2393                 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
2394         *       TMath::DegToRad());
2395   Double_t Theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
2396                                  /                         fgkCarbonFiberSupportXAxisLength);
2397   /////////////////////
2398   //Vertex Positioning
2399   ////////////////////
2400   VertexPosition[0][0] = new TVector3();
2401   VertexPosition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
2402                                                                           fgkCarbonFiberSupportYAxisLength);
2403   VertexPosition[0][2] = new TVector3(CarbonFiberSupportXAxisEdgeProj,
2404                                                                           CarbonFiberSupportXAxisEdgeProj
2405                                            *                      TMath::Tan(Theta));
2406   VertexPosition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
2407                                            -                      CarbonFiberSupportXAxisEdgeProj,
2408                                                                           fgkCarbonFiberSupportYAxisLength
2409                                            -                      VertexPosition[0][2]->Y());
2410   ////////////////////////////////////////////////////
2411   //Setting the parameters for Isometry Transformation
2412   ////////////////////////////////////////////////////
2413   Double_t SymmetryPlanePosition = (fgkCarbonFiberSupportYAxisLength
2414                                                                  +      fgkCarbonFiberSupportTopEdgeDist[0]
2415                                                                  +      fgkCarbonFiberSupportWidth);
2416   Double_t* param = new Double_t[4];
2417   param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -SymmetryPlanePosition;
2418   for(Int_t j=0; j<VertexNumber; j++) VertexPosition[1][j] =
2419                                   new TVector3((GetReflection(VertexPosition[0][j],param))->X(),
2420                                                           (GetReflection(VertexPosition[0][j],param))->Y());
2421   char* CarbonFiberSupportShapeName[ShapesNumber] =
2422                                                 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
2423   TGeoArb8* CarbonFiberSupportShape[ShapesNumber];
2424   Double_t Width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
2425   Double_t CarbonFiberSupportHeight =
2426           CarbonFiberSupportXAxisEdgeProj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
2427           *TMath::DegToRad());
2428   for(Int_t i = 0; i< ShapesNumber; i++) CarbonFiberSupportShape[i] =
2429                                         GetArbShape(VertexPosition[i],Width,CarbonFiberSupportHeight,
2430                                                                         CarbonFiberSupportShapeName[i],i==0 ? 1: -1);
2431   /////////////////////////////////////
2432   //Setting Translations and Rotations:
2433   /////////////////////////////////////
2434   TGeoTranslation* CarbonFiberSupportTrans =
2435                                                   new TGeoTranslation("CarbonFiberSupportTrans",
2436                                                                                           0.0,0.0,0.5*CarbonFiberSupportHeight);
2437   CarbonFiberSupportTrans->RegisterYourself();
2438   TGeoRotation* CarbonFiberCompShapeRot[2];
2439   CarbonFiberCompShapeRot[0] = new TGeoRotation("CarbonFiberCompShapeRot1",
2440                                                                                           0.0,180.0,0.0);
2441   CarbonFiberCompShapeRot[1] = new TGeoRotation("CarbonFiberCompShapeRot2",
2442                                                                                   90.,-fgkCarbonFiberTriangleAngle,-90.);
2443   Double_t TransVector[3] = {fgkCarbonFiberTriangleLength
2444                                                   *  TMath::Cos(fgkCarbonFiberTriangleAngle
2445                                                   *      TMath::DegToRad()),0.,-fgkCarbonFiberTriangleLength
2446                                                   *      TMath::Sin(fgkCarbonFiberTriangleAngle
2447                                                   *      TMath::DegToRad())};
2448   TGeoCombiTrans* CarbonFiberSupportCombiTrans =
2449                                                            new TGeoCombiTrans("CarbonFiberSupportCombiTrans",
2450                                                            TransVector[0],2.*SymmetryPlanePosition
2451                                                   +        TransVector[1],TransVector[2],
2452                                                            new TGeoRotation((*CarbonFiberCompShapeRot[1])
2453                                                   *        (*CarbonFiberCompShapeRot[0])));
2454   CarbonFiberSupportCombiTrans->RegisterYourself();
2455 ////////////////////////////////////////////////////////////////////////////////
2456   TGeoCompositeShape* CarbonFiberSupportCompShape =
2457                                                         new TGeoCompositeShape("CarbonFiberSupportCompShape",
2458                                                         "CarbonFiberSupportShape1:CarbonFiberSupportTrans+"
2459                                                         "CarbonFiberSupportShape2:CarbonFiberSupportTrans");
2460   TGeoVolume* CarbonFiberSupport = new TGeoVolume("CarbonFiberSupport",
2461                                                    CarbonFiberSupportCompShape,fgkSSDCarbonFiberMedium);
2462   CarbonFiberSupport->SetLineColor(fColorCarbonFiber);
2463   TGeoVolume* CarbonFiberSupportAssembly =
2464                                                     new TGeoVolumeAssembly("CarbonFiberSupportAssembly");
2465   CarbonFiberSupportAssembly->AddNode(CarbonFiberSupport,1);
2466   CarbonFiberSupportAssembly->AddNode(CarbonFiberSupport,2,
2467                                                                           CarbonFiberSupportCombiTrans);
2468   return CarbonFiberSupportAssembly;
2469 }
2470 ////////////////////////////////////////////////////////////////////////////////
2471 TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberLowerSupport(Int_t ikind, Bool_t EndLadder){
2472 ////////////////////////////////////////////////////////////////////////////////
2473   const Int_t VertexNumber = 4;
2474   const Int_t ShapesNumber = 2;
2475   Double_t Width[2] = {fgkCarbonFiberLowerSupportWidth,
2476                                                                 fgkCarbonFiberLowerSupportWidth};
2477   TVector3** VertexPosition[ShapesNumber];
2478   for(Int_t i = 0; i<ShapesNumber; i++) VertexPosition[i] =
2479                                                  new TVector3*[VertexNumber];
2480   //First Shape Vertex Positioning
2481   VertexPosition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
2482   VertexPosition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
2483                                            -            fgkCarbonFiberLowerSupportLowerLenght);
2484   VertexPosition[0][2] = new TVector3();
2485   VertexPosition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
2486   //Second Shape Vertex Positioning
2487   Double_t Theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
2488                                  -                              fgkCarbonFiberLowerSupportVolumePosition[0])
2489                                  /                              fgkCarbonFiberTriangleLength);
2490   VertexPosition[1][0] = new TVector3(VertexPosition[0][0]->X(),
2491                                                                 VertexPosition[0][0]->X()*TMath::Tan(Theta)
2492                                  +                              fgkCarbonFiberLowerSupportVolumePosition[0]);
2493   VertexPosition[1][1] = new TVector3(VertexPosition[0][1]->X(),
2494                                                                 VertexPosition[0][1]->X()*TMath::Tan(Theta)
2495                                  +                              fgkCarbonFiberLowerSupportVolumePosition[0]);
2496   VertexPosition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
2497   VertexPosition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
2498                                                                 fgkCarbonFiberLowerSupportVolumePosition[1]);
2499   char* CarbonFiberLowerSupportName[ShapesNumber] =
2500                           {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
2501   TGeoArb8* CarbonFiberLowerSupportShape[ShapesNumber];
2502   for(Int_t i = 0; i< ShapesNumber; i++) CarbonFiberLowerSupportShape[i] =
2503                                                                 GetArbShape(VertexPosition[i],Width,
2504                                                                                         fgkCarbonFiberLowerSupportHeight,
2505                                                                                         CarbonFiberLowerSupportName[i]);
2506   ///////////////////////////////////////////////////////
2507   TGeoTranslation* CarbonFiberLowerSupportTrans[ShapesNumber];
2508   CarbonFiberLowerSupportTrans[0] =
2509                                                 new TGeoTranslation("CarbonFiberLowerSupportTrans1",
2510                                                 0.0,
2511                                                 VertexPosition[1][3]->Y()+VertexPosition[1][2]->Y(),
2512                                                 0.0);
2513   CarbonFiberLowerSupportTrans[1] =
2514                                                 new TGeoTranslation("CarbonFiberLowerSupportTrans2",
2515                                                 0.0,
2516                                 -               VertexPosition[1][3]->Y()-VertexPosition[1][2]->Y(),
2517                                                 0.0);
2518   for(Int_t i = 0; i< ShapesNumber; i++)
2519                                                 CarbonFiberLowerSupportTrans[i]->RegisterYourself();
2520   ///////////////////////////////////////////////////////
2521   TGeoCompositeShape* CarbonFiberLowerSupportCompShape;
2522   if(EndLadder==false)
2523     CarbonFiberLowerSupportCompShape =
2524                                 new TGeoCompositeShape("CarbonFiberLowerSupportCompShape",
2525                                 "CarbonFiberLowerSupportShape2+"
2526                                 "CarbonFiberLowerSupportShape1:CarbonFiberLowerSupportTrans1");
2527   else
2528     if(ikind==0)
2529       CarbonFiberLowerSupportCompShape =
2530                                                   (TGeoCompositeShape*)CarbonFiberLowerSupportShape[0];
2531     else
2532       CarbonFiberLowerSupportCompShape =
2533         new TGeoCompositeShape("CarbonFiberLowerSupportCompShape",
2534                                  "CarbonFiberLowerSupportShape1+"
2535                                  "CarbonFiberLowerSupportShape1:CarbonFiberLowerSupportTrans1");
2536   TGeoVolume* CarbonFiberLowerSupport = new TGeoVolume("CarbonFiberLowerSupport",
2537                                           CarbonFiberLowerSupportCompShape,fgkSSDCarbonFiberMedium);
2538   CarbonFiberLowerSupport->SetLineColor(fColorCarbonFiber);
2539   return CarbonFiberLowerSupport;
2540 }
2541 ////////////////////////////////////////////////////////////////////////////////
2542 TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberAssemblySupport(){
2543 ////////////////////////////////////////////////////////////////////////////////
2544   SetCarbonFiberAssemblyCombiTransMatrix();
2545   TGeoVolume* CarbonFiberAssemblySupport =
2546                                                 new TGeoVolumeAssembly("CarbonFiberAssembly");
2547   TGeoVolume* CarbonFiberAssemblyVolumes[fgkCarbonFiberAssemblyCombiTransNumber];
2548   CarbonFiberAssemblyVolumes[0] = GetCarbonFiberJunctionAssembly();
2549   CarbonFiberAssemblyVolumes[1] = GetCarbonFiberSupport();
2550   CarbonFiberAssemblyVolumes[2] = GetCarbonFiberLowerSupport();
2551   for(Int_t i=0; i<fgkCarbonFiberAssemblyCombiTransNumber;i++)
2552     CarbonFiberAssemblySupport->AddNode(CarbonFiberAssemblyVolumes[i],1,
2553                                                 CarbonFiberAssemblyCombiTransMatrix[i]);
2554   return CarbonFiberAssemblySupport;
2555 }
2556 ////////////////////////////////////////////////////////////////////////////////
2557 TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(){
2558 ////////////////////////////////////////////////////////////////////////////////
2559   const Int_t VertexNumber = 3;
2560   Double_t Phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2561                            /                     fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2562   /* TGeoTubeSeg* CoolingTubeSegShape =  */
2563                                                 new TGeoTubeSeg("CoolingTubeSegShape",0.0,
2564                                                         fgkCoolingTubeSupportRmax,
2565                                                         0.5*fgkCoolingTubeSupportWidth,Phi,
2566                                                         360-Phi);
2567   /* TGeoTube* CoolingTubeHoleShape =  */
2568                                                 new TGeoTube("CoolingTubeHoleShape",0.0,
2569                                                         fgkCoolingTubeSupportRmin,
2570                                                         0.5*fgkCoolingTubeSupportWidth);
2571   TVector3* VertexPosition[VertexNumber];
2572   ///////////////////////////
2573   //Shape Vertex Positioning
2574   ///////////////////////////
2575   VertexPosition[0] = new TVector3();
2576   VertexPosition[1] = new TVector3(fgkCoolingTubeSupportRmax
2577                                         *               TMath::Cos(Phi*TMath::DegToRad()),
2578                                                         fgkCoolingTubeSupportRmax
2579                                         *               TMath::Sin(Phi*TMath::DegToRad()));
2580   VertexPosition[2] = new TVector3(VertexPosition[1]->X(),
2581                                         -                          VertexPosition[1]->Y());
2582   /* TGeoArb8* CoolingTubeTriangleShape = */ GetTriangleShape(VertexPosition,
2583                                                                            fgkCoolingTubeSupportWidth,
2584                                                                            "CoolingTubeTriangleShape");
2585   Double_t* BoxOrigin = new Double_t[3];
2586   Double_t BoxLength = fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax
2587                                          - VertexPosition[1]->X();
2588   BoxOrigin[0] = VertexPosition[1]->X()+0.5*BoxLength, BoxOrigin[1] = BoxOrigin[2] = 0.;
2589   /* TGeoBBox* CoolingTubeBoxShape = */
2590                                                 new TGeoBBox("CoolingTubeBoxShape",0.5*BoxLength,
2591                                                         0.5*fgkCoolingTubeSupportHeight,
2592                                                         0.5*fgkCoolingTubeSupportWidth,BoxOrigin);
2593   TGeoCompositeShape* CoolingTubeSupportShape =
2594                                                 new TGeoCompositeShape("CoolingTubeSupportShape",
2595                                                  "(CoolingTubeSegShape+CoolingTubeTriangleShape"
2596                                                  "+CoolingTubeBoxShape)-CoolingTubeHoleShape");
2597   TGeoVolume* CoolingTubeSupport = new TGeoVolume("CoolingTubeSupport",
2598                                                  CoolingTubeSupportShape,fgkSSDTubeHolderMedium);
2599   return CoolingTubeSupport;
2600 }
2601 ////////////////////////////////////////////////////////////////////////////////
2602 TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupportAssembly(){
2603 ////////////////////////////////////////////////////////////////////////////////
2604   TGeoVolume* CoolingTubeSupportAssembly =
2605                                                    new TGeoVolumeAssembly("CoolingTubeSupportAssembly");
2606   TGeoVolume* CoolingTubeSupport = GetCoolingTubeSupport();
2607   SetCoolingTubeSupportCombiTransMatrix();
2608   for(Int_t i=0; i<fgkCoolingTubeSupportCombiTransNumber;i++)
2609     CoolingTubeSupportAssembly->AddNode(CoolingTubeSupport,i+1,
2610                                                                                  CoolingTubeSupportCombiTransMatrix[i]);
2611   return CoolingTubeSupportAssembly;
2612 }
2613 ////////////////////////////////////////////////////////////////////////////////
2614 TGeoVolume* AliITSv11GeometrySSD::GetCoolingTube(){
2615 ////////////////////////////////////////////////////////////////////////////////
2616   TGeoVolume* CoolingTubeAssembly = new TGeoVolumeAssembly("CoolingTubeAssembly");
2617   TGeoTube *CoolingTubeShape = new TGeoTube("CoolingTubeShape", fgkCoolingTubeRmin,
2618                                                 fgkCoolingTubeRmax, fgkCoolingTubeLength/2.0);
2619   TGeoVolume* CoolingTube = new TGeoVolume("CoolingTube",
2620                                                  CoolingTubeShape,fgkSSDCoolingTubePhynox);
2621   TGeoTube *CoolingTubeInteriorShape = new TGeoTube("CoolingTubeInteriorShape",
2622                                                 0, fgkCoolingTubeRmin,
2623                                                 fgkCoolingTubeLength/2.0);
2624   TGeoVolume *CoolingTubeInterior = new TGeoVolume("CoolingTubeInterior",
2625                                                    CoolingTubeInteriorShape,fgkSSDCoolingTubeWater);
2626   CoolingTubeAssembly->AddNode(CoolingTube,1);
2627   CoolingTubeAssembly->AddNode(CoolingTubeInterior,2);
2628   return CoolingTubeAssembly;
2629 }
2630 ////////////////////////////////////////////////////////////////////////////////
2631 TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeAssembly(){
2632 ////////////////////////////////////////////////////////////////////////////////
2633   TGeoVolume* CoolingTubeAssembly =   new TGeoVolumeAssembly("CoolingTubeAssembly");
2634   TGeoVolume* CoolingTube = GetCoolingTube();
2635   SetCoolingTubeCombiTransMatrix();
2636   for(Int_t i=0; i<fgkCoolingTubeCombiTransNumber;i++)
2637     CoolingTubeAssembly->AddNode(CoolingTube,i+1,CoolingTubeTransMatrix[i]);
2638   return CoolingTubeAssembly;
2639 }
2640 ////////////////////////////////////////////////////////////////////////////////
2641 TGeoVolume* AliITSv11GeometrySSD::GetLadderSegment(Int_t iChipCablesHeight){
2642 ////////////////////////////////////////////////////////////////////////////////
2643     TGeoVolume* LadderSegment = new TGeoVolumeAssembly("LadderSegment");
2644     TGeoVolume* LadderSegmentVolumes[fgkLadderSegmentCombiTransNumber];
2645     LadderSegmentVolumes[0] = GetCarbonFiberAssemblySupport();
2646     LadderSegmentVolumes[1] = GetSSDModule(iChipCablesHeight);
2647     LadderSegmentVolumes[2] = GetSSDSensorSupportAssembly(iChipCablesHeight);
2648     LadderSegmentVolumes[3] = GetCoolingTubeSupportAssembly();
2649         LadderSegmentVolumes[4] = GetCoolingTubeAssembly();
2650     SetLadderSegmentCombiTransMatrix();
2651     for(Int_t i=0; i<fgkLadderSegmentCombiTransNumber; i++)
2652       LadderSegment->AddNode(LadderSegmentVolumes[i],1,
2653                                                          LadderSegmentCombiTransMatrix[i]);
2654     return LadderSegment;
2655 }
2656 ////////////////////////////////////////////////////////////////////////////////
2657 TList* AliITSv11GeometrySSD::GetEndLadderSegment(){
2658 ////////////////////////////////////////////////////////////////////////////////
2659   const Int_t EndLadderSegmentNumber = 2;
2660   TList* EndLadderCarbonFiberJunctionList = GetEndLadderCarbonFiberJunctionAssembly();
2661   TGeoVolume* EndLadderSegment[EndLadderSegmentNumber];
2662   EndLadderSegment[0] = new TGeoVolumeAssembly("EndLadderSegment1");
2663   EndLadderSegment[1] = new TGeoVolumeAssembly("EndLadderSegment2");
2664   TGeoVolume** LadderSegmentVolumes[EndLadderSegmentNumber];
2665   const Int_t LadderSegmentVolumeNumber = 4;
2666   for(Int_t i=0; i<EndLadderSegmentNumber; i++) LadderSegmentVolumes[i] =
2667                                                 new TGeoVolume*[LadderSegmentVolumeNumber];
2668   LadderSegmentVolumes[0][0] = (TGeoVolume*)EndLadderCarbonFiberJunctionList->At(0);
2669   LadderSegmentVolumes[0][1] = GetCarbonFiberSupport();
2670   LadderSegmentVolumes[0][2] = GetSSDMountingBlock();
2671   LadderSegmentVolumes[0][3] = GetCarbonFiberLowerSupport(0,true);
2672   LadderSegmentVolumes[1][0] = (TGeoVolume*)EndLadderCarbonFiberJunctionList->At(1);
2673   LadderSegmentVolumes[1][1] = LadderSegmentVolumes[0][1];
2674   LadderSegmentVolumes[1][2] = LadderSegmentVolumes[0][2];
2675   LadderSegmentVolumes[1][3] = GetCarbonFiberLowerSupport(1,true);
2676   TList* EndLadderSegmentList = new TList();
2677   for(Int_t i=0; i<EndLadderSegmentNumber; i++){
2678     SetEndLadderSegmentCombiTransMatrix(i);
2679     for(Int_t j=0; j<LadderSegmentVolumeNumber; j++)
2680       EndLadderSegment[i]->AddNode(LadderSegmentVolumes[i][j],1,
2681                                                                    EndLadderSegmentCombiTransMatrix[j]);
2682     EndLadderSegmentList->Add(EndLadderSegment[i]);
2683   }
2684   return EndLadderSegmentList;
2685 }
2686 ////////////////////////////////////////////////////////////////////////////////
2687 TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
2688 ////////////////////////////////////////////////////////////////////////////////
2689   // Mounting Block Boxes Shapes
2690   ///////////////////////////////////////
2691   const Int_t MountingBlockBoxNumber = 3;
2692   TGeoBBox* MountingBlockBoxShape[MountingBlockBoxNumber];
2693   MountingBlockBoxShape[0] = new TGeoBBox("MountingBlockBoxShape0",
2694                                                         0.25*(fgkSSDMountingBlockLength[0]
2695                                                 -       fgkSSDMountingBlockLength[1]),
2696                                                         0.5*fgkSSDMountingBlockWidth,
2697                                                         0.5*fgkSSDMountingBlockHeight[0]);
2698   MountingBlockBoxShape[1] = new TGeoBBox("MountingBlockBoxShape1",
2699                                                         0.25*(fgkSSDMountingBlockLength[1]
2700                                                 -       fgkSSDMountingBlockLength[2]),
2701                                                         0.5*fgkSSDMountingBlockWidth,
2702                                                         0.5*(fgkSSDMountingBlockHeight[1]
2703                                                 -       fgkSSDMountingBlockHeight[3]));
2704   MountingBlockBoxShape[2] = new TGeoBBox("MountingBlockBoxShape2",
2705                                                         0.5*fgkSSDMountingBlockLength[2],
2706                                                         0.5*fgkSSDMountingBlockWidth,
2707                                                         0.5*(fgkSSDMountingBlockHeight[2]
2708                                                 -       fgkSSDMountingBlockHeight[3]));
2709   TGeoTranslation* MountingBlockBoxTrans[MountingBlockBoxNumber+2];
2710   MountingBlockBoxTrans[0] = new TGeoTranslation("MountingBlockBoxTrans0",0.,0.,0.);
2711   MountingBlockBoxTrans[1] = new TGeoTranslation("MountingBlockBoxTrans1",
2712                                                         MountingBlockBoxShape[0]->GetDX()
2713                                                 +       MountingBlockBoxShape[1]->GetDX(),
2714                                                         0.0,
2715                                                         MountingBlockBoxShape[1]->GetDZ()
2716                                                 -       MountingBlockBoxShape[0]->GetDZ()
2717                                                 +       fgkSSDMountingBlockHeight[3]);
2718   MountingBlockBoxTrans[2] = new TGeoTranslation("MountingBlockBoxTrans2",
2719                                                         MountingBlockBoxShape[0]->GetDX()
2720                                                 +       2.*MountingBlockBoxShape[1]->GetDX()
2721                                                 +       MountingBlockBoxShape[2]->GetDX(),
2722                                                         0.0,
2723                                                         MountingBlockBoxShape[2]->GetDZ()
2724                                                 -       MountingBlockBoxShape[0]->GetDZ()
2725                                                 +       fgkSSDMountingBlockHeight[3]);
2726   MountingBlockBoxTrans[3] = new TGeoTranslation("MountingBlockBoxTrans3",
2727                                                         MountingBlockBoxShape[0]->GetDX()
2728                                                 +       MountingBlockBoxShape[1]->GetDX()
2729                                                 +       2.*(MountingBlockBoxShape[1]->GetDX()
2730                                                 +       MountingBlockBoxShape[2]->GetDX()),
2731                                                         0.0,
2732                                                         MountingBlockBoxShape[1]->GetDZ()
2733                                                 -       MountingBlockBoxShape[0]->GetDZ()
2734                                                 +       fgkSSDMountingBlockHeight[3]);
2735   MountingBlockBoxTrans[4] = new TGeoTranslation("MountingBlockBoxTrans4",
2736                                                         2.*(MountingBlockBoxShape[0]->GetDX()
2737                                                 +       2.*MountingBlockBoxShape[1]->GetDX()
2738                                                 +   MountingBlockBoxShape[2]->GetDX()),
2739                                                         0.0,
2740                                                         0.0);
2741   for(Int_t i=0; i<MountingBlockBoxNumber+2; i++)
2742                                                                         MountingBlockBoxTrans[i]->RegisterYourself();
2743   ///////////////////////////////////////
2744   // Mounting Block Trapezoid Hole Shapes
2745   ///////////////////////////////////////
2746   const Int_t HoleTrapezoidVertexNumber = 4;
2747   TVector3* HoleTrapezoidVertex[HoleTrapezoidVertexNumber];
2748   HoleTrapezoidVertex[0] = new TVector3();
2749   HoleTrapezoidVertex[1] = new TVector3(fgkSSDMountingBlockHoleTrapezoidHeight);
2750   HoleTrapezoidVertex[2] = new TVector3(*HoleTrapezoidVertex[0]);
2751   HoleTrapezoidVertex[3] = new TVector3(*HoleTrapezoidVertex[1]);
2752   Double_t HoleTrapezoidWidth[2] = {fgkSSDMountingBlockHoleTrapezoidUpBasis
2753                                                 +       2.*MountingBlockBoxShape[1]->GetDX()
2754                                                 *       TMath::Tan(fgkSSDMountingBlockHoleTrapezoidAngle
2755                                                 *       TMath::DegToRad()),
2756                                                         fgkSSDMountingBlockHoleTrapezoidUpBasis};
2757   /* TGeoArb8* HoleTrapezoidShape =*/ GetArbShape(HoleTrapezoidVertex,
2758                                                         HoleTrapezoidWidth,
2759                                                         2.*MountingBlockBoxShape[1]->GetDX(),
2760                                                         "HoleTrapezoidShape");
2761   TGeoRotation* HoleTrapezoidShapeRot[2];
2762   HoleTrapezoidShapeRot[0] = new TGeoRotation("HoleTrapezoidShapeRot0",
2763                                                         90.,-90.,-90.);
2764   HoleTrapezoidShapeRot[1] = new TGeoRotation("HoleTrapezoidShapeRot1",
2765                                                         -180.,0.,0.);
2766   TGeoCombiTrans* HoleTrapezoidShapeCombiTrans =
2767                                                         new TGeoCombiTrans("HoleTrapezoidShapeCombiTrans",
2768                                                         MountingBlockBoxShape[0]->GetDX()
2769                                                 +       3.*MountingBlockBoxShape[1]->GetDX()
2770                                                 +       2.*MountingBlockBoxShape[2]->GetDX(),
2771                                                         0.5*fgkSSDMountingBlockWidth,
2772                                                 -       fgkSSDMountingBlockHoleTrapezoidHeight
2773                                                 +       2.*MountingBlockBoxShape[1]->GetDZ()
2774                                                 -       MountingBlockBoxShape[0]->GetDZ()
2775                                                 +       fgkSSDMountingBlockHeight[3],
2776                                                         new TGeoRotation((*HoleTrapezoidShapeRot[1])
2777                                                 *       (*HoleTrapezoidShapeRot[0])));
2778   HoleTrapezoidShapeCombiTrans->RegisterYourself();
2779   ///////////////////////////////////
2780   // Mounting Block Screw Hole Shapes
2781   ///////////////////////////////////
2782   const Int_t MountingBlockTubeNumber = 2;
2783   TGeoTube* MountingBlockTubeShape[MountingBlockTubeNumber];
2784   MountingBlockTubeShape[0] = new TGeoTube("MountingBlockTubeShape0",0.0,
2785                                                         fgkSSDMountingBlockHoleRadius,
2786                                                         MountingBlockBoxShape[0]->GetDZ());
2787   MountingBlockTubeShape[1] = new TGeoTube("MountingBlockTubeShape1",0.0,
2788                                                         fgkSSDMountingBlockHoleRadius,
2789                                                         MountingBlockBoxShape[2]->GetDZ());
2790   TGeoTranslation* MountingBlockTubeTrans[2*MountingBlockTubeNumber];
2791   MountingBlockTubeTrans[0] = new TGeoTranslation("MountingBlockTubeTrans0",
2792                                                 -       0.5*(fgkSSDMountingBlockLength[0]
2793                                                 -       fgkSSDMountingBlockHoleTubeLength[0]),
2794                                                         0.5*fgkSSDMountingBlockWidth
2795                                                 -       fgkSSDMountingBlockHoleTubeWidth[0],0.);
2796   MountingBlockTubeTrans[1] = new TGeoTranslation("MountingBlockTubeTrans1",
2797                                                 -       0.5*(fgkSSDMountingBlockLength[0]
2798                                                 -       fgkSSDMountingBlockHoleTubeLength[0])
2799                                                 +       fgkSSDMountingBlockHoleTubeLength[0],
2800                                                 -       0.5*fgkSSDMountingBlockWidth
2801                                                 +       fgkSSDMountingBlockHoleTubeWidth[0],
2802                                                         0.);
2803   MountingBlockTubeTrans[2] = new TGeoTranslation("MountingBlockTubeTrans2",
2804                                                 -       MountingBlockBoxShape[0]->GetDX()
2805                                                 +       0.5*fgkSSDMountingBlockLength[0]
2806                                                 -       fgkSSDMountingBlockHoleTubeLength[1],
2807                                                         0.5*fgkSSDMountingBlockWidth
2808                                                 -       fgkSSDMountingBlockHoleTubeWidth[0],
2809                                                         MountingBlockBoxShape[2]->GetDZ()
2810                                                 -       MountingBlockBoxShape[0]->GetDZ()
2811                                                 +       fgkSSDMountingBlockHeight[3]);
2812   MountingBlockTubeTrans[3] = new TGeoTranslation("MountingBlockTubeTrans3",
2813                                                 -       MountingBlockBoxShape[0]->GetDX()
2814                                                 +       0.5*fgkSSDMountingBlockLength[0],
2815                                                 -       0.5*fgkSSDMountingBlockWidth
2816                                                 +       fgkSSDMountingBlockHoleTubeWidth[1],
2817                                                         MountingBlockBoxShape[2]->GetDZ()
2818                                                 -       MountingBlockBoxShape[0]->GetDZ()
2819                                                 +       fgkSSDMountingBlockHeight[3]);
2820   for(Int_t i=0; i<2*MountingBlockTubeNumber; i++)
2821                                                 MountingBlockTubeTrans[i]->RegisterYourself();
2822   /* TGeoCompositeShape* MountingBlockMainShape = */
2823                                                 new TGeoCompositeShape("MountingBlockMainShape",
2824                                                 "MountingBlockBoxShape0:MountingBlockBoxTrans0+"
2825                                                 "MountingBlockBoxShape1:MountingBlockBoxTrans1+"
2826                                                 "MountingBlockBoxShape2:MountingBlockBoxTrans2+"
2827                                                 "MountingBlockBoxShape1:MountingBlockBoxTrans3+"
2828                                                 "MountingBlockBoxShape0:MountingBlockBoxTrans4");
2829   ////////////////////////////////////////////
2830   // Mounting Block Screw Composite Hole Shapes
2831   ////////////////////////////////////////////
2832   const Int_t MountingBlockHoleTubeSegNumber = 4;
2833   /* TGeoTubeSeg* MountingBlockHoleTubeSegShape =  */
2834                                                 new TGeoTubeSeg("MountingBlockHoleTubeSegShape",
2835                                                 0.0,
2836                                                 fgkSSDMountingBlockScrewHoleRadius[0],
2837                                                 0.5*fgkSSDMountingBlockScrewHoleHeigth,-90.,180.);
2838   TGeoCombiTrans* MountingBlockHoleTubeSegCombiTrans[MountingBlockHoleTubeSegNumber];
2839   char* MountingBlockHoleTubeSegCombiTransName[MountingBlockHoleTubeSegNumber] =
2840                                         {       "MountingBlockHoleTubeSegCombiTrans0",
2841                                                 "MountingBlockHoleTubeSegCombiTrans1",
2842                                                 "MountingBlockHoleTubeSegCombiTrans2",
2843                                                 "MountingBlockHoleTubeSegCombiTrans3"};
2844   for(Int_t i=0; i<MountingBlockHoleTubeSegNumber; i++){
2845     MountingBlockHoleTubeSegCombiTrans[i] =
2846       new TGeoCombiTrans(MountingBlockHoleTubeSegCombiTransName[i],
2847                                                 0.5*fgkSSDMountingBlockScrewHoleEdge*TMath::Sqrt(2)
2848                                         *       TMath::Cos(45*(2*i+1)*TMath::DegToRad()),
2849                                                 0.5*fgkSSDMountingBlockScrewHoleEdge*TMath::Sqrt(2)
2850                                         *       TMath::Sin(45*(2*i+1)*TMath::DegToRad()),
2851                                                 0.0,
2852                                                 new TGeoRotation("",90.*i,0.,0.));
2853     MountingBlockHoleTubeSegCombiTrans[i]->RegisterYourself();
2854   }
2855   TGeoBBox* MountingBlockHoleBoxShape =
2856                                                 new TGeoBBox("MountingBlockHoleBoxShape",
2857                                                 0.5*fgkSSDMountingBlockScrewHoleEdge,
2858                                                 0.5*fgkSSDMountingBlockScrewHoleEdge,
2859                                                 0.5*fgkSSDMountingBlockScrewHoleHeigth);
2860   TGeoCompositeShape* MountingBlockScrewHole[2];
2861   MountingBlockScrewHole[0] =
2862                         new TGeoCompositeShape("MountingBlockScrewHole0",
2863                         "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans0+"
2864                         "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans1+"
2865                         "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans2+"
2866                         "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans3+"
2867                         "MountingBlockHoleBoxShape");
2868   /* TGeoTubeSeg* MountingBlockLowerHoleTubeSegShape = */
2869                         new TGeoTubeSeg("MountingBlockLowerHoleTubeSegShape",
2870                                                 0.0,
2871                                                 fgkSSDMountingBlockScrewHoleRadius[1],
2872                                                 0.5*(fgkSSDMountingBlockHoleTubeWidth[0]
2873                                         -       fgkSSDMountingBlockScrewHoleHeigth
2874                                         -       fgkSSDMountingBlockHeight[3]),0.,90.);
2875   TGeoCombiTrans* MountingBlockLowerHoleTubeSegCombiTrans[MountingBlockHoleTubeSegNumber];
2876   char* MountingBlockLowerHoleTubeSegCombiTransName[MountingBlockHoleTubeSegNumber] =
2877                                         {       "MountingBlockLowerHoleTubeSegCombiTrans0",
2878                                                 "MountingBlockLowerHoleTubeSegCombiTrans1",
2879                                                 "MountingBlockLowerHoleTubeSegCombiTrans2",
2880                                                 "MountingBlockLowerHoleTubeSegCombiTrans3"};
2881   for(Int_t i=0; i<MountingBlockHoleTubeSegNumber; i++){
2882     MountingBlockLowerHoleTubeSegCombiTrans[i] =
2883                         new TGeoCombiTrans(MountingBlockLowerHoleTubeSegCombiTransName[i],
2884                                                 0.5*(fgkSSDMountingBlockScrewHoleEdge
2885                                         -       2.*fgkSSDMountingBlockScrewHoleRadius[1])
2886                                         *       TMath::Sqrt(2)*TMath::Cos(45*(2*i+1)*TMath::DegToRad()),
2887                                                 0.5*(fgkSSDMountingBlockScrewHoleEdge
2888                                         -       2.0*fgkSSDMountingBlockScrewHoleRadius[1])
2889                                         *       TMath::Sqrt(2)*TMath::Sin(45*(2*i+1)*TMath::DegToRad()),0.,
2890                                                 new TGeoRotation("",90.*i,0.,0.));
2891                                         MountingBlockLowerHoleTubeSegCombiTrans[i]->RegisterYourself();
2892   }
2893   Double_t fgkSSDMountingBlockLowerScrewHoleEdge = fgkSSDMountingBlockScrewHoleEdge
2894                                         -       2.*fgkSSDMountingBlockScrewHoleRadius[1];
2895   TGeoBBox* MountingBlockLowerHoleBoxShape[2];
2896   MountingBlockLowerHoleBoxShape[0] =
2897                         new TGeoBBox("MountingBlockLowerHoleBoxShape0",
2898                                                 0.5*fgkSSDMountingBlockLowerScrewHoleEdge,
2899                                                 0.5*fgkSSDMountingBlockLowerScrewHoleEdge,
2900                                                 0.5*(fgkSSDMountingBlockHoleTubeWidth[0]
2901                                         -       fgkSSDMountingBlockScrewHoleHeigth
2902                                         -       fgkSSDMountingBlockHeight[3]));
2903   MountingBlockLowerHoleBoxShape[1] =
2904                         new TGeoBBox("MountingBlockLowerHoleBoxShape1",
2905                                                 0.5*fgkSSDMountingBlockLowerScrewHoleEdge,
2906                                                 0.5*fgkSSDMountingBlockScrewHoleRadius[1],
2907                                                 0.5*(fgkSSDMountingBlockHoleTubeWidth[0]
2908                                         -       fgkSSDMountingBlockScrewHoleHeigth
2909                                         -       fgkSSDMountingBlockHeight[3]));
2910   TGeoCombiTrans* MountingBlockLowerHoleBoxCombiTrans[MountingBlockHoleTubeSegNumber];
2911   char* MountingBlockLowerHoleBoxCombiTransName[MountingBlockHoleTubeSegNumber] =
2912                                         {       "MountingBlockLowerHoleBoxCombiTrans0",
2913                                                 "MountingBlockLowerHoleBoxCombiTrans1",
2914                                                 "MountingBlockLowerHoleBoxCombiTrans2",
2915                                                 "MountingBlockLowerHoleBoxCombiTrans3"};
2916   for(Int_t i=0; i<MountingBlockHoleTubeSegNumber; i++){
2917     MountingBlockLowerHoleBoxCombiTrans[i] =
2918                         new TGeoCombiTrans(MountingBlockLowerHoleBoxCombiTransName[i],
2919                                                 0.5*(fgkSSDMountingBlockLowerScrewHoleEdge
2920                                         +       fgkSSDMountingBlockScrewHoleRadius[1])
2921                                         *       TMath::Cos(90*(i+1)*TMath::DegToRad()),
2922                                                 0.5*(fgkSSDMountingBlockLowerScrewHoleEdge
2923                                         +       fgkSSDMountingBlockScrewHoleRadius[1])
2924                                         *       TMath::Sin(90*(i+1)*TMath::DegToRad()),0.,
2925                                                 new TGeoRotation("",90.*i,0.,0.));
2926     MountingBlockLowerHoleBoxCombiTrans[i]->RegisterYourself();
2927   }
2928   MountingBlockScrewHole[1] = new TGeoCompositeShape("MountingBlockScrewHole1",
2929         "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans0+"
2930         "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans1+"
2931         "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans2+"
2932         "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans3+"
2933         "MountingBlockLowerHoleBoxShape0+"
2934         "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans0+"
2935         "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans1+"
2936         "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans2+"
2937         "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans3");
2938   TGeoTranslation* MountingBlockScrewHole1Trans =
2939                         new TGeoTranslation("MountingBlockScrewHole1Trans",0.,0.,
2940                                         -       MountingBlockLowerHoleBoxShape[0]->GetDZ()
2941                                         -       MountingBlockHoleBoxShape->GetDZ());
2942   MountingBlockScrewHole1Trans->RegisterYourself();
2943   /* TGeoCompositeShape* MountingBlockHole = */
2944                         new TGeoCompositeShape("MountingBlockHole",
2945         "MountingBlockScrewHole0+MountingBlockScrewHole1:MountingBlockScrewHole1Trans");
2946   TGeoTranslation* MountingBlockHoleTrans = new TGeoTranslation("MountingBlockHoleTrans",
2947                                                 0.5*fgkSSDMountingBlockLength[0]
2948                                         -       MountingBlockBoxShape[0]->GetDZ(),
2949                                                 0.0,
2950                                                 2.*MountingBlockBoxShape[2]->GetDZ()
2951                                         -       MountingBlockBoxShape[0]->GetDZ()
2952                                         +       fgkSSDMountingBlockHeight[3]
2953                                         -       MountingBlockHoleBoxShape->GetDZ());
2954   MountingBlockHoleTrans->RegisterYourself();
2955   TGeoCompositeShape* MountingBlockShape = new TGeoCompositeShape("MountingBlockShape",
2956                         "MountingBlockMainShape-(MountingBlockTubeShape0:MountingBlockTubeTrans0+"
2957                         "MountingBlockTubeShape0:MountingBlockTubeTrans1+"
2958                         "MountingBlockTubeShape1:MountingBlockTubeTrans2+"
2959                         "MountingBlockTubeShape1:MountingBlockTubeTrans3+"
2960                         "HoleTrapezoidShape:HoleTrapezoidShapeCombiTrans+"
2961                         "MountingBlockHole:MountingBlockHoleTrans)");
2962   TGeoVolume* SSDMountingBlock = new TGeoVolume("SSDMountingBlock",
2963                         MountingBlockShape,fgkSSDMountingBlockMedium);
2964   return SSDMountingBlock;
2965 }
2966 ////////////////////////////////////////////////////////////////////////////////
2967 TGeoVolume* AliITSv11GeometrySSD::GetLadder(Int_t iLayer){
2968   TGeoVolume* Ladder = new TGeoVolumeAssembly(iLayer==5 ? "ITSssdLay5Ladd"
2969                                                                                                                 : "ITSssdLay6Ladd");
2970   TGeoVolume* LadderSegment[2];
2971   LadderSegment[0] = GetLadderSegment(0);
2972   LadderSegment[1] = GetLadderSegment(1);
2973   TList* EndLadderSegmentList = GetEndLadderSegment();
2974   Double_t BeamAxisTransVector = fgkCarbonFiberJunctionWidth;
2975   Int_t SSDLaySensorsNumber = (iLayer==5 ?
2976                                                 fgkSSDLay5SensorsNumber :
2977                                                 fgkSSDLay6SensorsNumber);
2978   for(Int_t i=0; i<SSDLaySensorsNumber; i++) Ladder->AddNode(i%2==0 ?
2979                                                 LadderSegment[iLayer==5 ? 0 : 1] :
2980                                                 LadderSegment[iLayer==5 ? 1 : 0],
2981                                                 SSDLaySensorsNumber-i,new TGeoTranslation("",-0.5*fgkCarbonFiberTriangleLength,
2982                                                 BeamAxisTransVector*i,0.));
2983   Ladder->AddNode((TGeoVolume*)EndLadderSegmentList->At(0),1,
2984                                                 new TGeoTranslation("",-0.5*fgkCarbonFiberTriangleLength,
2985                                                 fgkCarbonFiberJunctionWidth*SSDLaySensorsNumber,0.));
2986   Ladder->AddNode((TGeoVolume*)EndLadderSegmentList->At(1),1,
2987                                                 new TGeoCombiTrans("",0.5*fgkCarbonFiberTriangleLength,
2988                                                 0.,0.,new TGeoRotation("",180.,0.,0.)));
2989 /////////////////////////////////////////////////////////////////////////////
2990 /// Placing Ladder Cables
2991 /////////////////////////////////////////////////////////////////////////////
2992   SetLadderCableCombiTransMatrix(iLayer);
2993   Int_t SideCableNumber[2] = {0,0};
2994   switch(iLayer){
2995         case 5:
2996                 SideCableNumber[0] = fgkSSDLay5SensorsNumber/2+1;
2997                 SideCableNumber[1] = SideCableNumber[0]-2;
2998                 break;
2999     case 6:
3000                 SideCableNumber[0] = (fgkSSDLay6SensorsNumber-1)/2+1;
3001                 SideCableNumber[1] = SideCableNumber[0]-1;
3002                 break;
3003   }
3004   const Double_t* CarbonFiberToModulePosition =
3005                                                          LadderSegmentCombiTransMatrix[1]->GetTranslation();
3006   Double_t SSDEndLadderCableLength[4];
3007   SSDEndLadderCableLength[0] = CarbonFiberToModulePosition[1]
3008                                                          + fgkSSDSensorLength
3009                                                          - fgkSSDModuleStiffenerPosition[1]
3010                                                          - fgkSSDStiffenerWidth
3011                                                          - fgkSSDFlexWidth[0]
3012                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[1];
3013   SSDEndLadderCableLength[1] = CarbonFiberToModulePosition[1]
3014                                                          + fgkSSDModuleStiffenerPosition[1]
3015                                                          + fgkSSDStiffenerWidth
3016                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[1];
3017   SSDEndLadderCableLength[2] = SSDEndLadderCableLength[1]
3018                                                          - fgkEndLadderCarbonFiberLowerJunctionLength[1]
3019                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[0];
3020   SSDEndLadderCableLength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
3021                                                          + CarbonFiberToModulePosition[1]
3022                                                          - fgkSSDModuleStiffenerPosition[1]
3023                                                          - fgkSSDStiffenerWidth)
3024                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[1];
3025   TList* LadderCableAssemblyList[4];
3026   const Int_t EndLadderCablesNumber = 4;
3027   for(Int_t i=0; i<EndLadderCablesNumber; i++){
3028           LadderCableAssemblyList[i] =
3029           GetLadderCableAssemblyList(SideCableNumber[i<2?0:1],
3030                                                                    SSDEndLadderCableLength[i]);
3031           Ladder->AddNode((TGeoVolume*)LadderCableAssemblyList[i]->At(i%2==0?0:1),
3032                                                                         i<2?1:2,LadderCableCombiTransMatrix[i]);
3033   }
3034   return Ladder;
3035 }
3036 ////////////////////////////////////////////////////////////////////////////////
3037 TGeoVolume* AliITSv11GeometrySSD::GetLayer(Int_t iLayer){
3038   TGeoVolume* Layer = new TGeoVolumeAssembly(iLayer==5 ? "ITSssdLayer5"
3039                                                                                                            : "ITSssdLayer6");
3040   TGeoVolume* Ladder = GetLadder(iLayer);
3041   /////////////////////////////////////////////////////
3042   // Setting the CombiTransformation to pass ITS center
3043   /////////////////////////////////////////////////////
3044   Double_t ITSCenterTransZ = iLayer==5 ? fgkSSDLay5LadderLength
3045                            -             fgkLay5CenterITSPosition:
3046                                          fgkSSDLay6LadderLength
3047                            -             fgkLay6CenterITSPosition;
3048   Double_t ITSSensorYTrans = fgkSSDModuleCoolingBlockToSensor
3049                            + 0.5*        fgkCoolingTubeSupportHeight
3050                            -(iLayer==5 ? fgkSSDSensorSideSupportHeight[1]
3051                            -             fgkSSDSensorSideSupportHeight[0]: 0.);
3052   TGeoRotation* ITSCenterRot[3];
3053   ITSCenterRot[0] = new TGeoRotation("ITSCenterRot0",90.,180.,-90.);
3054   ITSCenterRot[1] = new TGeoRotation("ITSCenterRot1",0.,90.,0.);
3055   ITSCenterRot[2] = new TGeoRotation((*ITSCenterRot[1])*(*ITSCenterRot[0]));
3056   TGeoCombiTrans* ITSCenterCombiTrans = new TGeoCombiTrans("ITSCenterCombiTrans",0.,
3057                                         fgkSSDMountingBlockHeight[1]+ITSSensorYTrans,
3058                                         fgkEndLadderCarbonFiberLowerJunctionLength[1]
3059                                       - ITSCenterTransZ,ITSCenterRot[2]);
3060   /////////////////////////////////////////////////////
3061   // Setting the Ladder into the Layer
3062   /////////////////////////////////////////////////////
3063   Double_t LayLadderAnglePosition = 360./(iLayer==5 ? fgkSSDLay5LadderNumber :
3064                                           fgkSSDLay6LadderNumber);
3065   Int_t LayLadderNumber        = iLayer==5 ? fgkSSDLay5LadderNumber :
3066                                              fgkSSDLay6LadderNumber;
3067   Double_t LayRadiusMin        = iLayer==5 ? fgkSSDLay5RadiusMin    :
3068                                              fgkSSDLay6RadiusMin;
3069   Double_t LayRadiusMax        = iLayer==5 ? fgkSSDLay5RadiusMax    :
3070                                              fgkSSDLay6RadiusMax;
3071   TGeoCombiTrans* LadderCombiTrans[LayLadderNumber];
3072   TGeoHMatrix* LadderHMatrix[LayLadderNumber];
3073   Double_t LayerRadius = 0.;
3074   char LadderCombiTransName[30], LadderRotName[30];
3075   for(Int_t i=0; i<LayLadderNumber;i++){
3076       sprintf(LadderCombiTransName,"LadderCombiTrans%i",i);
3077       sprintf(LadderRotName,"LaddeRot%i",i);
3078       switch(iLayer){
3079             case 5:
3080                   LayerRadius = (i%2==0 ? LayRadiusMin: LayRadiusMax);
3081                   break;
3082             case 6:
3083                   LayerRadius = (i%2==0 ? LayRadiusMax : LayRadiusMin);
3084                   break;
3085       }
3086       LadderCombiTrans[i] = new TGeoCombiTrans(LadderCombiTransName,
3087                             LayerRadius *       TMath::Cos((i+1)
3088                           * LayLadderAnglePosition*TMath::DegToRad()),
3089                             LayerRadius *       TMath::Sin((i+1)
3090                           * LayLadderAnglePosition*TMath::DegToRad()),0.,
3091                             new TGeoRotation(LadderRotName,(i+1)
3092                           * LayLadderAnglePosition-90,0.,0.));
3093     LadderHMatrix[i] = new TGeoHMatrix((*LadderCombiTrans[i])
3094                           * (*ITSCenterCombiTrans));
3095     Layer->AddNode(Ladder,i+1,LadderHMatrix[i]);
3096   }
3097   return Layer;
3098 }
3099 ////////////////////////////////////////////////////////////////////////////////
3100 void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
3101 ////////////////////////////////////////////////////////////////////////////////
3102 // Insert the layer 5 in the mother volume.
3103 ////////////////////////////////////////////////////////////////////////////////
3104         if(! moth){
3105                 cout << "Error::AliITSv11GeometrySSD: Can't insert layer5, mother is null!"<< endl;
3106                 return;
3107         }
3108         fMotherVol = moth;
3109         moth->AddNode(GetLayer(5),1,0);
3110 }
3111 ////////////////////////////////////////////////////////////////////////////////
3112 void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
3113 ////////////////////////////////////////////////////////////////////////////////
3114 // Insert the layer 6 in the mother volume.
3115 ////////////////////////////////////////////////////////////////////////////////
3116         if(! moth){
3117                 cout << "Error::AliITSv11GeometrySSD: Can't insert layer6, mother is null!"<< endl;
3118                 return;
3119         }
3120         fMotherVol = moth;
3121         moth->AddNode(GetLayer(6),1,0);
3122 }
3123 ////////////////////////////////////////////////////////////////////////////////
3124 TGeoArb8* AliITSv11GeometrySSD::GetTrapezoidShape(TVector3* vertexpos[],
3125                                                         Double_t* width, Double_t height, char* shapename){
3126 ////////////////////////////////////////////////////////////////////////////////
3127   const Int_t VertexNumber = 4;
3128   const Int_t TransVectNumber = 2;
3129   TVector3* Vertex[VertexNumber];
3130   TVector3* TransVector[2];
3131   for(Int_t i=0; i<TransVectNumber; i++)
3132                                                                         TransVector[i] = new TVector3(0.,width[i]);
3133 ////////////////////////////////////////////////////////////////////////////////
3134   //Setting the vertices
3135 ////////////////////////////////////////////////////////////////////////////////
3136   Vertex[0] = new TVector3(*vertexpos[0]);
3137   Vertex[1] = new TVector3(*vertexpos[1]);
3138   Vertex[2] = new TVector3(*Vertex[1]+*TransVector[1]);
3139   Vertex[3] = new TVector3(*Vertex[0]+*TransVector[0]);
3140   TGeoArb8* TrapezoidShape = new TGeoArb8(shapename,0.5*height);
3141   for(Int_t i=0; i<2*VertexNumber; i++)
3142         TrapezoidShape->SetVertex(i,Vertex[(i<VertexNumber ? i : i-VertexNumber)]->X(),
3143                                                                 Vertex[(i<VertexNumber ? i : i-VertexNumber)]->Y());
3144   return TrapezoidShape;
3145 }
3146 ////////////////////////////////////////////////////////////////////////////////
3147 TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
3148                                                                         Double_t height, char* shapename, Int_t isign){
3149   const Int_t VertexNumber = 8;
3150   const Int_t TransVectNumber = 2;
3151   TVector3* Vertex[VertexNumber];
3152   TVector3* TransVector[2];
3153   for(Int_t i=0; i<TransVectNumber; i++) TransVector[i] = new TVector3(0.,width[i]);
3154 ////////////////////////////////////////////////////////////////////////////////
3155   //Setting the vertices for TGeoArb8
3156 ////////////////////////////////////////////////////////////////////////////////
3157   Vertex[0] = new TVector3(*vertexpos[0]);
3158   Vertex[1] = new TVector3(*vertexpos[1]);
3159   Vertex[2] = new TVector3(*Vertex[1]+isign*(*TransVector[0]));
3160   Vertex[3] = new TVector3(*Vertex[0]+isign*(*TransVector[0]));
3161   Vertex[4] = new TVector3(*vertexpos[2]);
3162   Vertex[5] = new TVector3(*vertexpos[3]);
3163   Vertex[6] = new TVector3(*Vertex[5]+isign*(*TransVector[1]));
3164   Vertex[7] = new TVector3(*Vertex[4]+isign*(*TransVector[1]));
3165 ////////////////////////////////////////////////////////////////////////////////
3166   TGeoArb8* ArbShape = new TGeoArb8(shapename,0.5*height);
3167   for(Int_t i = 0; i<VertexNumber;i++)
3168                                                         ArbShape->SetVertex(i,Vertex[i]->X(),Vertex[i]->Y());
3169   return ArbShape;
3170 }
3171 ////////////////////////////////////////////////////////////////////////////////
3172 TGeoArb8* AliITSv11GeometrySSD::GetTriangleShape(TVector3* vertexpos[],
3173                                                                                           Double_t height, char* shapename){
3174 ////////////////////////////////////////////////////////////////////////////////
3175   const Int_t VertexNumber = 4;
3176   TVector3* Vertex[VertexNumber];
3177 //////////////////////////////////////
3178   //Setting the vertices for TGeoArb8
3179   ////////////////////////////////////
3180   for(Int_t i = 0; i<VertexNumber; i++)
3181   Vertex[i] = new TVector3(i!=VertexNumber-1?*vertexpos[i]:*Vertex[VertexNumber-1-i]);
3182   TGeoArb8* TriangleShape = new TGeoArb8(shapename,0.5*height);
3183   for(Int_t i = 0; i<2*VertexNumber; i++)
3184         TriangleShape->SetVertex(i,Vertex[(i < VertexNumber ? i: i-VertexNumber)]->X(),
3185                                                            Vertex[(i < VertexNumber ? i : i-VertexNumber)]->Y());
3186   return TriangleShape;
3187 }
3188 ////////////////////////////////////////////////////////////////////////////////
3189 TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* Vector,Double_t* Param){
3190 ////////////////////////////////////////////////////////////////////////////////
3191   TVector3* n = new TVector3(Param[0],Param[1],Param[2]);
3192   Double_t D = ((*Vector)*(*n)+Param[3])/n->Mag2();
3193   TVector3* ReflectedVector = new TVector3(*Vector-2*D*(*n));
3194   return ReflectedVector;
3195 }
3196 ////////////////////////////////////////////////////////////////////////////////
3197 TGeoCombiTrans* AliITSv11GeometrySSD::AddTranslationToCombiTrans(TGeoCombiTrans* ct,
3198                                                        Double_t dx,
3199                                                        Double_t dy,
3200                                                        Double_t dz) const{
3201   TGeoCombiTrans* CombiTrans = new TGeoCombiTrans(*ct);
3202   // Add a dx,dy,dz translation to the initial TGeoCombiTrans
3203   const Double_t *vect = CombiTrans->GetTranslation();
3204   Double_t newVect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
3205   CombiTrans->SetTranslation(newVect);
3206   return CombiTrans;
3207 }
3208 ////////////////////////////////////////////////////////////////////////////////
3209 //To be interfaced with AliRoot Materials file
3210 ////////////////////////////////////////////////////////////////////////////////
3211 TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
3212   char ch[30];
3213   sprintf(ch, "ITS_%s",mediumName);
3214   TGeoMedium* medium =  gGeoManager->GetMedium(ch);
3215   if (! medium)
3216     printf("Error(AliITSv11GeometrySSD)::medium %s not found !\n", mediumName);
3217   return medium;
3218 }
3219 ////////////////////////////////////////////////////////////////////////////////
3220 //To be interfaced with AliRoot Materials file
3221 ////////////////////////////////////////////////////////////////////////////////
3222 /*void AliITSv11GeometrySSD::CreateMaterials(){
3223 ///////////////////////////////////
3224 // This part has to be modified
3225 ///////////////////////////////////
3226 //  Float_t ifield =  2.000;
3227 //  Float_t fieldm = 10.000;
3228 //    Int_t   ifield = gAlice->Field()->Integ();
3229 //    Float_t fieldm = gAlice->Field()->Max();
3230   ///////////////////////////////////
3231   // Silicon for Sensor
3232   ///////////////////////////////////
3233   Int_t SINumber = 0;
3234   TGeoMaterial* SiMaterial = new TGeoMaterial("SiMaterial");
3235   TGeoMedium* Silicon = new TGeoMedium("Silicon",SINumber,SiMaterial);
3236   fgkSSDSensorMedium = Silicon;
3237   ///////////////////////////////////
3238   // Silicon Mixture for Sensor
3239   ///////////////////////////////////
3240   Int_t SiMixtureNumber = 1;
3241   TGeoMaterial* SiMixtureMaterial = new TGeoMaterial("SiMixtureMaterial");
3242   TGeoMedium* SiliconMixture = new TGeoMedium("SiliconMixture",SiMixtureNumber,SiMixtureMaterial);
3243   fgkSSDChipMedium = SiliconMixture;
3244   ///////////////////////////////////
3245   // Stiffener Components Materials
3246   ///////////////////////////////////
3247   Int_t K1100Number = 2;
3248   TGeoMaterial* K1100Material = new TGeoMaterial("K1100Material");
3249   TGeoMedium* K1100 = new TGeoMedium("K1100",K1100Number,K1100Material);
3250   fgkSSDStiffenerMedium = K1100;
3251   ///////////////////////////
3252   // Stiffener Connectors
3253   ///////////////////////////
3254   Int_t SnMaterialNumber = 3;
3255   TGeoMaterial* SnMaterial = new TGeoMaterial("SnMaterial");
3256   TGeoMedium* SnMedium = new TGeoMedium("SnMedium",SnMaterialNumber,
3257                                                 SnMaterial);
3258   fgkSSDStiffenerConnectorMedium = SnMedium;
3259   ////////////////////////////////
3260   // Stiffener 0603-1812 Capacitor
3261   ////////////////////////////////
3262   Int_t Al2O3Number = 4;
3263   TGeoMaterial* Al2O3Material = new TGeoMaterial("Al2O3Material");
3264   TGeoMedium* Al2O3Medium = new TGeoMedium("Al2O3Medium",
3265                                                 Al2O3Number,
3266                                                 Al2O3Material);
3267   fgkSSDStiffener0603CapacitorMedium = Al2O3Medium;
3268   fgkSSDStiffener1812CapacitorMedium = Al2O3Medium;
3269   ///////////////////////////
3270   // Stiffener Hybrid Wire
3271   ///////////////////////////
3272   Int_t CuHybridWireNumber = 5;
3273   TGeoMaterial* CuHybridWireMaterial = new TGeoMaterial("CuHybridWireMaterial");
3274   TGeoMedium* CuHybridWireMedium = new TGeoMedium("CuHybridWireMedium",
3275                                                 CuHybridWireNumber,
3276                                                 CuHybridWireMaterial);
3277   fgkSSDStiffenerHybridWireMedium = CuHybridWireMedium;
3278   ///////////////////////////
3279   // Al for Cooling Block
3280   ///////////////////////////
3281   Int_t AlCoolBlockNumber = 6;
3282   TGeoMaterial* AlCoolBlockMaterial = new TGeoMaterial("AlCoolBlockMaterial");
3283   TGeoMedium* AlCoolBlockMedium = new TGeoMedium("AlCoolBlockMedium",
3284                                                 AlCoolBlockNumber,
3285                                                 AlCoolBlockMaterial);
3286   fgkSSDAlCoolBlockMedium = AlCoolBlockMedium;
3287   //////////////////////////////////////////////////////
3288   // Kapton and Al for Chip Cable Flex and Ladder Cables
3289   //////////////////////////////////////////////////////
3290   Int_t KaptonBlockNumber = 7;
3291   TGeoMaterial* KaptonMaterial = new TGeoMaterial("KaptonMaterial");
3292   TGeoMedium* KaptonMedium = new TGeoMedium("KaptonMedium",
3293                                                 KaptonBlockNumber,
3294                                                 KaptonMaterial);
3295   Int_t AlTraceBlockNumber = 8;
3296   TGeoMaterial* AlTraceMaterial = new TGeoMaterial("AlTraceMaterial");
3297   TGeoMedium* AlTraceMedium = new TGeoMedium("AlTraceMedium",
3298                                                 AlTraceBlockNumber,
3299                                                 AlTraceMaterial);
3300   fgkSSDKaptonChipCableMedium = KaptonMedium;
3301   fgkSSDAlTraceChipCableMedium = AlTraceMedium;
3302   fgkSSDKaptonFlexMedium = KaptonMedium;
3303   fgkSSDAlTraceFlexMedium = AlTraceMedium;
3304   fgkSSDKaptonLadderCableMedium = KaptonMedium;
3305   fgkSSDAlTraceLadderCableMedium = AlTraceMedium;
3306   /////////////////////////////////////////////////////////////////
3307   // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
3308   //////////////////////////////////////////////////////////////////
3309   Int_t M55JNumber = 9;
3310   TGeoMaterial* M55JMaterial = new TGeoMaterial("M55JMaterial");
3311   TGeoMedium* M55JMedium = new TGeoMedium("M55JMedium",M55JNumber,
3312                                            M55JMaterial);
3313   fgkSSDCarbonFiberMedium = M55JMedium;
3314   fgkSSDMountingBlockMedium = M55JMedium;
3315   /////////////////////////////////////////////////////////////////
3316   // G10 for Detector Leg, TubeHolder
3317   //////////////////////////////////////////////////////////////////
3318   Int_t G10Number = 10;
3319   TGeoMaterial* G10Material = new TGeoMaterial("G10Material");
3320   TGeoMedium* G10Medium = new TGeoMedium("G10Medium",G10Number,
3321                                            G10Material);
3322   fgkSSDTubeHolderMedium = G10Medium;
3323   fgkSSDSensorSupportMedium = G10Medium;
3324   /////////////////////////////////////////////////////////////////
3325   // Water and Phynox for Cooling Tube
3326   //////////////////////////////////////////////////////////////////
3327   Int_t WaterNumber = 11;
3328   TGeoMaterial* WaterMaterial = new TGeoMaterial("WaterMaterial");
3329   TGeoMedium* WaterMedium = new TGeoMedium("WaterMedium",WaterNumber,
3330                                            WaterMaterial);
3331   fgkSSDCoolingTubeWater = WaterMedium;
3332   Int_t PhynoxNumber = 12;
3333   TGeoMaterial* PhynoxMaterial = new TGeoMaterial("PhynoxMaterial");
3334   TGeoMedium* PhynoxMedium = new TGeoMedium("PhynoxMedium",PhynoxNumber,
3335                                            PhynoxMaterial);
3336   fgkSSDCoolingTubePhynox = PhynoxMedium;
3337 }
3338 */
3339 void AliITSv11GeometrySSD::CreateMaterials(){
3340 ///////////////////////////////////
3341 // This part has to be modified
3342 ///////////////////////////////////
3343   ///////////////////////////////////
3344   // Silicon for Sensor
3345   ///////////////////////////////////
3346   fgkSSDSensorMedium = GetMedium("Si");
3347   ///////////////////////////////////
3348   // Silicon Mixture for Sensor
3349   ///////////////////////////////////
3350   fgkSSDChipMedium = GetMedium("SPD SI CHIP$");
3351   fgkSSDChipGlueMedium = GetMedium("EPOXY$");
3352   ///////////////////////////////////
3353   // Stiffener Components Materials
3354   ///////////////////////////////////
3355   fgkSSDStiffenerMedium = GetMedium("ITSsddCarbonM55J");
3356   ///////////////////////////
3357   // Stiffener Connectors
3358   ///////////////////////////
3359   fgkSSDStiffenerConnectorMedium = GetMedium("COPPER");
3360   ////////////////////////////////
3361   // Stiffener 0603-1812 Capacitor
3362   ////////////////////////////////
3363   fgkSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3");
3364   fgkSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3");
3365   ///////////////////////////
3366   // Stiffener Hybrid Wire
3367   ///////////////////////////
3368   fgkSSDStiffenerHybridWireMedium = GetMedium("COPPER");
3369   ///////////////////////////
3370   // Al for Cooling Block
3371   ///////////////////////////
3372   fgkSSDAlCoolBlockMedium = GetMedium("ITSal");
3373   //////////////////////////////////////////////////////
3374   // Kapton and Al for Chip Cable Flex and Ladder Cables
3375   //////////////////////////////////////////////////////
3376   fgkSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)");
3377   fgkSSDAlTraceChipCableMedium = GetMedium("ITSal");
3378   fgkSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)");
3379   fgkSSDAlTraceFlexMedium = GetMedium("ITSal");
3380   fgkSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)");
3381   fgkSSDAlTraceLadderCableMedium = GetMedium("ITSal");
3382   /////////////////////////////////////////////////////////////////
3383   // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
3384   //////////////////////////////////////////////////////////////////
3385   fgkSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
3386   /////////////////////////////////////////////////////////////////
3387   // G10 for Detector Leg, TubeHolder
3388   //////////////////////////////////////////////////////////////////
3389   fgkSSDTubeHolderMedium = GetMedium("G10FR4$");
3390   fgkSSDSensorSupportMedium = GetMedium("G10FR4$");
3391   fgkSSDMountingBlockMedium = GetMedium("G10FR4$");
3392   fgkSSDMountingBlockMedium = GetMedium("G10FR4$");
3393   /////////////////////////////////////////////////////////////////
3394   // Water and Phynox for Cooling Tube
3395   //////////////////////////////////////////////////////////////////
3396   fgkSSDCoolingTubeWater = GetMedium("WATER");
3397   fgkSSDCoolingTubePhynox = GetMedium("INOX$");
3398 }
3399 /////////////////////////////////////////////////////////////////////