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 /* $Id$ */
  17
  18 //*************************************************************************
  19 // SSD geometry, based on ROOT geometrical modeler
  20 //
  21 // Enrico Cattaruzza                                    ecattar@ts.infn.it
  22 //*************************************************************************
  23 #include "TMath.h"
  24 #include "TGeoVolume.h"
  25 #include "TGeoMatrix.h"
  26 #include <TGeoManager.h>
  27 #include "TVector3.h"
  28 #include "TGeoArb8.h"
  29 #include "TList.h"
  30 #include "TGeoMatrix.h"
  31 #include "TGeoCompositeShape.h"
  32 #include "TGeoTube.h"
  33 #include "TGeoBBox.h"
  34 #include "TGeoXtru.h"
  35 #include "TGeoTorus.h"
  36 #include "TGeoPgon.h"
  37 #include "TRotation.h"
  38 #include "AliITSv11GeometrySSD.h"
  39 /////////////////////////////////////////////////////////////////////////////////
  40 // Names of the Sensitive Volumes of Layer 5 and Layer 6
  41 /////////////////////////////////////////////////////////////////////////////////
  42 const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName5 = "ITSssdSensitivL5";
  43 const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName6 = "ITSssdSensitivL6";
  44 /////////////////////////////////////////////////////////////////////////////////
  45 //Parameters for SSD Geometry
  46 /////////////////////////////////////////////////////////////////////////////////
  47 // Variable for Vertical Disalignement of Modules
  48 /////////////////////////////////////////////////////////////////////////////////
  49 const Double_t AliITSv11GeometrySSD::fgkSSDModuleVerticalDisalignment = 0.2*fgkmm;
  50 /////////////////////////////////////////////////////////////////////////////////
  51 // Layer5 (lengths are in mm and angles in degrees)
  52 /////////////////////////////////////////////////////////////////////////////////
  53 const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength      = 950.7*fgkmm;
  54 const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber        =  22;
  55 const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber         =  34;
  56 const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin         = 378.0*fgkmm;
  57 const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax         = 384.0*fgkmm;
  58 const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition    = 467.85*fgkmm;
  59 /////////////////////////////////////////////////////////////////////////////////
  60 // Layer6 (lengths are in mm and angles in degrees)
  61 /////////////////////////////////////////////////////////////////////////////////
  62 const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength      = 1068.0*fgkmm;
  63 const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber        =   25;
  64 const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber         =   38;
  65 const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin         =  428.0*fgkmm;
  66 const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax         =  434.0*fgkmm;
  67 const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition    = 526.50*fgkmm;
  68 /////////////////////////////////////////////////////////////////////////////////
  69 // SSD Chips and Hybrid (lengths are in mm and angles in degrees)
  70 /////////////////////////////////////////////////////////////////////////////////
  71 const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber               =   6;
  72 const Double_t AliITSv11GeometrySSD::fgkSSDChipLength            =  11.100*fgkmm;
  73 const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth             =   3.850*fgkmm;
  74 const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight            =   0.180*fgkmm;
  75 const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength  =   1.000*fgkmm;
  76 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength     = fgkSSDChipLength;
  77 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth      =  fgkSSDChipWidth;
  78 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight        =   0.030*fgkmm;
  79 /////////////////////////////////////////////////////////////////////////////////
  80 // Stiffener (lengths are in mm and angles in degrees)
  81 /////////////////////////////////////////////////////////////////////////////////
  82 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength       =  73.000*fgkmm;
  83 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth        =   6.500*fgkmm;
  84 //const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight       =   3.315;
  85 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight       =   0.315*fgkmm;
  86 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist   =   2.500*fgkmm;
  87 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length   = 1.600*fgkmm;
  88 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width    =   0.870*fgkmm;
  89 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height   =   0.800*fgkmm;
  90 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length   =   4.600*fgkmm;
  91 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width    =   3.400*fgkmm;
  92 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height   =   0.700*fgkmm; // multiplied by 0.5
  93 const Double_t AliITSv11GeometrySSD::fgkSSDWireLength            =  30.000*fgkmm;
  94 const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius            =   0.185*fgkmm;
  95 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2]  =
  96                                                                                                            {44.32*fgkmm, 0.33*fgkmm};
  97 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation   =        0.44*fgkmm;
  98 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength       =        2.16*fgkmm;
  99 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth        =        3.60*fgkmm;
 100 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight       =
 101                                                                                                           0.25*fgkSSDStiffenerHeight;
 102 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight     =       0.030*fgkmm;
 103 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight     =   0.002*fgkmm;
 104 /////////////////////////////////////////////////////////////////////////////////
 105 // Cooling Block (lengths are in mm and angles in degrees)
 106 /////////////////////////////////////////////////////////////////////////////////
 107 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength    =   3.000*fgkmm;
 108 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth     =   4.000*fgkmm;
 109 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
 110                                                                                  {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
 111 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
 112                                                                                                           {1.000*fgkmm, 0.120*fgkmm};
 113 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
 114                                                                                                           {1.900*fgkmm, 0.400*fgkmm};
 115 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter    =
 116                                                                                                                                          1.500*fgkmm;
 117 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight    =
 118                                                                                                                                          0.300*fgkmm;
 119 /////////////////////////////////////////////////////////////////////////////////
 120 // SSD Sensor (lengths are in mm and angles in degrees)
 121 /////////////////////////////////////////////////////////////////////////////////
 122 const char*  AliITSv11GeometrySSD::fgkSSDSensitiveVolName       =
 123                                                                                                                  "SSDSensorSensitiveVol";
 124 const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength          =  42.000*fgkmm;
 125 const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight          =   0.300*fgkmm;
 126 const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth           =  75.000*fgkmm;
 127 const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap         =
 128                                                                                                    fgkSSDSensorLength-39.1*fgkmm;
 129 const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength    = 1.*fgkmm;
 130 const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth     = 1.*fgkmm;
 131 /////////////////////////////////////////////////////////////////////////////////
 132 // Flex (lengths are in mm and angles in degrees)
 133 /////////////////////////////////////////////////////////////////////////////////
 134 const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength       =  106.000*fgkmm;
 135 const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4]        =
 136                         {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
 137                                  + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
 138                          0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
 139                                  + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)
 140                                                                            - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm};
 141 const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2]         =
 142                                                                                                    {  9.340*fgkmm,  5.380*fgkmm};
 143 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2]        =
 144                                                                                                    {  0.030*fgkmm,  0.020*fgkmm};
 145 const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle            =   30.000;
 146 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength       =    1.430*fgkmm;
 147 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth        =    3.000*fgkmm;
 148 const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
 149                          {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
 150 const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
 151                                                                                    {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
 152 /////////////////////////////////////////////////////////////////////////////////
 153 // SSD Ladder Cable (lengths are in mm and angles in degrees)
 154 /////////////////////////////////////////////////////////////////////////////////
 155 const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth     =     23.5*fgkmm;
 156 /////////////////////////////////////////////////////////////////////////////////
 157 // SSD Module (lengths are in mm and angles in degrees)
 158 /////////////////////////////////////////////////////////////////////////////////
 159 const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2]  =
 160                                                                                                          { 1.000*fgkmm, 3.900*fgkmm};
 161 const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
 162                                                                                                                                         45.600*fgkmm;
 163 const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor  =
 164                                                                                                                                          5.075*fgkmm;
 165 /////////////////////////////////////////////////////////////////////////////////
 166 // Sensor Support (lengths are in mm and angles in degrees)
 167 /////////////////////////////////////////////////////////////////////////////////
 168 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength                     =
 169                                                                                                                                          5.800*fgkmm;
 170 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth          =
 171                                                                                                                                          2.000*fgkmm;
 172 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2]      =
 173                                                                                                      { 4.620*fgkmm, 5.180*fgkmm};
 174 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2]   =
 175                                                                                                          { 0.450*fgkmm, 0.450*fgkmm};
 176 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition
 177                                                                 = 0.5 * (fgkSSDModuleSensorSupportDistance
 178                                                             +  fgkSSDSensorSideSupportThickness[0])
 179                                                                 -  fgkSSDSensorSideSupportLength;
 180 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength       =
 181                                                                                                                                     5.250*fgkmm;
 182 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth        =
 183                                                                                                                                         1.680*fgkmm;
 184 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]
 185                                                                   = {fgkSSDSensorSideSupportHeight[0]
 186                                                                   +  fgkSSDSensorSideSupportThickness[0],
 187                                                                          fgkSSDSensorSideSupportHeight[1]
 188                                                                   +  fgkSSDSensorSideSupportThickness[1]};
 189 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2]
 190                                                                   =  {fgkSSDSensorSideSupportThickness[0],
 191                                                                           fgkSSDSensorSideSupportThickness[1]};
 192 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition     =
 193                                                                                                                                    19.000*fgkmm;
 194 /////////////////////////////////////////////////////////////////////////////////
 195 // Chip Cables (lengths are in mm and angles in degrees)
 196 /////////////////////////////////////////////////////////////////////////////////
 197 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2]   =
 198                                   {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
 199 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4]   =
 200                                   {  0.014*fgkmm,  0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
 201                                                                   -  (fgkSSDSensorSideSupportHeight[1]
 202                                                                   -   fgkSSDSensorSideSupportHeight[0])
 203                                                                   -   fgkSSDCoolingBlockHoleCenter
 204                                                                   -   fgkSSDStiffenerHeight
 205                                                                   -   fgkSSDChipHeight-fgkSSDSensorHeight,
 206                                                                           fgkSSDModuleCoolingBlockToSensor
 207                                                                   -   fgkSSDCoolingBlockHoleCenter
 208                                                                   -       fgkSSDStiffenerHeight
 209                                                                   -   fgkSSDChipHeight-fgkSSDSensorHeight};
 210 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3]    =
 211                                             { 11.000*fgkmm,  0.800*fgkmm,  0.600*fgkmm};
 212 /////////////////////////////////////////////////////////////////////////////////
 213 // Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
 214 /////////////////////////////////////////////////////////////////////////////////
 215 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          =
 216                                                                                                                                         3.820*fgkmm;
 217 //const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          =
 218 //                                                                                                                                         3.780;
 219 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth           =
 220                                                                                  fgkSSDSensorLength-fgkSSDSensorOverlap;
 221 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2]         =
 222                                                                                                         {  0.86*fgkmm,  0.30*fgkmm};
 223 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2]        =
 224                                                                                                                                 { 30.00, 90.00};
 225 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
 226                                                                                                                                          1.78*fgkmm;
 227 /////////////////////////////////////////////////////////////////////////////////
 228 //Carbon Fiber Parameters (lengths are in mm and angles in degrees)
 229 /////////////////////////////////////////////////////////////////////////////////
 230 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength
 231                                                                    = fgkSSDModuleSensorSupportDistance
 232                                                                    - 2. * fgkCarbonFiberJunctionToSensorSupport;
 233 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
 234 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2]   =
 235                                                                                                   {  0.751*fgkmm,  0.482*fgkmm};
 236 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength  =
 237                                                                                                                                         1.630*fgkmm;
 238 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth =   0.950*fgkmm;
 239 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength
 240                                                                         = fgkCarbonFiberTriangleLength
 241                                                                         - 0.5*fgkCarbonFiberSupportTopEdgeDist[1]
 242                                                                         / TMath::Cos(fgkCarbonFiberTriangleAngle
 243                                                                         * TMath::DegToRad());
 244 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength
 245                                                                         = 0.5*(fgkCarbonFiberJunctionWidth
 246                                                                         - fgkCarbonFiberSupportWidth)
 247                                                                         - fgkCarbonFiberSupportTopEdgeDist[0]
 248                                                                         - fgkCarbonFiberSupportWidth;
 249 /////////////////////////////////////////////////////////////////////////////////
 250 // Carbon Fiber Lower Support Parameters (lengths are in mm)
 251 /////////////////////////////////////////////////////////////////////////////////
 252 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
 253                                                                                                                                           =  0.950*fgkmm;
 254 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
 255                                                                                                                                           =  1.600*fgkmm;
 256 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
 257                                                                                                                                           =  0.830*fgkmm;
 258 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
 259                                                                                           = 0.5*fgkCarbonFiberSupportWidth;
 260 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
 261                                                                         = fgkCarbonFiberJunctionWidth
 262                                                                         - 2. * (fgkCarbonFiberLowerSupportWidth
 263                                                                         + fgkCarbonFiberLowerSupportVolumeSeparation);
 264 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
 265                                                                         = {fgkCarbonFiberLowerSupportWidth
 266                                                                         +  fgkCarbonFiberLowerSupportVolumeSeparation,
 267                                                                            fgkCarbonFiberLowerSupportWidth
 268                                                                         +  fgkCarbonFiberLowerSupportVolumeSeparation
 269                                                                         +  fgkCarbonFiberLowerSupportTransverseWidth};
 270 /////////////////////////////////////////////////////////////////////////////////
 271 // End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
 272 /////////////////////////////////////////////////////////////////////////////////
 273 const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
 274                                                            {0.5 * (fgkSSDLay5LadderLength
 275                                                                         -  fgkSSDLay5SensorsNumber
 276                                                                         *  fgkCarbonFiberJunctionWidth
 277                                                                         -  fgkCarbonFiberLowerSupportWidth),
 278                                                                 0.5 * (fgkSSDLay5LadderLength
 279                                                                         -  fgkSSDLay5SensorsNumber
 280                                                                         *  fgkCarbonFiberJunctionWidth
 281                                                                         +  fgkCarbonFiberLowerSupportWidth)};
 282 const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
 283                                                 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
 284                                                  fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
 285 const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
 286                                                 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
 287                                                  fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
 288 const Double_t AliITSv11GeometrySSD::fgkendladdercoolingsupportdistance[3] =
 289                                                                                         {15.0*fgkmm, 13.5*fgkmm, 14.5*fgkmm};
 290 /////////////////////////////////////////////////////////////////////////////////
 291 // Cooling Tube Support (lengths are in mm and angles in degrees)
 292 /////////////////////////////////////////////////////////////////////////////////
 293 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax      =  1.45*fgkmm;
 294 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
 295                                                                                           = fgkSSDCoolingBlockHoleRadius[0];
 296 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength    =  8.55*fgkmm;
 297 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight    =  0.85*fgkmm;
 298 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth     =  2.00*fgkmm;
 299 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation    =
 300                                         fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
 301 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber =
 302                                                                                                                                           11.70*fgkmm;
 303 /////////////////////////////////////////////////////////////////////////////////
 304 // Cooling Tube (lengths are in mm and angles in degrees)
 305 /////////////////////////////////////////////////////////////////////////////////
 306 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
 307 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin =  0.96*fgkmm;
 308 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
 309                                                                                                         fgkCarbonFiberJunctionWidth;
 310 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
 311                                                                          fgkSSDModuleSensorSupportDistance
 312                                                                   +      fgkSSDCoolingBlockLength;
 313 const Double_t AliITSv11GeometrySSD::fgkMountingBlockToSensorSupport = 30.7*fgkmm;
 314 /////////////////////////////////////////////////////////////////////////////////
 315 // SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
 316 /////////////////////////////////////////////////////////////////////////////////
 317 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3]            =
 318                                                                                    { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
 319 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4]            =
 320                                                            {  4.0*fgkmm,  8.0*fgkmm,  5.0*fgkmm,  0.2*fgkmm};
 321 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth                =
 322                                                                                                                                           20.0*fgkmm;
 323 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle   =
 324                                                                                                                                                     40.0;
 325 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight  =
 326                    0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
 327 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
 328                                                                                                                                           2.5*fgkmm;
 329 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2]    =
 330                                                                                                           { 56.0*fgkmm, 12.0*fgkmm};
 331 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2]     =
 332                                                                                                       {  5.0*fgkmm,  2.9*fgkmm};
 333 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius           =
 334                                                                                                                                           1.0*fgkmm;
 335 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge        =
 336                                                                                                                                           6.0*fgkmm;
 337 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth      =
 338                                                                                                                                           4.0*fgkmm;
 339 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2]   =
 340                                                           {  1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
 341 /////////////////////////////////////////////////////////////////////////////////
 342 // SSD Mounting Block Clip Parameters (lengths are in mm and angles in degrees)
 343 /////////////////////////////////////////////////////////////////////////////////
 344 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipLength        = 15.1*fgkmm;
 345 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipThickness     = 0.3*fgkmm;
 346 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewRadius   = 1.6*fgkmm;
 347 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewPosition = 4.0*fgkmm;
 348 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibWidth         = 9.0*fgkmm;
 349 /////////////////////////////////////////////////////////////////////////////////
 350 // SSD Mounting Block Support Parameters (lengths are in mm and angles in degrees)
 351 /////////////////////////////////////////////////////////////////////////////////
 352 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportWidth[2] = {9.5*fgkmm,10.0*fgkmm};
 353 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportDownHeight   = 4.0*fgkmm;
 354 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDLay5RadiusMin
 355                                                                                                   -  fgkSSDMountingBlockHeight[1]
 356                                                                                                   +  0.5*fgkCoolingTubeSupportHeight
 357                                                                                                   +      fgkSSDModuleCoolingBlockToSensor
 358                                                                                                   +  fgkSSDModuleVerticalDisalignment
 359                                                                                                   -      fgkMountingBlockSupportDownHeight,
 360                                                                                                          fgkSSDLay6RadiusMin
 361                                                                                                   -  fgkSSDMountingBlockHeight[1]
 362                                                                                                   +  0.5*fgkCoolingTubeSupportHeight
 363                                                                                                   +      fgkSSDModuleCoolingBlockToSensor
 364                                                                                                   +  fgkSSDModuleVerticalDisalignment
 365                                                                                                   -      fgkMountingBlockSupportDownHeight};
 366 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax
 367                                                                                                     -  fgkSSDMountingBlockHeight[1]
 368                                                                                                     +  0.5*fgkCoolingTubeSupportHeight
 369                                                                                                     +  fgkSSDModuleCoolingBlockToSensor
 370                                                                                                         +  fgkSSDModuleVerticalDisalignment
 371                                                                                                         -  fgkMountingBlockSupportRadius[0],
 372                                                                                                            fgkSSDLay6RadiusMax
 373                                                                                                     -  fgkSSDMountingBlockHeight[1]
 374                                                                                                     +  0.5*fgkCoolingTubeSupportHeight
 375                                                                                                     +  fgkSSDModuleCoolingBlockToSensor
 376                                                                                                         +  fgkSSDModuleVerticalDisalignment
 377                                                                                                         -  fgkMountingBlockSupportRadius[1]};
 378 const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeigth = 10.0*fgkmm; // To be verified
 379 const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
 380 const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
 381 /////////////////////////////////////////////////////////////////////////////////
 382 // SSD End Cap Cover Plate Parameters (lengths are in mm and angles in degrees)
 383 /////////////////////////////////////////////////////////////////////////////////
 384 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleRadius = 1.25*fgkmm;
 385 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateBigHoleRadius = 2.45*fgkmm;
 386 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateThickness = 0.5*fgkmm;
 387 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleSeparation[3] =
 388                                                                                                 {16.5*fgkmm,22.0*fgkmm,7.*fgkmm};
 389 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateLength[6] =
 390                                   {7.*fgkmm,55.*fgkmm,8.0*fgkmm,53.*fgkmm,61.0*fgkmm,25.5*fgkmm};
 391 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateWidth[3] =
 392                                                                                            {68.5*fgkmm,75.5*fgkmm,6.5*fgkmm};
 393 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMin = 0.750*fgkmm;
 394 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMax = 2.*fgkmm;
 395 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipLength = 10.4*fgkmm;
 396 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipWidth = 6.0*fgkmm;
 397 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipLength = 5.7*fgkmm;
 398 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipWidth = 5.0*fgkmm;
 399 /////////////////////////////////////////////////////////////////////////////////
 400 // SSD End Cap Kapton Foil Parameters (lengths are in mm and angles in degrees)
 401 /////////////////////////////////////////////////////////////////////////////////
 402 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilThickness = 0.4*fgkmm;
 403 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilLength = 68.0*fgkmm;
 404 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilWidth = 75.0*fgkmm;
 405 /////////////////////////////////////////////////////////////////////////////////
 406 // SSD End Cap Cooling Tube Parameters (lengths are in mm and angles in degrees)
 407 /////////////////////////////////////////////////////////////////////////////////
 408 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAxialRadius[2] =
 409                                                                                                                 {10.5*fgkmm,9.25*fgkmm};
 410 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMin = 1.3*fgkmm;
 411 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMax = 1.5*fgkmm;
 412 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAngle[5] =
 413                                                                                                         {182.3,177.9,84.4,70.0,35.0};
 414 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeLength[5] =
 415                                                                         {49.5*fgkmm,41.7*fgkmm,47.6*fgkmm,5.0*fgkmm};
 416 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeToCoverSide = 13.0*fgkmm;
 417 /////////////////////////////////////////////////////////////////////////////////
 418 // SSD End Cap Cover Side Parameters (lengths are in mm and angles in degrees)
 419 /////////////////////////////////////////////////////////////////////////////////
 420 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverLength[5] = {3.5*fgkmm,
 421                                                                           6.5*fgkmm,75.0*fgkmm,8.0*fgkmm,2.0*fgkmm};
 422 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverWidth[7] = {30.9*fgkmm,
 423                                                                           47.5*fgkmm,12.6*fgkmm,5.6*fgkmm,
 424                                                                           20.0*fgkmm,7.0*fgkmm,5.9*fgkmm};
 425 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm;
 426 /////////////////////////////////////////////////////////////////////////////////
 427 // SSD End Cap Cards Parameters (lengths are in mm and angles in degrees)
 428 /////////////////////////////////////////////////////////////////////////////////
 429 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] =
 430                                                                                                            {62.0*fgkmm,21.87*fgkmm};
 431 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] =
 432                                                                                                             {47.1*fgkmm,0.35*fgkmm};
 433 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness =
 434                                                                                                                                           1.0*fgkmm;
 435 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm;
 436 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerWidth[2] =
 437                                                                                                            {43.5*fgkmm, 0.70*fgkmm};
 438 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerThickness =
 439                                                                                                                                          0.15*fgkmm;
 440 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorThickness =
 441                                                                                                                                          19.0*fgkmm;
 442 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorLength[2] =
 443                                                                                                                  {4.80*fgkmm,1.1*fgkmm};
 444 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorWidth[2] =
 445                                                                                                                  {3.3*fgkmm,1.10*fgkmm};
 446 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorToLayer =
 447                                                                                                                                           2.1*fgkmm;
 448 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorLength[3] =
 449                                                                                                 {5.2*fgkmm,3.5*fgkmm,1.2*fgkmm};
 450 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorWidth[2] =
 451                                                                                                                  {1.9*fgkmm,0.15*fgkmm};
 452 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorThickness =
 453                                                                                                                                            19*fgkmm;
 454 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorDistance =
 455                                                                                                                                           1.0*fgkmm;
 456 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorToLayer =
 457                                                                                                                                           3.6*fgkmm;
 458 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionLength =
 459                                                                                                                                          61.0*fgkmm;
 460 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionThickness =
 461                                                                                                                                          5.97*fgkmm;
 462 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionWidth = 3.0*fgkmm;
 463 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBLength[7] =
 464                                                                                                 {3.1*fgkmm,68.0*fgkmm,3.6*fgkmm,
 465                                                                           1.9*fgkmm,2.5*fgkmm,14.2*fgkmm,1.5*fgkmm};
 466 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBWidth[5] =
 467                                                   {17.0*fgkmm,10.0*fgkmm,5.9*fgkmm,6.4*fgkmm,3.9*fgkmm};
 468 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBThickness =
 469                                                                                                                                           1.0*fgkmm;
 470 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceElectBoardCardBThickness
 471                                                                                                                                    = 0.15*fgkmm;
 472 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBJMDConnectorSeparation =
 473                                                                                                                                          20.0*fgkmm;
 474 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerLength = 68.0*fgkmm;
 475 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerWidth = 5.0*fgkmm;
 476 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerThickness = 5.0*fgkmm;
 477 const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMin = 1.25*fgkmm; // To Be Checked
 478 const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMax = 1.575*fgkmm; // To Be Checked
 479 /////////////////////////////////////////////////////////////////////////////////
 480 // SSD End Cap SupportLayer5/6 Side Parameters (lengths are in mm and angles in degrees)
 481 /////////////////////////////////////////////////////////////////////////////////
 482 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLength[2] = {70.424*fgkmm,72.919*fgkmm};
 483 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fgkmm,437.0*fgkmm};
 484 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {365.0*fgkmm,430.0*fgkmm};
 485 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm;
 486 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm};
 487 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 625.0*fgkmm;
 488 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
 489 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
 490 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
 491 /////////////////////////////////////////////////////////////////////////////////
 492 ClassImp(AliITSv11GeometrySSD)
 493 /////////////////////////////////////////////////////////////////////////////////
 494 AliITSv11GeometrySSD::AliITSv11GeometrySSD():
 495   AliITSv11Geometry(),
 496   fSSDChipMedium(),
 497   fSSDChipGlueMedium(),
 498   fSSDStiffenerMedium(),
 499   fSSDStiffenerConnectorMedium(),
 500   fSSDStiffener0603CapacitorMedium(),
 501   fSSDStiffener1812CapacitorMedium(),
 502   fSSDStiffenerHybridWireMedium(),
 503   fSSDKaptonFlexMedium(),
 504   fSSDAlTraceFlexMedium(),
 505   fSSDAlTraceLadderCableMedium(),
 506   fSSDKaptonLadderCableMedium(),
 507   fSSDKaptonChipCableMedium(),
 508   fSSDAlTraceChipCableMedium(),
 509   fSSDAlCoolBlockMedium(),
 510   fSSDSensorMedium(),
 511   fSSDSensorSupportMedium(),
 512   fSSDCarbonFiberMedium(),
 513   fSSDTubeHolderMedium(),
 514   fSSDCoolingTubeWater(),
 515   fSSDCoolingTubePhynox(),
 516   fSSDSupportRingAl(),
 517   fSSDMountingBlockMedium(),
 518   fSSDAir(),
 519   fCreateMaterials(kFALSE),
 520   fTransformationMatrices(kFALSE),
 521   fBasicObjects(kFALSE),
 522   fcarbonfiberjunction(),
 523   fcoolingtubesupport(),
 524   fhybridmatrix(),
 525   fssdcoolingblocksystem(),
 526   fcoolingblocksystematrix(),
 527   fssdstiffenerflex(),
 528   fssdendflex(),
 529   fendladdercoolingtubesupportmatrix(),
 530   fendladdermountingblock(),
 531   fendladdermountingblockclip(),
 532   fSSDSensor5(),
 533   fSSDSensor6(),
 534   fSSDLayer5(),
 535   fSSDLayer6(),
 536   fMotherVol(),
 537   fLay5LadderSupportRing(),
 538   fLay6LadderSupportRing(),
 539   fgkEndCapSupportSystem(),
 540   fColorCarbonFiber(4),
 541   fColorRyton(5),
 542   fColorPhynox(14),
 543   fColorSilicon(3),
 544   fColorAl(38),
 545   fColorKapton(6),
 546   fColorPolyhamide(5),
 547   fColorStiffener(9),
 548   fColorEpoxy(30),
 549   fColorWater(7),
 550   fColorG10(41)
 551 {
 552   ////////////////////////
 553   // Standard constructor
 554   ////////////////////////
 555 }
 556 /////////////////////////////////////////////////////////////////////////////////
 557 AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
 558   AliITSv11Geometry(s.GetDebug()),
 559   fSSDChipMedium(s.fSSDChipMedium),
 560   fSSDChipGlueMedium(s.fSSDChipGlueMedium),
 561   fSSDStiffenerMedium(s.fSSDStiffenerMedium),
 562   fSSDStiffenerConnectorMedium(s.fSSDStiffenerConnectorMedium),
 563   fSSDStiffener0603CapacitorMedium(s.fSSDStiffener0603CapacitorMedium),
 564   fSSDStiffener1812CapacitorMedium(s.fSSDStiffener1812CapacitorMedium),
 565   fSSDStiffenerHybridWireMedium(s.fSSDStiffenerHybridWireMedium),
 566   fSSDKaptonFlexMedium(s.fSSDKaptonFlexMedium),
 567   fSSDAlTraceFlexMedium(s.fSSDAlTraceFlexMedium),
 568   fSSDAlTraceLadderCableMedium(s.fSSDAlTraceLadderCableMedium),
 569   fSSDKaptonLadderCableMedium(s.fSSDKaptonLadderCableMedium),
 570   fSSDKaptonChipCableMedium(s.fSSDKaptonChipCableMedium),
 571   fSSDAlTraceChipCableMedium(s.fSSDAlTraceChipCableMedium),
 572   fSSDAlCoolBlockMedium(s.fSSDAlCoolBlockMedium),
 573   fSSDSensorMedium(s.fSSDSensorMedium),
 574   fSSDSensorSupportMedium(s.fSSDSensorSupportMedium),
 575   fSSDCarbonFiberMedium(s.fSSDCarbonFiberMedium),
 576   fSSDTubeHolderMedium(s.fSSDTubeHolderMedium),
 577   fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
 578   fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
 579   fSSDSupportRingAl(s.fSSDSupportRingAl),
 580   fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
 581   fSSDAir(s.fSSDAir),
 582   fCreateMaterials(s.fCreateMaterials),
 583   fTransformationMatrices(s.fTransformationMatrices),
 584   fBasicObjects(s.fBasicObjects),
 585   fcarbonfiberjunction(s.fcarbonfiberjunction),
 586   fcoolingtubesupport(s.fcoolingtubesupport),
 587   fhybridmatrix(s.fhybridmatrix),
 588   fssdcoolingblocksystem(s.fssdcoolingblocksystem),
 589   fcoolingblocksystematrix(s.fcoolingblocksystematrix),
 590   fssdstiffenerflex(s.fssdstiffenerflex),
 591   fssdendflex(s.fssdendflex),
 592   fendladdercoolingtubesupportmatrix(s.fendladdercoolingtubesupportmatrix),
 593   fendladdermountingblock(s.fendladdermountingblock),
 594   fendladdermountingblockclip(s.fendladdermountingblockclip),
 595   fSSDSensor5(s.fSSDSensor5),
 596   fSSDSensor6(s.fSSDSensor6),
 597   fSSDLayer5(s.fSSDLayer5),
 598   fSSDLayer6(s.fSSDLayer6),
 599   fMotherVol(s.fMotherVol),
 600   fLay5LadderSupportRing(s.fLay5LadderSupportRing),
 601   fLay6LadderSupportRing(s.fLay6LadderSupportRing),
 602   fgkEndCapSupportSystem(s.fgkEndCapSupportSystem),
 603   fColorCarbonFiber(s.fColorCarbonFiber),
 604   fColorRyton(s.fColorRyton),
 605   fColorPhynox(s.fColorPhynox),
 606   fColorSilicon(s.fColorSilicon),
 607   fColorAl(s.fColorAl),
 608   fColorKapton(s.fColorKapton),
 609   fColorPolyhamide(s.fColorPolyhamide),
 610   fColorStiffener(s.fColorStiffener),
 611   fColorEpoxy(s.fColorEpoxy),
 612   fColorWater(s.fColorWater),
 613   fColorG10(s.fColorG10)
 614 {
 615   ////////////////////////
 616   // Copy Constructor
 617   ////////////////////////
 618 }
 619 /////////////////////////////////////////////////////////////////////////////////
 620 AliITSv11GeometrySSD& AliITSv11GeometrySSD::
 621 operator=(const AliITSv11GeometrySSD &s){
 622   ////////////////////////
 623   // Assignment operator
 624   ////////////////////////
 625   this->~AliITSv11GeometrySSD();
 626   new(this) AliITSv11GeometrySSD(s);
 627   return *this;
 628 /*
 629   if(&s == this) return *this;
 630   fMotherVol = s.fMotherVol;
 631   return *this;
 632  */
 633 }
 634 ///////////////////////////////////////////////////////////////////////////////
 635 void AliITSv11GeometrySSD::CreateTransformationMatrices(){
 636   ///////////////////////////////////////////////////////////////////////
 637   // Method generating the trasformation matrix for the whole SSD Geometry
 638   ///////////////////////////////////////////////////////////////////////
 639   // Setting some variables for Carbon Fiber Supportmatrix creation
 640   //////////////////////////////////////////////////////////////////////
 641   Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
 642                                                                                    * CosD(fgkCarbonFiberJunctionAngle[0]);
 643   Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
 644                                                                  +      fgkCarbonFiberSupportTopEdgeDist[0]
 645                                                                  +      fgkCarbonFiberSupportWidth);
 646   Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
 647                                                                         * TanD(fgkCarbonFiberJunctionAngle[0]);
 648   TGeoRotation* carbonfiberot[3];
 649   for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
 650   carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
 651   carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
 652   carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
 653   Double_t transvector[3] = {fgkCarbonFiberTriangleLength
 654                                                   *  CosD(fgkCarbonFiberTriangleAngle),0.,
 655                                                   -  fgkCarbonFiberTriangleLength
 656                                                   *      SinD(fgkCarbonFiberTriangleAngle)};
 657   ///////////////////////////////////////////
 658   //Setting Local Translations and Rotations:
 659   ///////////////////////////////////////////
 660   TGeoCombiTrans* localcarbonfibersupportmatrix[3];
 661   localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
 662                                                                          0.5*carbonfibersupportheight,NULL);
 663   localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
 664                                                                          2.*symmetryplaneposition+transvector[1],
 665                                                                          transvector[2], carbonfiberot[2]);
 666   localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
 667   /////////////////////////////////////////////////////////////
 668   // Carbon Fiber Support Transformations
 669   /////////////////////////////////////////////////////////////
 670   const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
 671   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
 672                 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
 673                 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
 674                         fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
 675   }
 676   /////////////////////////////////////////////////////////////
 677   // Carbon Fiber Junction Transformation
 678   /////////////////////////////////////////////////////////////
 679   const Int_t kcarbonfiberjunctionmatrixnumber = 2;
 680   TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
 681   TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
 682   TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
 683   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
 684         localcarbonfiberjunctionmatrix[i] =
 685                                                 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
 686         localcarbonfiberjunctionrot[i] =
 687                                                 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
 688         localcarbonfiberjunctiontrans[i] =
 689                                                 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
 690   }
 691   ///////////////////////
 692   // Setting Translations
 693   ///////////////////////
 694   localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
 695   localcarbonfiberjunctiontrans[1][0] =
 696                                  new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
 697   localcarbonfiberjunctiontrans[2][0] =
 698                                  new TGeoTranslation(fgkCarbonFiberTriangleLength
 699                                  * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
 700                                  fgkCarbonFiberTriangleLength
 701                                  * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
 702   localcarbonfiberjunctiontrans[0][1] =
 703                                  new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
 704   localcarbonfiberjunctiontrans[1][1] =
 705                                  new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
 706   localcarbonfiberjunctiontrans[2][1] =
 707                                  new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
 708   ////////////////////
 709   // Setting Rotations
 710   ////////////////////
 711   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
 712                 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
 713                         localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
 714   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
 715         localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
 716   localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
 717   localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
 718   localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
 719   ////////////////////////////////////////
 720   // Setting Carbon Fiber Junction matrix
 721   ////////////////////////////////////////
 722   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
 723                 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
 724                 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
 725                         localcarbonfiberjunctionmatrix[i][j] =
 726                         new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
 727                                                            *localcarbonfiberjunctionrot[i][j]);
 728                     fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
 729          }
 730   }
 731   /////////////////////////////////////////////////////////////
 732   // Carbon Fiber Lower Support Transformations
 733   /////////////////////////////////////////////////////////////
 734   TGeoTranslation* localcarbonfiberlowersupportrans[2];
 735   localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
 736                                                                          fgkCarbonFiberLowerSupportVolumePosition[1]
 737                                                                 +    fgkCarbonFiberLowerSupportVolumePosition[0],
 738                                                                          0.0);
 739   localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
 740                                                                          fgkCarbonFiberJunctionWidth
 741                                                                 -    fgkCarbonFiberLowerSupportWidth
 742                                                                 -    fgkCarbonFiberLowerSupportVolumePosition[0]
 743                                                                 -    fgkCarbonFiberLowerSupportVolumePosition[1],
 744                                                                 -    0.5*fgkCarbonFiberLowerSupportHeight);
 745    localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
 746    fcarbonfiberlowersupportrans[0] =
 747                                                 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
 748    fcarbonfiberlowersupportrans[1] =
 749                                                 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
 750   /////////////////////////////////////////////////////////////
 751   // SSD Sensor Support Transformations
 752   /////////////////////////////////////////////////////////////
 753   const Int_t kssdsensorsupportmatrixnumber = 3;
 754   TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
 755   TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
 756   TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
 757   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 758         localssdsensorsupportmatrix[i] =
 759                                                 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
 760         localssdsensorsupportrot[i] =
 761                                                 new TGeoRotation*[kssdsensorsupportmatrixnumber];
 762         localssdsensorsupportrans[i] =
 763                                                 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
 764   }
 765   ///////////////////////
 766   // Setting Translations
 767   ///////////////////////
 768   localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
 769                                                                           0.5*fgkSSDSensorSideSupportWidth,
 770                                                                           0.0);
 771   localssdsensorsupportrans[1][0] =
 772                                                  new TGeoTranslation(*localssdsensorsupportrans[0][0]);
 773   localssdsensorsupportrans[2][0] =
 774                                                  new TGeoTranslation(*localssdsensorsupportrans[0][0]);
 775   localssdsensorsupportrans[0][1] =
 776                                                  new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
 777                                                                                 0.5*fgkSSDSensorSideSupportThickness[0],
 778                                                                                 0.0);
 779   localssdsensorsupportrans[1][1] =
 780                                                  new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
 781                                                                         -   0.5*fgkSSDSensorSideSupportThickness[0]
 782                                                                     -   fgkSSDModuleSensorSupportDistance,
 783                                                                                 0.0);
 784   localssdsensorsupportrans[2][1] =
 785                                                  new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
 786                                                                         -    fgkSSDSensorCenterSupportPosition,
 787                                                                                  0.5*fgkSSDSensorCenterSupportWidth
 788                                                                         -    0.5*fgkSSDModuleSensorSupportDistance,
 789                                                                                  fgkSSDSensorCenterSupportThickness[0]);
 790   localssdsensorsupportrans[0][2] =
 791                                                  new TGeoTranslation(fgkCarbonFiberTriangleLength
 792                                                                         +    fgkCarbonFiberJunctionToSensorSupport,
 793                                                                                  fgkCarbonFiberJunctionWidth
 794                                                                     -    0.5*(fgkCarbonFiberLowerSupportWidth
 795                                                                         +    fgkSSDSensorCenterSupportLength
 796                                                                         -    fgkSSDSensorCenterSupportThickness[0])
 797                                                                         -    fgkSSDSensorCenterSupportPosition,
 798                                                                              0.0);
 799   localssdsensorsupportrans[1][2] =
 800                                                 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
 801   localssdsensorsupportrans[2][2] =
 802                                                 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
 803   ////////////////////
 804   // Setting Rotations
 805   ////////////////////
 806   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
 807                 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
 808                         localssdsensorsupportrot[i][j] = new TGeoRotation();
 809   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 810         localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
 811         localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
 812   }
 813   localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
 814   localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
 815   localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
 816   ////////////////////////////////////////
 817   // SSD Sensor Support matrix
 818   ////////////////////////////////////////
 819   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 820                 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
 821                 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
 822                         localssdsensorsupportmatrix[i][j] =
 823                         new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
 824                                                            *localssdsensorsupportrot[i][j]);
 825                     fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
 826          }
 827   }
 828   /////////////////////////////////////////////////////////////
 829   // SSD Cooling Tube Support Transformations
 830   /////////////////////////////////////////////////////////////
 831   const Int_t kcoolingtubesupportmatrixnumber = 2;
 832   TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
 833   TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
 834   TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
 835   Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
 836                                                                                                         /fgkCoolingTubeSupportRmax);
 837   localcoolingtubesupportrans[0] =
 838                         new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
 839                                                 +  2.*(fgkCoolingTubeSupportLength
 840                                                 -  fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
 841                                                 +  fgkCarbonFiberTriangleLength
 842                                                 -  2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
 843   localcoolingtubesupportrans[1] =
 844                         new TGeoTranslation(fgkCarbonFiberJunctionLength
 845                                         - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
 846                                         - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 847                                                    fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 848                     +  0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 849                     -  0.5*(fgkCarbonFiberLowerSupportWidth
 850                                         +          fgkSSDSensorCenterSupportLength
 851                     -      fgkSSDSensorCenterSupportThickness[0])
 852                                         +  0.5*fgkSSDSensorLength,
 853                                         -  0.5*fgkCoolingTubeSupportHeight);
 854   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
 855   localcoolingtubesupportrot[i] = new TGeoRotation();
 856   localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
 857   localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
 858   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
 859         localcoolingtubesupportmatrix[i] =
 860                 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
 861                                                    *localcoolingtubesupportrot[i]);
 862   fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
 863   fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
 864                                                                 (*localcoolingtubesupportmatrix[0]));
 865   /////////////////////////////////////////////////////////////
 866   // End Ladder SSD Cooling Tube Support Transformations
 867   /////////////////////////////////////////////////////////////
 868   TGeoTranslation** localendladdercooltubetrans[2];
 869   localendladdercooltubetrans[0] = new TGeoTranslation*[4];
 870   localendladdercooltubetrans[1] = new TGeoTranslation*[2];
 871   for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
 872   localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
 873                                                                                         -          (fgkCoolingTubeSupportLength
 874                                                                                         -               fgkCoolingTubeSupportRmax),
 875                                                                                                         fgkEndLadderMountingBlockPosition[0]
 876                                                                                         -               fgkendladdercoolingsupportdistance[0]
 877                                                                                         +   0.5*fgkCoolingTubeSupportWidth,
 878                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 879   localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
 880                                                                                         -          (fgkCoolingTubeSupportLength
 881                                                                                         -               fgkCoolingTubeSupportRmax),
 882                                                                                                         fgkEndLadderMountingBlockPosition[0]
 883                                                                                         +               fgkendladdercoolingsupportdistance[1]
 884                                                                                         +   0.5*fgkCoolingTubeSupportWidth,
 885                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 886   localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
 887                                                                                         -       fgkCoolingTubeSupportRmax)
 888                                                                                         +               fgkCarbonFiberTriangleLength
 889                                                                                         -   2.0*fgkCarbonFiberJunctionLength,
 890                                                                                                 0.0,
 891                                                                                                 0.0);
 892   localendladdercooltubetrans[0][3]->SetTranslation(0.0,
 893                                                                                                         fgkendladdercoolingsupportdistance[0]
 894                                                                                         +               fgkendladdercoolingsupportdistance[1],
 895                                                                                                         0.0);
 896   for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
 897   localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
 898                                                                                         +               fgkCarbonFiberJunctionLength
 899                                                                                         -               fgkCoolingTubeSupportLength,
 900                                                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[1]
 901                                                                                         -       0.5*fgkCoolingTubeSupportWidth
 902                                                                                                    -fgkendladdercoolingsupportdistance[2],
 903                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 904   localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
 905                                                                                         +               fgkCoolingTubeSupportLength
 906                                                                                         -               fgkCoolingTubeSupportRmax
 907                                                                                         -               fgkCarbonFiberJunctionLength,
 908                                                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[1]
 909                                                                                         -       0.5*fgkCoolingTubeSupportWidth
 910                                                                                         -               fgkendladdercoolingsupportdistance[2],
 911                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 912   fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
 913   fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
 914   fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
 915   fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
 916   (*localcoolingtubesupportrot[1]));
 917   fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
 918   (*localcoolingtubesupportrot[1]));
 919   fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
 920   fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
 921   fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
 922   fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
 923   fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
 924
 925   fendladdercoolingtubesupportmatrix[1][0] =
 926                                                         new TGeoHMatrix((*localendladdercooltubetrans[1][0])
 927                                                                                    *(*localcoolingtubesupportrot[1]));
 928   fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
 929   fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
 930   fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
 931   /////////////////////////////////////////////////////////////
 932   // SSD Cooling Tube Transformations
 933   /////////////////////////////////////////////////////////////
 934   TGeoRotation* localcoolingtuberot = new TGeoRotation();
 935   localcoolingtuberot->SetAngles(0.,90.,0.);
 936   TGeoTranslation** localcoolingtubetrans[4];
 937   TVector3** localcoolingtubevect[4];
 938   for(Int_t i=0; i<4; i++){
 939         localcoolingtubevect[i] = new TVector3*[2];
 940         localcoolingtubetrans[i] = new TGeoTranslation*[2];
 941         fcoolingtubematrix[i] = new TGeoHMatrix*[2];
 942   }
 943   localcoolingtubevect[0][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
 944                                                   -fgkCarbonFiberTriangleLength),
 945                                                   - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 946                                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 947                                                   +      0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 948                                                   -      0.5*(fgkCarbonFiberLowerSupportWidth
 949                                                   +      fgkSSDSensorCenterSupportLength
 950                                                   -      fgkSSDSensorCenterSupportThickness[0])+
 951                                                          0.5*fgkSSDSensorLength-0.25*(fgkSSDSensorLength
 952                                                   -  2.0*fgkSSDModuleStiffenerPosition[1]
 953                                                   -      2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
 954                                                   -  0.5*fgkCoolingTubeSupportWidth,
 955                                                   -  0.5*fgkCoolingTubeSupportHeight);
 956   localcoolingtubevect[0][1] = new TVector3(localcoolingtubevect[0][0]->X(),
 957                                                         localcoolingtubevect[0][0]->Y()+0.5*(fgkSSDSensorLength
 958                                                   -  2.0*fgkSSDModuleStiffenerPosition[1]
 959                                                   -      2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
 960                                                   +  fgkCoolingTubeSupportWidth,
 961                                                   localcoolingtubevect[0][0]->Z());
 962   localcoolingtubevect[1][0] = new TVector3(-localcoolingtubevect[0][0]->X()
 963                                                          +                               fgkCarbonFiberTriangleLength,
 964                                                                                          localcoolingtubevect[0][0]->Y(),
 965                                                                                          localcoolingtubevect[0][0]->Z());
 966   localcoolingtubevect[1][1] = new TVector3(-localcoolingtubevect[0][1]->X()
 967                                                          +                               fgkCarbonFiberTriangleLength,
 968                                                                                          localcoolingtubevect[0][1]->Y(),
 969                                                                                          localcoolingtubevect[0][1]->Z());
 970   localcoolingtubevect[2][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
 971                                                   -     fgkCarbonFiberTriangleLength),
 972                                                   - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 973                                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 974                                                   +      0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 975                                                   -      0.5*(fgkCarbonFiberLowerSupportWidth
 976                                                   +      fgkSSDSensorCenterSupportLength
 977                                                   -      fgkSSDSensorCenterSupportThickness[0])
 978                                                   +  fgkSSDModuleStiffenerPosition[1]
 979                                                   -  0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDSensorOverlap),
 980                                                   -  0.5*fgkCoolingTubeSupportHeight);
 981   localcoolingtubevect[2][1] = new TVector3(-localcoolingtubevect[2][0]->X()
 982                                                          +                               fgkCarbonFiberTriangleLength,
 983                                                                                          localcoolingtubevect[2][0]->Y(),
 984                                                                                          localcoolingtubevect[2][0]->Z());
 985   localcoolingtubevect[3][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
 986                                                   -     fgkCarbonFiberTriangleLength),
 987                                                   - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 988                                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 989                                                   +      0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 990                                                   -      0.5*(fgkCarbonFiberLowerSupportWidth
 991                                                   +      fgkSSDSensorCenterSupportLength
 992                                                   -      fgkSSDSensorCenterSupportThickness[0])
 993                                                   +      fgkSSDSensorLength
 994                                                   -      0.5*fgkSSDModuleStiffenerPosition[1],
 995                                                   -  0.5*fgkCoolingTubeSupportHeight);
 996   localcoolingtubevect[3][1] = new TVector3(-localcoolingtubevect[3][0]->X()
 997                                                   + fgkCarbonFiberTriangleLength,
 998                                                         localcoolingtubevect[3][0]->Y(),
 999                                                   - 0.5*fgkCoolingTubeSupportHeight);
1000   for(Int_t i=0; i<4; i++)
1001         for(Int_t j=0; j<2; j++){
1002                 localcoolingtubetrans[i][j] =
1003                         new TGeoTranslation(localcoolingtubevect[i][j]->X(),
1004                                                                 localcoolingtubevect[i][j]->Y(),
1005                                                                 localcoolingtubevect[i][j]->Z());
1006                 fcoolingtubematrix[i][j] = new TGeoHMatrix((*localcoolingtubetrans[i][j])
1007                                                           *                                     (*localcoolingtuberot));
1008         }
1009   /////////////////////////////////////////////////////////////
1010   // SSD End Ladder Cooling Tube Transformations
1011   /////////////////////////////////////////////////////////////
1012   TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
1013   localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
1014   TGeoTranslation** localendlladdercoolingtubetrans[2];
1015   localendlladdercoolingtubetrans[0] = new TGeoTranslation*[6];
1016   localendlladdercoolingtubetrans[1] = new TGeoTranslation*[4];
1017   for(Int_t i=0; i<2; i++)
1018         for(Int_t j=0; j<(i==0?6:4); j++)
1019                 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
1020   localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1021                                                                         -        fgkCoolingTubeSupportRmax)
1022                                                                         +        fgkCarbonFiberJunctionLength,
1023                                                                           0.5*(fgkEndLadderMountingBlockPosition[0]
1024                                                                         -    fgkendladdercoolingsupportdistance[0]),
1025                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1026   localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1027                                                                         -        fgkCoolingTubeSupportRmax)
1028                                                                         -        fgkCarbonFiberJunctionLength
1029                                                                         +    fgkCarbonFiberTriangleLength,
1030                                                                           0.5*(fgkEndLadderMountingBlockPosition[0]
1031                                                                         -    fgkendladdercoolingsupportdistance[0]),
1032                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1033   localendlladdercoolingtubetrans[0][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1034                                                                         -   fgkCoolingTubeSupportRmax)
1035                                                                         +       fgkCarbonFiberJunctionLength,
1036                                                                            fgkEndLadderMountingBlockPosition[0]
1037                                                                         -   fgkendladdercoolingsupportdistance[0]
1038                                                   +                0.5*(fgkendladdercoolingsupportdistance[0]
1039                                                   +                             fgkendladdercoolingsupportdistance[1]
1040                                                   +                             fgkCoolingTubeSupportWidth),
1041                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1042   localendlladdercoolingtubetrans[0][3]->SetTranslation((fgkCoolingTubeSupportLength
1043                                                                         -        fgkCoolingTubeSupportRmax)
1044                                                                         -        fgkCarbonFiberJunctionLength
1045                                                                         +    fgkCarbonFiberTriangleLength,
1046                                                                            fgkEndLadderMountingBlockPosition[0]
1047                                                                         -   fgkendladdercoolingsupportdistance[0]
1048                                                   +                0.5*(fgkendladdercoolingsupportdistance[0]
1049                                                   +                             fgkendladdercoolingsupportdistance[1]
1050                                                   +                             fgkCoolingTubeSupportWidth),
1051                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1052   localendlladdercoolingtubetrans[0][4]->SetTranslation(-(fgkCoolingTubeSupportLength
1053                                                                         -   fgkCoolingTubeSupportRmax)
1054                                                                         +       fgkCarbonFiberJunctionLength,
1055                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[0]
1056                                                   - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1057                                                   -                     fgkEndLadderMountingBlockPosition[0]
1058                                                   -                     fgkendladdercoolingsupportdistance[1]
1059                                                   -                     fgkCoolingTubeSupportWidth),
1060                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1061   localendlladdercoolingtubetrans[0][5]->SetTranslation((fgkCoolingTubeSupportLength
1062                                                                         -        fgkCoolingTubeSupportRmax)
1063                                                                         -        fgkCarbonFiberJunctionLength
1064                                                                         +    fgkCarbonFiberTriangleLength,
1065                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[0]
1066                                                   - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1067                                                   -                     fgkEndLadderMountingBlockPosition[0]
1068                                                   -                     fgkendladdercoolingsupportdistance[1]
1069                                                   -                     fgkCoolingTubeSupportWidth),
1070                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1071   localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1072                                                                         -   fgkCoolingTubeSupportRmax)
1073                                                                         +       fgkCarbonFiberJunctionLength,
1074                                                         - 0.50 * (fgkMountingBlockToSensorSupport
1075                                                         - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1076                                                         -                 fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1077                                                         +                 fgkSSDSensorOverlap
1078                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1079                                                         -                 fgkendladdercoolingsupportdistance[2]
1080                                                         -                 fgkEndLadderMountingBlockPosition[1]
1081                                                         -                 fgkCoolingTubeSupportWidth)
1082                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1083                                                         -                 fgkendladdercoolingsupportdistance[2]
1084                                                         -                 fgkCoolingTubeSupportWidth,
1085                                                   -             0.5*fgkCoolingTubeSupportHeight);
1086   localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1087                                                   -      fgkCoolingTubeSupportRmax)
1088                                                   -      fgkCarbonFiberJunctionLength
1089                                                   +    fgkCarbonFiberTriangleLength,
1090                                                   - 0.50 * (fgkMountingBlockToSensorSupport
1091                                                         - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1092                                                         -                 fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1093                                                         +                 fgkSSDSensorOverlap
1094                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1095                                                         -                 fgkendladdercoolingsupportdistance[2]
1096                                                         -                 fgkEndLadderMountingBlockPosition[1]
1097                                                         -                 fgkCoolingTubeSupportWidth)
1098                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1099                                                         -                 fgkendladdercoolingsupportdistance[2]
1100                                                         -                 fgkCoolingTubeSupportWidth,
1101                                                   -             0.5*fgkCoolingTubeSupportHeight);
1102   localendlladdercoolingtubetrans[1][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1103                                                                         -   fgkCoolingTubeSupportRmax)
1104                                                                         +       fgkCarbonFiberJunctionLength,
1105                                                                                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1106                                                                         - 0.5*fgkendladdercoolingsupportdistance[2],
1107                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1108   localendlladdercoolingtubetrans[1][3]->SetTranslation((fgkCoolingTubeSupportLength
1109                                                                         -        fgkCoolingTubeSupportRmax)
1110                                                                         -        fgkCarbonFiberJunctionLength
1111                                                                         +    fgkCarbonFiberTriangleLength,
1112                                                                                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1113                                                                         - 0.5*fgkendladdercoolingsupportdistance[2],
1114                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1115   fendladdercoolingtubematrix[0] = new TGeoHMatrix*[6];
1116   fendladdercoolingtubematrix[1] = new TGeoHMatrix*[4];
1117   for(Int_t i=0; i<2; i++)
1118         for(Int_t j=0; j<(i==0?6:4); j++){
1119                 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1120                 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1121         }
1122   /////////////////////////////////////////////////////////////
1123   // SSD Hybrid Components Transformations
1124   /////////////////////////////////////////////////////////////
1125   const Int_t khybridmatrixnumber = 3;
1126   TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1127   localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1128                                             0.5*fgkSSDStiffenerWidth,
1129                                             0.5*fgkSSDStiffenerHeight);
1130   localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1131                                             fgkSSDModuleStiffenerPosition[1],0.0);
1132
1133   localhybridtrans[2] = new TGeoTranslation(
1134                       -  0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1135                       -      (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1136                               fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1137                       +         0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1138                       -         0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1139                       -       fgkSSDSensorCenterSupportThickness[0]),
1140                       -      (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
1141                       -       fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight));
1142   fhybridmatrix = new TGeoHMatrix();
1143   for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1144   /////////////////////////////////////////////////////////////
1145   // SSD Cooling Block Transformations
1146   /////////////////////////////////////////////////////////////
1147   const Int_t kcoolingblockmatrixnumber = 4;
1148   TGeoTranslation* localcoolingblocktrans[kcoolingblockmatrixnumber];
1149   localcoolingblocktrans[0] = new TGeoTranslation(-2.*(fgkCoolingTubeSupportRmax
1150                             -  fgkCoolingTubeSupportRmin),0.0,
1151                                0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1152   localcoolingblocktrans[1] = new TGeoTranslation(0.5*fgkSSDStiffenerLength
1153                             -  0.5*fgkSSDModuleSensorSupportDistance-fgkSSDCoolingBlockLength,
1154                                0.0,fgkSSDStiffenerHeight);
1155   localcoolingblocktrans[2] = new TGeoTranslation(*localhybridtrans[1]);
1156   localcoolingblocktrans[3] = new TGeoTranslation(*localhybridtrans[2]);
1157   fcoolingblocksystematrix = new TGeoHMatrix();
1158   for(Int_t i=0; i<kcoolingblockmatrixnumber; i++)
1159       fcoolingblocksystematrix->MultiplyLeft(localcoolingblocktrans[i]);
1160   /////////////////////////////////////////////////////////////
1161   // SSD Stiffener Flex Transformations
1162   /////////////////////////////////////////////////////////////
1163   const Int_t klocalflexmatrixnumber = 4;
1164   TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1165   for(Int_t i=0; i<fgkflexnumber; i++)
1166       localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1167   for(Int_t i=0; i<fgkflexnumber; i++)
1168       for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1169             localflexmatrix[i][j] = new TGeoCombiTrans();
1170   Double_t ssdstiffenerseparation = fgkSSDSensorLength
1171                                                                   - 2.*fgkSSDModuleStiffenerPosition[1]
1172                                                                   -    fgkSSDStiffenerWidth;
1173   localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1174                                         +0.5*fgkSSDStiffenerLength,
1175                                          0.5*fgkSSDStiffenerWidth,
1176                                         -0.5*fgkSSDStiffenerHeight
1177                                         -0.5*fgkSSDFlexHeight[0]);
1178   localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1179                                         +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1180                                         -0.5*fgkSSDStiffenerWidth,
1181                                         -0.5*fgkSSDStiffenerHeight
1182                                         -0.5*fgkSSDFlexHeight[0]);
1183   TGeoRotation* localflexrot = new TGeoRotation();
1184   localflexrot->SetAngles(180.,0.,0.);
1185   localflexmatrix[1][0]->SetRotation(localflexrot);
1186   for(Int_t i=0; i<fgkflexnumber; i++)
1187       for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1188             localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1189   for(Int_t i=0; i<fgkflexnumber; i++){
1190       fstiffenerflexmatrix[i] = new TGeoHMatrix();
1191       for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1192             fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
1193   }
1194   /////////////////////////////////////////////////////////////
1195   // SSD End Flex Transformations
1196   /////////////////////////////////////////////////////////////
1197   TGeoRotation* localendflexrot = new TGeoRotation();
1198   localendflexrot->SetAngles(0.0,90.0,0.0);
1199   TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1200   Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1201                             /  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1202   Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1203                             * TMath::DegToRad()*ssdflexradiusmax
1204                                                                - fgkSSDFlexLength[2]-TMath::Pi()
1205                                                                * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
1206   Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1207                             + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1208                             +      fgkSSDFlexLength[2];
1209   localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1210                               0.5*fgkSSDFlexWidth[0],
1211                               2.*fgkSSDStiffenerHeight
1212                             + 0.5*fgkSSDFlexHeight[0]);
1213   localendflexmatrix->SetRotation(localendflexrot);
1214   for(Int_t i=0; i<fgkflexnumber; i++)
1215       fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1216   /////////////////////////////////////////////////////////////
1217   // End Ladder Carbon Fiber Junction
1218   /////////////////////////////////////////////////////////////
1219   TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1220   TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1221   TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1222   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1223       localendladdercarbonfiberjunctionmatrix[i]
1224             = new TGeoCombiTrans*[fgkendladdercabonfiberjunctionmatrixnumber];
1225       localendladdercarbonfiberjunctionrot[i]
1226             = new TGeoRotation*[fgkendladdercabonfiberjunctionmatrixnumber];
1227       localendladdercarbonfiberjunctiontrans[i]
1228             = new TGeoTranslation*[fgkendladdercabonfiberjunctionmatrixnumber];
1229       fendladdercarbonfiberjunctionmatrix[i]
1230             = new TGeoHMatrix*[fgkendladdercabonfiberjunctionmatrixnumber];
1231   }
1232   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1233       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1234             localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1235             localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1236       }
1237   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1238       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
1239           localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1240   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1241       localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1242                               0.0,0.0);
1243       localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1244                 *                     CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1245                 *                     SinD(fgkCarbonFiberTriangleAngle),
1246                         0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1247   -                          fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1248   }
1249   TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1250   TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1251   TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1252   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1253       localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1254       localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1255       localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1256       localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1257             0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1258       localendladdercarbonfiberjunctionglobalmatrix[i] =
1259             new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1260                                *localendladdercarbonfiberjunctionglobalrot[i]);
1261   }
1262   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1263       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1264             localendladdercarbonfiberjunctionmatrix[i][j] =
1265                   new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1266                                      *localendladdercarbonfiberjunctionrot[i][j]);
1267            fendladdercarbonfiberjunctionmatrix[i][j] =
1268             new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1269             *               (*localendladdercarbonfiberjunctionmatrix[i][j]));
1270       }
1271   /////////////////////////////////////////////////////////////
1272   // End Ladder Carbon Fiber Support
1273   /////////////////////////////////////////////////////////////
1274   TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1275   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1276       localendladdercarbonfibertrans[i] = new TGeoTranslation();
1277       localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1278             i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1279       fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1280   }
1281   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1282       for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1283             fendladdercarbonfibermatrix[i][j] =
1284             new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1285             *(*fcarbonfibersupportmatrix[j]));
1286   /////////////////////////////////////////////////////////////
1287   // End Ladder SSD Mounting Block
1288   /////////////////////////////////////////////////////////////
1289   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1290       fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1291   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1292       fendladdermountingblockcombitrans[i]->SetTranslation(-  0.25*(fgkSSDMountingBlockLength[0]
1293                                 +        fgkSSDMountingBlockLength[1])
1294                                 +  0.5*fgkCarbonFiberTriangleLength,
1295                                 fgkEndLadderMountingBlockPosition[i],
1296                                 -  fgkSSDMountingBlockHeight[1]
1297                                 +  0.5*fgkSSDMountingBlockHeight[0]);
1298   TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1299   endladdermountingblockrot->SetAngles(0.,90.,0.);
1300   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1301         fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1302   /////////////////////////////////////////////////////////////
1303   // End Ladder SSD Mounting Block Clip Matrix
1304   /////////////////////////////////////////////////////////////
1305   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1306         fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1307
1308   TGeoRotation* localendladdercliprot = new TGeoRotation();
1309   TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1310   localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1311                                                                                   -     fgkSSDMountingBlockLength[1])
1312                                                                                   + fgkSSDMountingBlockLength[0],0.,0.);
1313   localendladdercliprot->SetAngles(90.,180.,-90.);
1314   TGeoCombiTrans* localendladderclipcombitrans =
1315                         new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1316   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1317         for(Int_t j=0; j<2; j++){
1318                 fendladdermountingblockclipmatrix[i][j] =
1319                                                 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1320                 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1321         }
1322   /////////////////////////////////////////////////////////////
1323   // End Ladder Carbon Fiber Lower Support
1324   /////////////////////////////////////////////////////////////
1325   for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1326       fendladderlowersupptrans[i] =
1327             new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1328                         +  0.5*fgkSSDMountingBlockWidth),
1329                         -  0.5*fgkCarbonFiberLowerSupportHeight);
1330   fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1331                                                                          fgkCarbonFiberLowerSupportVolumePosition[1]
1332                                                                 +    fgkCarbonFiberLowerSupportVolumePosition[0],
1333                                                                          0.0);
1334   fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1335  /////////////////////////////////////////////////////////////
1336   // Matrix for positioning Ladder into mother volume
1337   /////////////////////////////////////////////////////////////
1338   TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1339   for(Int_t i=0; i<fgkladdernumber; i++)
1340         ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1341   TGeoRotation* localladdermotherrot = new TGeoRotation();
1342   localladdermotherrot->SetAngles(0.,90.,0.);
1343   TGeoTranslation* localladdermothertrans[fgkladdernumber];
1344   TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1345   for(Int_t i=0; i<fgkladdernumber; i++){
1346         localladdermothertrans[i] = new TGeoTranslation(0.,
1347                                                           - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1348                                                           + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1349                                                           + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1350                                                           * fgkCarbonFiberJunctionWidth,0.);
1351         localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1352                                                                                                                 *localladdermotherrot);
1353         ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1354         ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
1355   }
1356   /////////////////////////////////////////////////////////////
1357   // Ladder Cables Matrices
1358   /////////////////////////////////////////////////////////////
1359   Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
1360                                              + fgkSSDFlexHeight[1];
1361   Double_t ssdladdercabletransx[3];
1362   ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1363                                                   *   SinD(2.*fgkSSDFlexAngle)
1364                                                   *       CosD(2.*fgkSSDFlexAngle);
1365   ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1366                                                   -     ssdladdercabletransx[0]
1367                                                   /     SinD(2.*fgkSSDFlexAngle))
1368                                                   *     CosD(fgkSSDFlexAngle);
1369   ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1370                                                   *       TMath::DegToRad()*ssdflexradiusmax
1371                                                   -     fgkSSDFlexLength[2]-TMath::Pi()
1372                                                   *       fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1373                                                   -       fgkSSDLadderCableWidth)
1374                                                   *       CosD(2.*fgkSSDFlexAngle);
1375   Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
1376                                                   *     TanD(2.*fgkSSDFlexAngle),
1377                                                         ssdladdercabletransx[1]
1378                                                   *     TanD(fgkSSDFlexAngle),
1379                                                         ssdladdercabletransx[2]
1380                                                   *     TanD(2.*fgkSSDFlexAngle)};
1381   TGeoRotation* localladdercablerot[3];
1382   for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1383   localladdercablerot[0]->SetAngles(90.,0.,0.);
1384   localladdercablerot[1]->SetAngles(90.,60.,-90.);
1385   localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1386                                                  *                        (*localladdercablerot[0]));
1387   ////////////////////////////////////////////
1388   // LocalLadderCableCombiTransMatrix
1389   ////////////////////////////////////////////
1390   const Int_t klocalladdersidecablesnumber = 2;
1391   const Int_t klocalladdercombitransnumber = 5;
1392   TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1393   for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1394          localladdercablecombitransmatrix[i] =
1395                                                            new TGeoCombiTrans*[klocalladdercombitransnumber];
1396   ///////////////////////////////////////////
1397   // Left Side Ladder Cables Transformations
1398   ///////////////////////////////////////////
1399   localladdercablecombitransmatrix[0][0]  =
1400                                                 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1401                                                 0.,0.,NULL);
1402   localladdercablecombitransmatrix[0][1] =
1403         new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1404                                            - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1405                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1406                                            + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1407                                            - 0.5*(fgkCarbonFiberLowerSupportWidth
1408                                            + fgkSSDSensorCenterSupportLength
1409                                            - fgkSSDSensorCenterSupportThickness[0]),
1410                                            - (fgkSSDModuleCoolingBlockToSensor
1411                                            + 0.5*fgkCoolingTubeSupportHeight
1412                                            - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1413                                            - fgkSSDChipHeight),NULL);
1414   localladdercablecombitransmatrix[0][2] =
1415                                                 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1416                                                                                    fgkSSDModuleStiffenerPosition[1],0.,0);
1417   localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1418                                         0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1419                                    +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1420                                    fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1421                                          - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1422                                                                                                 new TGeoRotation("",180.,0.,0.));
1423   localladdercablecombitransmatrix[0][4] =
1424                                                 new TGeoCombiTrans(-ssdladdercabletransx[0]
1425                                                 -     ssdladdercabletransx[1]-ssdladdercabletransx[2]
1426                                                 +     fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1427                                                           0.,
1428                                                           0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1429                                                 +         fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
1430                                                 +     ssdladdercabletransz[0]-ssdladdercabletransz[1]
1431                                                 +         ssdladdercabletransz[2],localladdercablerot[2]);
1432   ///////////////////////////////////////////
1433   // Rigth Side Ladder Cables Transformations
1434   ///////////////////////////////////////////
1435   TGeoCombiTrans* localladdercablessdmodulematrix =
1436         new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1437                                                                   - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1438                                                                          fgkSSDStiffenerWidth,
1439                                                                   - 0.5*fgkSSDFlexHeight[0],NULL);
1440   for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1441    localladdercablecombitransmatrix[1][i] =
1442                         (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1443                                         new TGeoCombiTrans(*localladdercablessdmodulematrix));
1444   ///////////////////////////////////////////
1445   // Setting LadderCableHMatrix
1446   ///////////////////////////////////////////
1447   Int_t beamaxistrans[2][3];
1448   beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1449   beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1450   beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1451   beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1452   beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1453   beamaxistrans[1][2] = beamaxistrans[1][0];
1454   TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1455   TGeoRotation* laddercablerot = new TGeoRotation();
1456   TGeoTranslation* laddercabletrans = new TGeoTranslation();
1457   TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1458   Double_t* laddercabletransvector;
1459   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1460         localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1461         fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1462   }
1463   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1464         for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1465                 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1466                 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1467                         localladdercablehmatrix[i][j]->MultiplyLeft(
1468                         localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1469         }
1470                 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1471                 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1472                 laddercabletrans->SetTranslation(laddercabletransvector[0],
1473                                                                          laddercabletransvector[1]
1474                                         +                (j==0 ? beamaxistrans[i][0] : 0.)
1475                                         *                                fgkCarbonFiberJunctionWidth,
1476                                                                          laddercabletransvector[2]);
1477                 laddercablecombitrans->SetRotation(*laddercablerot);
1478                 laddercablecombitrans->SetTranslation(*laddercabletrans);
1479                 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1480         }
1481     fladdercablematrix[i][2] =
1482                                         AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1483                                         beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1484         fladdercablematrix[i][3] =
1485                                         AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1486                                         beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1487   }
1488   for(Int_t i=0; i<fgkladdercablesnumber; i++)
1489         for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1490                 fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1491   ///////////////////////////////////////////
1492   // Setting Ladder HMatrix
1493   ///////////////////////////////////////////
1494   Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1495                                                                                                 fgkSSDLay6SensorsNumber};
1496   for(Int_t i=0; i<fgkladdernumber; i++){
1497         fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1498         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1499                 fladdermatrix[i][j] = new TGeoHMatrix();
1500                 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1501                 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1502                 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1503         }
1504   }
1505   ///////////////////////////////////////////
1506   // Setting SSD Sensor Matrix
1507   ///////////////////////////////////////////
1508   TGeoCombiTrans* localssdsensorcombitrans[2];
1509   TGeoRotation* localssdsensorrot = new TGeoRotation();
1510   localssdsensorrot->SetAngles(0.,90.,0.);
1511   TGeoTranslation* localssdsensortrans[2];
1512   for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1513   localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1514                                           -             (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1515                               fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1516                       +         0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1517                       -         0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1518                       -       fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
1519                                                         0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1520                                           -             fgkSSDModuleCoolingBlockToSensor-0.5*fgkSSDModuleVerticalDisalignment
1521                                           +    (fgkSSDSensorSideSupportHeight[1]
1522                                           -             fgkSSDSensorSideSupportHeight[0]));
1523   localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1524                                           -        (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1525                               fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1526                       +         0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1527                       -         0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1528                       -       fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
1529                                                     0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1530                                                         -fgkSSDModuleCoolingBlockToSensor-0.5*fgkSSDModuleVerticalDisalignment);
1531   for(Int_t i=0; i<2; i++)
1532         localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1533                                                                                                          *localssdsensorrot);
1534     for(Int_t i=0; i<fgkladdernumber; i++){
1535         fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1536         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1537                 switch(i){
1538                         case 0: //Ladder of Layer5
1539                         fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1540                                                                    * ((j%2==0 ? *localssdsensorcombitrans[0] :
1541                                                                                                 *localssdsensorcombitrans[1])));
1542                         break;
1543                         case 1: //Ladder of Layer6
1544                         fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1545                                                                    * ((j%2==0 ? *localssdsensorcombitrans[1] :
1546                                                                                                 *localssdsensorcombitrans[0])));
1547                 break;
1548                 }
1549           }
1550   }
1551   //////////////////////////
1552   // Setting SSD End Ladder
1553   //////////////////////////
1554   for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1555   for(Int_t i=0; i<2; i++){
1556         fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1557         fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1558         fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1559         fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1560         fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1561         fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1562         fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1563         fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1564    }
1565   /////////////////////////////////////////////////////
1566   // Setting the CombiTransformation to pass ITS center
1567   /////////////////////////////////////////////////////
1568   Double_t itscentertransz[fgklayernumber];
1569   itscentertransz[0] = fgkSSDLay5LadderLength
1570                                          - fgkLay5CenterITSPosition;
1571   itscentertransz[1] = fgkSSDLay6LadderLength
1572                                          - fgkLay6CenterITSPosition;
1573   Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1574                                                    + 0.5*fgkCoolingTubeSupportHeight;
1575   TGeoRotation* itscenterrot[3];
1576   for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1577   itscenterrot[0]->SetAngles(90.,180.,-90.);
1578   itscenterrot[1]->SetAngles(0.,90.,0.);
1579   itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1580   TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1581   for(Int_t i=0; i<fgklayernumber; i++)
1582         itscentercombitrans[i] = new TGeoCombiTrans(0.,
1583                                                          itssensortransy,
1584                                                          fgkEndLadderCarbonFiberLowerJunctionLength[1]
1585                                                    - itscentertransz[i],itscenterrot[2]);
1586   TGeoRotation** locallayerrot[fgklayernumber];
1587   TGeoTranslation** locallayertrans[fgklayernumber];
1588   TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1589   TGeoTranslation* localbeamaxistrans[fgklayernumber];
1590   localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1591                                          - fgkLay5CenterITSPosition);
1592   localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1593                                          - fgkLay6CenterITSPosition);
1594   const Int_t kssdlayladdernumber[fgklayernumber] =
1595                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1596   for(Int_t i=0; i<fgklayernumber; i++){
1597     locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1598     locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1599         locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1600         flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1601   }
1602   Double_t layerladderangleposition[fgklayernumber] =
1603                 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1604   Double_t layerradius = 0.;
1605   for(Int_t i=0; i<fgklayernumber; i++){
1606         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1607                 switch(i){
1608                         case 0: //Ladder of Layer5
1609                         layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1610                         break;
1611                         case 1: //Ladder of Layer6
1612                         layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1613                 break;
1614                 }
1615                 locallayerrot[i][j] = new TGeoRotation();
1616                 locallayertrans[i][j] = new TGeoTranslation();
1617                 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1618                 locallayertrans[i][j]->SetTranslation(layerradius
1619                                                           *     CosD(90.0+j*layerladderangleposition[i]),
1620                                                             layerradius
1621                                                           * SinD(90.0+j*layerladderangleposition[i]),0.);
1622                 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1623                                                                          *locallayerrot[i][j]);
1624                 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1625                 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1626                 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1627         }
1628   }
1629   /////////////////////////////////////////////////////////////
1630   // Deallocating memory
1631   /////////////////////////////////////////////////////////////
1632   for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1633         delete carbonfiberot[i];
1634         delete localcarbonfibersupportmatrix[i];
1635   }
1636   for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1637      for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1638        delete localcarbonfiberjunctionmatrix[i][j];
1639            delete localcarbonfiberjunctionrot[i][j];
1640            delete localcarbonfiberjunctiontrans[i][j];
1641            }
1642        delete [] localcarbonfiberjunctionmatrix[i];
1643        delete [] localcarbonfiberjunctionrot[i];
1644        delete [] localcarbonfiberjunctiontrans[i];
1645   }
1646   for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1647            delete localcarbonfiberlowersupportrans[i];
1648   for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1649      for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1650        delete localssdsensorsupportmatrix[i][j];
1651            delete localssdsensorsupportrot[i][j];
1652            delete localssdsensorsupportrans[i][j];
1653            }
1654        delete [] localssdsensorsupportmatrix[i];
1655        delete [] localssdsensorsupportrot[i];
1656        delete [] localssdsensorsupportrans[i];
1657   }
1658   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1659         delete localcoolingtubesupportmatrix[i];
1660         delete localcoolingtubesupportrot[i];
1661         delete localcoolingtubesupportrans[i];
1662   }
1663   for(Int_t i=0; i<4; i++){
1664         for(Int_t j=0; j<2; j++){
1665                 delete localcoolingtubevect[i][j];
1666                 delete localcoolingtubetrans[i][j];
1667         }
1668         delete [] localcoolingtubevect[i];
1669         delete [] localcoolingtubetrans[i];
1670   }
1671  delete endladdermountingblockrot;
1672  for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
1673  for(Int_t i=0; i<kcoolingblockmatrixnumber; i++) delete localcoolingblocktrans[i];
1674  for(Int_t i=0; i<fgkflexnumber; i++){
1675       for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1676             delete localflexmatrix[i][j];
1677       delete [] localflexmatrix[i];
1678  }
1679  delete localendlladdercoolingtuberot;
1680  for(Int_t i=0; i<2; i++){
1681         for(Int_t j=0; j<(i==0?6:4); j++)
1682                 delete localendlladdercoolingtubetrans[i][j];
1683         delete [] localendlladdercoolingtubetrans[i];
1684   }
1685
1686  delete localflexrot;
1687  delete localendflexrot;
1688  delete localendflexmatrix;
1689  for(Int_t i=0; i<fgkladdernumber; i++){
1690         delete localladdermothertrans[i];
1691         delete localladdermothercombitrans[i];
1692   }
1693  delete localladdermotherrot;
1694  for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1695       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1696             delete localendladdercarbonfiberjunctionmatrix[i][j];
1697             delete localendladdercarbonfiberjunctionrot[i][j];
1698             delete localendladdercarbonfiberjunctiontrans[i][j];
1699       }
1700       delete [] localendladdercarbonfiberjunctionmatrix[i];
1701       delete [] localendladdercarbonfiberjunctionrot[i];
1702       delete [] localendladdercarbonfiberjunctiontrans[i];
1703       delete localendladdercarbonfiberjunctionglobalrot[i];
1704       delete localendladdercarbonfiberjunctionglobaltrans[i];
1705       delete localendladdercarbonfiberjunctionglobalmatrix[i];
1706  }
1707   for(Int_t i=0; i<2; i++){
1708         for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1709         delete [] localendladdercooltubetrans[i];
1710   }
1711   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1712       delete localendladdercarbonfibertrans[i];
1713   for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1714   for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1715         for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1716                 delete localladdercablecombitransmatrix[i][j];
1717                 delete []localladdercablecombitransmatrix[i];
1718   }
1719   delete localendladdercliprot;
1720   delete localendladdercliptrans;
1721   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1722         for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1723                 delete localladdercablehmatrix[i][j];
1724         delete []localladdercablehmatrix[i];
1725   }
1726   delete laddercablerot;
1727   delete laddercabletrans;
1728   delete laddercablecombitrans;
1729   delete localladdercablessdmodulematrix;
1730   delete localssdsensorrot;
1731   for(Int_t i=0; i<2; i++){
1732         delete localssdsensortrans[i];
1733         delete localssdsensorcombitrans[i];
1734   }
1735   for(Int_t i=0; i<fgklayernumber; i++){
1736         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1737                 delete locallayerrot[i][j];
1738                 delete locallayertrans[i][j];
1739                 delete locallayercombitrans[i][j];
1740     }
1741         delete [] locallayerrot[i];
1742         delete [] locallayertrans[i];
1743         delete [] locallayercombitrans[i];
1744         delete localbeamaxistrans[i];
1745   }
1746   for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1747   for(Int_t i=0; i<fgkladdernumber; i++){
1748         for(Int_t j=0; j<fgkladdernumber; j++)
1749                 delete ladderglobalmatrix[i][j];
1750         delete [] ladderglobalmatrix[i];
1751   }
1752   /////////////////////////////////////////////////////////////
1753   fTransformationMatrices = kTRUE;
1754 }
1755 ///////////////////////////////////////////////////////////////////////////////
1756 void AliITSv11GeometrySSD::CreateBasicObjects(){
1757   /////////////////////////////////////////////////////////////
1758   // Method generating the Objects of SSD Geometry
1759   /////////////////////////////////////////////////////////////
1760   // SSD Sensor
1761   ///////////////////////////////////
1762   SetSSDSensor();
1763   /////////////////////////////////////////////////////////////
1764   // Carbon Fiber Support
1765   /////////////////////////////////////////////////////////////
1766   TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1767   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1768       fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
1769   /////////////////////////////////////////////////////////////
1770   // Carbon Fiber Junction
1771   /////////////////////////////////////////////////////////////
1772   fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth);
1773   /////////////////////////////////////////////////////////////
1774   // Carbon Fiber Lower Support
1775   /////////////////////////////////////////////////////////////
1776   TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1777   for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1778         fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1779   /////////////////////////////
1780   // SSD Sensor Support
1781   /////////////////////////////
1782   for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1783                                                                                 new TGeoVolume*[fgkssdsensorsupportnumber];
1784   Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
1785                                                                          fgkSSDSensorSideSupportThickness[1]};
1786   for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1787         fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1788                                                                                            fgkSSDSensorSideSupportHeight[i],
1789                                                                                            fgkSSDSensorSideSupportWidth,
1790                                                                                            sidesupporthickness);
1791         fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1792                                                                                            fgkSSDSensorCenterSupportHeight[i],
1793                                                                                            fgkSSDSensorCenterSupportWidth,
1794                                                                                            sidesupporthickness);
1795   }
1796   /////////////////////////////////////////////////////////////
1797   // SSD Cooling Tube Support
1798   /////////////////////////////////////////////////////////////
1799   Int_t edgesnumber = 16;
1800   fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1801   /////////////////////////////////////////////////////////////
1802   // SSD Hybrid
1803   /////////////////////////////////////////////////////////////
1804   TList* ssdhybridcomponentslist = GetSSDHybridParts();
1805   for(Int_t i=0; i<fgkhybridcompnumber; i++)
1806         fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1807   /////////////////////////////////////////////////////////////
1808   // SSD Cooling Block System
1809   /////////////////////////////////////////////////////////////
1810   fssdcoolingblocksystem = GetCoolingBlockSystem();
1811    /////////////////////////////////////////////////////////////
1812   // SSD Cooling Tube
1813   /////////////////////////////////////////////////////////////
1814   TList* coolingtubelist = GetCoolingTubeList();
1815   for(Int_t i=0; i<fgkcoolingtubenumber; i++)
1816         fcoolingtube[i] = (TGeoVolume*)coolingtubelist->At(i);
1817   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
1818         fendladdercoolingtube[i] =
1819                         (TGeoVolume*)coolingtubelist->At(fgkcoolingtubenumber+i);
1820   /////////////////////////////////////////////////////////////
1821   // SSD Flex
1822   /////////////////////////////////////////////////////////////
1823   fssdstiffenerflex = GetSSDStiffenerFlex();
1824   fssdendflex = GetSSDEndFlex();
1825   ///////////////////////////////////
1826   // End Ladder Carbon Fiber Junction
1827   ///////////////////////////////////
1828   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1829                                                    fendladdercarbonfiberjunction[i] =
1830                                                    new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1831   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1832     fendladdercarbonfiberjunction[i][0] =
1833                   GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]);
1834     fendladdercarbonfiberjunction[i][1] =
1835                   GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]);
1836   }
1837   ///////////////////////////////////
1838   // End Ladder Mounting Block
1839   ///////////////////////////////////
1840   fendladdermountingblock = GetSSDMountingBlock();
1841   ///////////////////////////////////
1842   // End Ladder Mounting Block
1843   ///////////////////////////////////
1844   fendladdermountingblockclip = GetMountingBlockClip();
1845   ///////////////////////////////////
1846   // Ladder Support
1847   ///////////////////////////////////
1848   TList* laddersupportlist = GetMountingBlockSupport(20);
1849   fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1850   fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1851   fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1852   fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
1853   /////////////////////////////////////////////////////////////
1854   // Deallocating memory
1855   /////////////////////////////////////////////////////////////
1856   delete carbonfibersupportlist;
1857   delete carbonfiberlowersupportlist;
1858   delete ssdhybridcomponentslist;
1859   delete laddersupportlist;
1860   /////////////////////////////////////////////////////////////
1861   fBasicObjects = kTRUE;
1862 }
1863 /////////////////////////////////////////////////////////////////////////////////
1864 void AliITSv11GeometrySSD::SetSSDSensor(){
1865   ////////////////////////////////////////////////////////////////
1866   // Method generating SSD Sensors: it sets the private variables
1867   // fSSDSensor5, fSSDSensor6
1868   ////////////////////////////////////////////////////////////////
1869   Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1870   Double_t ssdsensitivewidth  = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1871   TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
1872                                                 0.5*ssdsensitivewidth,
1873                                                 0.5*fgkSSDSensorHeight,
1874                                                 0.5*ssdsensitivelength);
1875   TGeoVolume* ssdsensorsensitiveLay5 =
1876         new TGeoVolume(fgSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
1877   TGeoVolume* ssdsensorsensitiveLay6 =
1878         new TGeoVolume(fgSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
1879   ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1880   ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
1881   TGeoBBox* ssdsensorinsensitiveshape[2];
1882   ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
1883                                                 0.5*fgkSSDSensorInsensitiveWidth,
1884                                                 0.5*fgkSSDSensorHeight,
1885                                                 0.5*fgkSSDSensorLength);
1886   ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
1887                                                 0.5*ssdsensitivewidth,
1888                                                 0.5*fgkSSDSensorHeight,
1889                                                 0.5*fgkSSDSensorInsensitiveWidth);
1890   const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
1891                                              "SSDSensorInsensitive2"};
1892   TGeoVolume* ssdsensorinsensitive[2];
1893   for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1894       new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1895                      fSSDSensorMedium);
1896       ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
1897   }
1898   /////////////////////////////////////////////////////////////
1899   // Virtual Volume containing SSD Sensor
1900   /////////////////////////////////////////////////////////////
1901   TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1902                                                                                              0.5*fgkSSDSensorWidth,
1903                                                                                              0.5*fgkSSDSensorHeight,
1904                                                                                              0.5*fgkSSDSensorLength);
1905   fSSDSensor5 = new TGeoVolume("ITSssdSensor5",virtualSSDSensorShape,
1906                                                                                  fSSDAir);
1907   fSSDSensor6 = new TGeoVolume("ITSssdSensor6",virtualSSDSensorShape,
1908                                                                                  fSSDAir);
1909   /////////////////////////////////////////////////////////////
1910   for(Int_t i=0; i<4; i++){
1911             fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1912             ssdsensorinsensitive[1],i<2?1:2,
1913                         new TGeoTranslation(
1914                          0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1915       *   (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1916                         0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1917       *   (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1918             fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1919             ssdsensorinsensitive[1],i<2?1:2,
1920                         new TGeoTranslation(
1921                          0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1922       *   (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1923                         0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1924       *   (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1925   }
1926     fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1927     fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
1928 }
1929 ///////////////////////////////////////////////////////////////////////////////
1930 TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1931   /////////////////////////////////////////////////////////////
1932   // Method generating the Carbon Fiber Support
1933   /////////////////////////////////////////////////////////////
1934   const Int_t kvertexnumber = 4;
1935   const Int_t kshapesnumber = 2;
1936   TVector3** vertexposition[kshapesnumber];
1937   for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1938   Double_t carbonfibersupportxaxisEdgeproj =
1939                 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1940         *       TMath::DegToRad());
1941   Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1942                                  /                         fgkCarbonFiberSupportXAxisLength);
1943   /////////////////////
1944   //Vertex Positioning
1945   ////////////////////
1946   vertexposition[0][0] = new TVector3();
1947   vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
1948                                                                           fgkCarbonFiberSupportYAxisLength);
1949   vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
1950                                                                           carbonfibersupportxaxisEdgeproj
1951                                            *                      TMath::Tan(theta));
1952   vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
1953                                            -                      carbonfibersupportxaxisEdgeproj,
1954                                                                           fgkCarbonFiberSupportYAxisLength
1955                                            -                      vertexposition[0][2]->Y());
1956   ////////////////////////////////////////////////////
1957   //Setting the parameters for Isometry Transformation
1958   ////////////////////////////////////////////////////
1959   Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
1960                                                                  +      fgkCarbonFiberSupportTopEdgeDist[0]
1961                                                                  +      fgkCarbonFiberSupportWidth);
1962   Double_t* param = new Double_t[4];
1963   param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
1964   for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
1965                                   new TVector3((GetReflection(vertexposition[0][j],param))->X(),
1966                                                           (GetReflection(vertexposition[0][j],param))->Y());
1967   char* carbonfibersupportshapename[kshapesnumber] =
1968                                                 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
1969   char* carbonfibersupportname[kshapesnumber] =
1970                                                 {"CarbonFiberSupport1","CarbonFiberSupport2"};
1971   TGeoArb8* carbonfibersupportshape[kshapesnumber];
1972   TGeoVolume* carbonfibersupport[kshapesnumber];
1973   TList* carbonfibersupportlist = new TList();
1974   Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
1975   Double_t carbonfibersupportheight =
1976           carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1977           *TMath::DegToRad());
1978   for(Int_t i = 0; i< kshapesnumber; i++){
1979    carbonfibersupportshape[i] =
1980                                         GetArbShape(vertexposition[i],width,carbonfibersupportheight,
1981                                                                 carbonfibersupportshapename[i],i==0 ? 1: -1);
1982    carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
1983                                                    carbonfibersupportshape[i],fSSDCarbonFiberMedium);
1984    carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
1985    carbonfibersupportlist->Add(carbonfibersupport[i]);
1986    }
1987   /////////////////////////////////////////////////////////////
1988   // Deallocating memory
1989   /////////////////////////////////////////////////////////////
1990   for(Int_t i=0; i< kshapesnumber; i++){
1991      for(Int_t j=0; j< kvertexnumber; j++)
1992            delete vertexposition[i][j];
1993        delete [] vertexposition[i];
1994   }
1995   delete [] param;
1996   /////////////////////////////////////////////////////////////
1997    return carbonfibersupportlist;
1998 }
1999 /////////////////////////////////////////////////////////////////////////////////
2000 TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
2001   /////////////////////////////////////////////////////////////
2002   // Method generating SSD Carbon Fiber Junction
2003   /////////////////////////////////////////////////////////////
2004   const Int_t kvertexnumber = 6;
2005   TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
2006   Double_t reflectionparam[3] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
2007                                                           *  TMath::DegToRad()),-1.,0.};
2008   TVector3* vertex[kvertexnumber];
2009   vertex[0] = new TVector3();
2010   vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
2011                         *                         TMath::Cos(fgkCarbonFiberJunctionAngle[0]
2012                         *                         TMath::DegToRad()),
2013                                                   fgkCarbonFiberJunctionEdge[0]
2014                         *                         TMath::Sin(fgkCarbonFiberJunctionAngle[0]
2015                         *                         TMath::DegToRad()));
2016   vertex[4] = new TVector3(fgkCarbonFiberJunctionLength,
2017                                                    fgkCarbonFiberJunctionEdge[1]);
2018   vertex[5] = new TVector3(fgkCarbonFiberJunctionLength);
2019   vertex[1] = GetReflection(vertex[5],reflectionparam);
2020   vertex[2] = GetReflection(vertex[4],reflectionparam);
2021   Double_t xvertexpoints[6], yvertexpoints[6];
2022   for(Int_t i=0; i<kvertexnumber; i++)
2023           xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
2024   carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2025   carbonfiberjunctionshape->DefineSection(0,-0.5*width);
2026   carbonfiberjunctionshape->DefineSection(1,0.5*width);
2027   TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
2028                                                                 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
2029   carbonfiberjunction->SetLineColor(fColorCarbonFiber);
2030   /////////////////////////////////////////////////////////////
2031   // Deallocating memory
2032   /////////////////////////////////////////////////////////////
2033   for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
2034   /////////////////////////////////////////////////////////////
2035   return carbonfiberjunction;
2036 }
2037 ////////////////////////////////////////////////////////////////////////////////
2038 TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
2039   /////////////////////////////////////////////////////////////
2040   // Method generating the Carbon Fiber Lower Support
2041   /////////////////////////////////////////////////////////////
2042   const Int_t kvertexnumber = 4;
2043   const Int_t kshapesnumber = 2;
2044   Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
2045                                                                 fgkCarbonFiberLowerSupportWidth};
2046   TVector3** vertexposition[kshapesnumber];
2047   for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
2048                                                  new TVector3*[kvertexnumber];
2049   //First Shape Vertex Positioning
2050   vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
2051   vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
2052                                            -            fgkCarbonFiberLowerSupportLowerLenght);
2053   vertexposition[0][2] = new TVector3();
2054   vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
2055   //Second Shape Vertex Positioning
2056   Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
2057                                  -                              fgkCarbonFiberLowerSupportVolumePosition[0])
2058                                  /                              fgkCarbonFiberTriangleLength);
2059   vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
2060                                                                 vertexposition[0][0]->X()*TMath::Tan(theta)
2061                                  +                              fgkCarbonFiberLowerSupportVolumePosition[0]);
2062   vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
2063                                                                 vertexposition[0][1]->X()*TMath::Tan(theta)
2064                                  +                              fgkCarbonFiberLowerSupportVolumePosition[0]);
2065   vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
2066   vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
2067                                                                 fgkCarbonFiberLowerSupportVolumePosition[1]);
2068   char* carbonfiberlowersupportshapename[kshapesnumber] =
2069                           {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
2070   char* carbonfiberlowersupportname[kshapesnumber] =
2071                           {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
2072   TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
2073   TGeoVolume* carbonfiberlowersupport[kshapesnumber];
2074   TList* carbonfiberlowersupportlist = new TList();
2075   for(Int_t i = 0; i< kshapesnumber; i++){
2076         carbonfiberlowersupportshape[i] =
2077                                                                 GetArbShape(vertexposition[i],width,
2078                                                                                         fgkCarbonFiberLowerSupportHeight,
2079                                                                                         carbonfiberlowersupportshapename[i]);
2080     carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
2081                                                 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
2082         carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
2083     carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
2084   }
2085   /////////////////////////////////////////////////////////////
2086   // Deallocating memory
2087   /////////////////////////////////////////////////////////////
2088   for(Int_t i=0; i< kshapesnumber; i++){
2089      for(Int_t j=0; j< kvertexnumber; j++)
2090            delete vertexposition[i][j];
2091        delete [] vertexposition[i];
2092   }
2093   /////////////////////////////////////////////////////////////
2094   return carbonfiberlowersupportlist;
2095 }
2096 ///////////////////////////////////////////////////////////////////////////////
2097 TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
2098                                                                  Double_t width, Double_t* thickness)const{
2099   /////////////////////////////////////////////////////////////
2100   // Method generating the Sensor Support
2101   /////////////////////////////////////////////////////////////
2102         const Int_t kvertexnumber = 6;
2103         TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2104     TVector3* vertexposition[kvertexnumber];
2105         vertexposition[0] = new TVector3();
2106         vertexposition[1] = new TVector3(0.0,length);
2107         vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());
2108         vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);
2109         vertexposition[4] = new TVector3(height,vertexposition[3]->Y());
2110         vertexposition[5] = new TVector3(vertexposition[4]->X());
2111         Double_t xvertexpoints[6], yvertexpoints[6];
2112         for(Int_t i=0; i<kvertexnumber; i++)
2113                 xvertexpoints[i] = vertexposition[i]->X(),
2114                 yvertexpoints[i] = vertexposition[i]->Y();
2115     ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2116     ssdsensorsupportshape->DefineSection(0,-0.5*width);
2117     ssdsensorsupportshape->DefineSection(1,0.5*width);
2118     TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2119                                                                  ssdsensorsupportshape,fSSDSensorSupportMedium);
2120   /////////////////////////////////////////////////////////////
2121   // Deallocating memory
2122   /////////////////////////////////////////////////////////////
2123         for (Int_t i=0; i<kvertexnumber; i++)
2124                 delete vertexposition[i];
2125   /////////////////////////////////////////////////////////////
2126     return ssdsensorsupport;
2127 }
2128 ////////////////////////////////////////////////////////////////////////////////
2129 TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2130   /////////////////////////////////////////////////////////////
2131   // Method generating the Cooling Tube Support
2132   /////////////////////////////////////////////////////////////
2133   if(nedges%2!=0) nedges--;
2134   const Int_t kvertexnumber = nedges+5;
2135   Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2136                            /                     fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2137   Double_t angle = 90.+phi;
2138   Double_t psi = 90.-phi;
2139   ///////////////////////////////////////
2140   // Vertex Positioning for TGeoXTru
2141   ///////////////////////////////////////
2142   TVector3** vertexposition = new TVector3*[kvertexnumber];
2143   vertexposition[0] = new TVector3(fgkCoolingTubeSupportRmin*CosD(angle),
2144                                                                    fgkCoolingTubeSupportRmin*SinD(angle));
2145   vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2146                                                                    fgkCoolingTubeSupportRmax*SinD(angle));
2147   vertexposition[2] = new TVector3(vertexposition[1]->X(),
2148                                                                    fgkCoolingTubeSupportRmax);
2149   vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2150                                                                    fgkCoolingTubeSupportRmax);
2151   vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2152                                                                     vertexposition[1]->Y());
2153   for(Int_t i=0; i<nedges; i++)
2154         vertexposition[i+5] =
2155                 new TVector3(fgkCoolingTubeSupportRmin*CosD(psi+i*(2.*phi/nedges)),
2156                                          fgkCoolingTubeSupportRmin*SinD(psi+i*(2.*phi/nedges)));
2157   ///////////////////////////////////////////////////////////////////////
2158   // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2159   ///////////////////////////////////////////////////////////////////////
2160   TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2161   Double_t* xvertexpoints = new Double_t[kvertexnumber];
2162   Double_t* yvertexpoints = new Double_t[kvertexnumber];
2163   for(Int_t i=0; i<kvertexnumber; i++){
2164         xvertexpoints[i] = vertexposition[i]->X();
2165         yvertexpoints[i] = vertexposition[i]->Y();
2166   }
2167   coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2168                                                                                         yvertexpoints);
2169   coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2170   coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2171   TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2172                                                                           coolingtubesupportarcshape,
2173                                                                                   fSSDTubeHolderMedium);
2174   coolingtubesupportarc->SetLineColor(fColorG10);
2175   //////////////////////////////////////////////////////////////////////////
2176   // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2177   //////////////////////////////////////////////////////////////////////////
2178   TGeoTubeSeg* coolingtubesupportsegshape =
2179                                                         new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2180                                                                                         fgkCoolingTubeSupportRmax,
2181                                                                                         0.5*fgkCoolingTubeSupportWidth,
2182                                                                                         phi,360-phi);
2183   TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2184                                                                                         coolingtubesupportsegshape,
2185                                                                                         fSSDTubeHolderMedium);
2186   coolingtubesupportseg->SetLineColor(fColorG10);
2187   //////////////////////////////////////////////////////////////////////////
2188   // TGeoBBox Volume definition for Cooling Tube Support Box Part
2189   //////////////////////////////////////////////////////////////////////////
2190   Double_t* boxorigin = new Double_t[3];
2191   Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2192   boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2193   TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2194                                                                                  0.5*fgkCoolingTubeSupportHeight,
2195                                                                                  0.5*fgkCoolingTubeSupportWidth,boxorigin);
2196   TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2197                                coolingtubesupportboxshape,fSSDTubeHolderMedium);
2198   coolingtubesupportbox->SetLineColor(fColorG10);
2199   //////////////////////////////////////////////////////////////////////////
2200   // Cooling Tube for Cooling Tube Support
2201   //////////////////////////////////////////////////////////////////////////
2202   TGeoXtru* coolingtubearcshape[2];
2203   coolingtubearcshape[0] = new TGeoXtru(2);
2204   Double_t* xvert = new Double_t[nedges+2];
2205   Double_t* yvert = new Double_t[nedges+2];
2206   Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2207   ////////////////////////////////////////
2208   // Positioning the vertices for TGeoXTru
2209   ////////////////////////////////////////
2210   xvert[0] = 0., yvert[0] = 0.;
2211   xvert[1] = vertexposition[0]->X()*ratio,  yvert[1] = vertexposition[0]->Y()*ratio;
2212   for(Int_t i=0; i< nedges; i++)
2213                 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2214                 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2215   ////////////////////////////////////////
2216   // Defining TGeoXTru PolyGone
2217   ////////////////////////////////////////
2218   coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2219   coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2220   coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2221   coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2222                 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2223   TGeoVolume* coolingtubearc[2];
2224   coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2225                                                                   coolingtubearcshape[0],fSSDCoolingTubeWater);
2226   coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2227                                                                   coolingtubearcshape[1],fSSDCoolingTubePhynox);
2228   coolingtubearc[0]->SetLineColor(fColorWater);
2229   coolingtubearc[1]->SetLineColor(fColorPhynox);
2230   ////////////////////////////////////////////
2231   // Defining TGeoTubeSeg Part of Cooling Tube
2232   ////////////////////////////////////////////
2233   TGeoTubeSeg* coolingtubesegshape[2];
2234   coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2235                                                         0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2236   coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2237                                                         0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2238   TGeoVolume* coolingtubeseg[2];
2239   coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2240                                                                  coolingtubesegshape[0],fSSDCoolingTubePhynox);
2241   coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2242                                                                  coolingtubesegshape[1],fSSDCoolingTubeWater);
2243   coolingtubeseg[0]->SetLineColor(fColorPhynox);
2244   coolingtubeseg[1]->SetLineColor(fColorWater);
2245   /////////////////////////////////////////////////////////////
2246   // Virtual Volume containing Cooling Tube Support
2247   /////////////////////////////////////////////////////////////
2248   TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2249   const Int_t kvirtualvertexnumber = 8;
2250   TVector3* virtualvertex[kvirtualvertexnumber];
2251    ////////////////////////////////////////
2252   // Positioning the vertices for TGeoXTru
2253   ////////////////////////////////////////
2254   virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax);
2255   virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
2256   virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
2257   virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
2258   virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
2259   virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
2260   virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
2261   virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
2262   Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2263   for(Int_t i=0; i< kvirtualvertexnumber; i++)
2264         xmothervertex[i] = virtualvertex[i]->X(),
2265         ymothervertex[i] = virtualvertex[i]->Y();
2266   ////////////////////////////////////////
2267   // Defining TGeoXTru PolyGone
2268   ////////////////////////////////////////
2269   virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2270                                                                                                                                          ymothervertex);
2271   virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2272   virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2273   TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2274                                                                  virtualCoolingTubeSupportShape,fSSDAir);
2275   ////////////////////////////////////////
2276   // Positioning Volumes in Virtual Volume
2277   ////////////////////////////////////////
2278   TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2279   coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2280   virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2281   virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2282   virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
2283   virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2284   virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2285   virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2286   virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
2287   /////////////////////////////////////////////////////////////
2288   // Deallocating memory
2289   /////////////////////////////////////////////////////////////
2290   delete [] vertexposition;
2291   delete xvertexpoints;
2292   delete yvertexpoints;
2293   delete xvert;
2294   delete yvert;
2295   for(Int_t i=0; i< kvirtualvertexnumber; i++)
2296         delete virtualvertex[i];
2297   /////////////////////////////////////////////////////////////
2298         return virtualcoolingtubesupport;
2299 }
2300 /////////////////////////////////////////////////////////////////////////////////
2301 TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2302   /////////////////////////////////////////////////////////////
2303   // Method generating List containing SSD Hybrid Components
2304   /////////////////////////////////////////////////////////////
2305   TList* ssdhybridlist = new TList();
2306   const Int_t kssdstiffenernumber = 2;
2307   Double_t ssdstiffenerseparation = fgkSSDSensorLength
2308                                                                   - 2.*fgkSSDModuleStiffenerPosition[1]
2309                                                                   -    fgkSSDStiffenerWidth;
2310   Double_t ssdchipcablesradius[kssdstiffenernumber];
2311   for(Int_t i=0; i<kssdstiffenernumber; i++)
2312           ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2313                                -  fgkSSDChipCablesHeight[0]
2314                                -  fgkSSDChipCablesHeight[1]);
2315   /////////////////////////////////////////////////////////////
2316   // Mother Volumes Containers
2317   /////////////////////////////////////////////////////////////
2318   const Int_t kmothernumber = 2;
2319   const Int_t kmothervertexnumber = 12;
2320   Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2321   Double_t ymothervertex[kmothernumber][kmothervertexnumber];
2322   ///////////////////////
2323   // Setting the vertices
2324   ///////////////////////
2325   xmothervertex[0][0]  = -0.5*fgkSSDStiffenerLength;
2326   xmothervertex[0][1]  = xmothervertex[0][0];
2327   xmothervertex[0][2]  = fgkSSDFlexLength[0]-0.5*fgkSSDStiffenerLength;
2328   xmothervertex[0][3]  = xmothervertex[0][2];
2329   xmothervertex[0][4]  = xmothervertex[0][0];
2330   xmothervertex[0][5]  = xmothervertex[0][4];
2331   xmothervertex[0][6]  = -xmothervertex[0][0];
2332   xmothervertex[0][7]  = xmothervertex[0][6];
2333   xmothervertex[0][8]  = -xmothervertex[0][2];
2334   xmothervertex[0][9]  = xmothervertex[0][8];
2335   xmothervertex[0][10] = xmothervertex[0][7];
2336   xmothervertex[0][11] = xmothervertex[0][10];
2337   for(Int_t i=0; i<kmothervertexnumber; i++) xmothervertex[1][i] = xmothervertex[0][i];
2338   for(Int_t i = 0; i<kmothernumber; i++){
2339       ymothervertex[i][0]  = -(fgkSSDChipWidth-(0.5*fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist)
2340                            + ssdchipcablesradius[i]+fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]);
2341       ymothervertex[i][1]  = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexWidth[0];
2342       ymothervertex[i][2]  = ymothervertex[i][1];
2343       ymothervertex[i][3]  = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth;
2344       ymothervertex[i][4]  = ymothervertex[i][3];
2345       ymothervertex[i][5]  = ymothervertex[i][4]+0.5*fgkSSDStiffenerWidth-ymothervertex[i][0];
2346       ymothervertex[i][6]  = ymothervertex[i][5];
2347       ymothervertex[i][7]  = 0.5*fgkSSDStiffenerWidth+fgkSSDFlexWidth[0];
2348       ymothervertex[i][8]  = ymothervertex[i][7];
2349       ymothervertex[i][9]  = 0.5*fgkSSDStiffenerWidth;
2350       ymothervertex[i][10] = ymothervertex[i][9];
2351       ymothervertex[i][11] = ymothervertex[i][0];
2352   }
2353   TGeoXtru* ssdhybridmothershape[kmothernumber];
2354   TGeoVolume* ssdhybridmother[kmothernumber];
2355   const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2356   for(Int_t i=0; i<kmothernumber; i++){
2357       ssdhybridmothershape[i] = new TGeoXtru(2);
2358       ssdhybridmothershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
2359                                           ymothervertex[i]);
2360       ssdhybridmothershape[i]->DefineSection(0,-0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2361                                                -fgkSSDChipCablesHeight[i+2]);
2362       ssdhybridmothershape[i]->DefineSection(1, 0.5*fgkSSDStiffenerHeight);
2363       ssdhybridmother[i] = new TGeoVolume(ssdhybridmothername[i],ssdhybridmothershape[i],
2364                                           fSSDAir);
2365    }
2366   /////////////////////////////////////////////////////////////
2367   // SSD Stiffener
2368   /////////////////////////////////////////////////////////////
2369   TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2370                                              0.5*fgkSSDStiffenerLength,
2371                                              0.5*fgkSSDStiffenerWidth,
2372                                              0.5*fgkSSDStiffenerHeight);
2373   TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2374                                             fSSDStiffenerMedium);
2375   ssdstiffener->SetLineColor(fColorStiffener);
2376   TGeoTranslation* ssdstiffenertrans[kssdstiffenernumber];
2377   for(Int_t i=0; i<kssdstiffenernumber; i++)
2378       ssdstiffenertrans[i] = new TGeoTranslation(0.,i*ssdstiffenerseparation,0.);
2379   /////////////////////////////////////////////////////////////
2380   // SSD Chip System
2381   /////////////////////////////////////////////////////////////
2382   TList* ssdchipsystemlist = GetSSDChipSystem();
2383   Double_t ssdchipseparation = fgkSSDSensorLength
2384                              - 2.*fgkSSDModuleStiffenerPosition[1]
2385                              - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
2386                              - 0.5*fgkSSDChipWidth);
2387   Double_t ssdchipsystemlength = (fgkSSDChipNumber-1)*(fgkSSDChipLength
2388                                +  fgkSSDChipSeparationLength)+fgkSSDChipCablesLength[1];
2389   TGeoTranslation* ssdchipsystemtrans = new TGeoTranslation(0.5*fgkSSDChipCablesLength[1]
2390                                       - 0.5*ssdchipsystemlength,
2391                                         0.5*(ssdstiffenerseparation-ssdchipseparation),
2392                                       - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight));
2393 ////////////////////////////
2394 // Capacitor 0603-2200 nF
2395 ///////////////////////////
2396   const Int_t knapacitor0603number = 5;
2397   TGeoBBox* capacitor0603shape =  new TGeoBBox("Capacitor0603Shape",
2398                                                                                          0.5*fgkSSDCapacitor0603Length,
2399                                                                                          0.5*fgkSSDCapacitor0603Width,
2400                                                                                          0.5*fgkSSDCapacitor0603Height);
2401   TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
2402                                              fSSDStiffener0603CapacitorMedium);
2403   capacitor0603->SetLineColor(fColorAl);
2404   for(Int_t i=0; i<kmothernumber; i++){
2405       for(Int_t j=0; j<kssdstiffenernumber; j++){
2406             ssdhybridmother[i]->AddNode(ssdstiffener,j+1,ssdstiffenertrans[j]);
2407             for(Int_t k=1; k<knapacitor0603number+1; k++){
2408                   ssdhybridmother[i]->AddNode(capacitor0603,knapacitor0603number*j+k,
2409                         new TGeoTranslation((k-3.)/6*fgkSSDStiffenerLength,
2410                                              j*ssdstiffenerseparation
2411                         +                    0.5*((j==0? 1:-1)*fgkSSDStiffenerWidth
2412                         +                    (j==0? -1:+1)*fgkSSDCapacitor0603Width),
2413                         -                    0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
2414             }
2415       }
2416       ssdhybridmother[i]->AddNode((TGeoVolume*)ssdchipsystemlist->At(i),i+1,ssdchipsystemtrans);
2417       ssdhybridlist->Add(ssdhybridmother[i]);
2418   }
2419 /////////////////////////////////////////////////////////////
2420 // Mother Volume Containing Capacitor Part
2421 /////////////////////////////////////////////////////////////
2422   const Int_t kcapacitormothernumber = 8;
2423   Double_t xcapacitorvertex[kcapacitormothernumber];
2424   Double_t ycapacitorvertex[kcapacitormothernumber];
2425   ///////////////////////
2426   // Setting the vertices
2427   ///////////////////////
2428   xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2429   xcapacitorvertex[1] = xcapacitorvertex[0];
2430   xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2431   xcapacitorvertex[3] = xcapacitorvertex[2];
2432   xcapacitorvertex[4] = xcapacitorvertex[0];
2433   xcapacitorvertex[5] = xcapacitorvertex[0];
2434   xcapacitorvertex[6] = -xcapacitorvertex[0];
2435   xcapacitorvertex[7] = xcapacitorvertex[6];
2436   ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2437   ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2438   ycapacitorvertex[2] = ycapacitorvertex[1];
2439   ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2440   ycapacitorvertex[4] = ycapacitorvertex[3];
2441   ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2442   ycapacitorvertex[6] = ycapacitorvertex[5];
2443   ycapacitorvertex[7] = ycapacitorvertex[0];
2444   TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2445   ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2446                                               ycapacitorvertex);
2447   ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2448   ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
2449   TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2450                                           fSSDAir);
2451 ////////////////////////////
2452 // Connector
2453 ///////////////////////////
2454   const Int_t kssdconnectornumber = 2;
2455   TGeoBBox* ssdconnectorshape[kssdconnectornumber];
2456   Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2457   Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2458                                    +  fgkSSDConnectorAlHeight};
2459   const char* ssdconnectorname[kssdconnectornumber] = {"SSDConnectorAl","SSDConnectorNi"};
2460   TGeoVolume* ssdconnector[kssdconnectornumber];
2461   for(Int_t i=0; i<kssdconnectornumber; i++){
2462       ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2463                                           0.5*fgkSSDConnectorWidth,
2464                                           0.5*((1-i)*fgkSSDConnectorAlHeight
2465                            +              i*fgkSSDConnectorNiHeight),
2466                              i==0? ssdAlconnectororigin : ssdNiconnectororigin);
2467       ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
2468                                        i==0 ? fSSDAlTraceFlexMedium
2469                                             : fSSDStiffenerConnectorMedium);
2470       ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorPhynox);
2471   }
2472   TGeoTranslation* ssdconnectortrans[2*kssdconnectornumber];
2473   ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2474                        +  fgkSSDConnectorPosition[0]
2475                        -  fgkSSDConnectorSeparation
2476                        -  1.5*fgkSSDConnectorLength,
2477                           ssdstiffenerseparation+ssdstiffenershape->GetDY()
2478                        -  fgkSSDConnectorPosition[1]
2479                        -  ssdconnectorshape[0]->GetDY(),0.0);
2480   ssdconnectortrans[1] = new TGeoTranslation(
2481                        -  ssdstiffenershape->GetDX()
2482                        +  fgkSSDConnectorPosition[0]
2483                        -  0.5*fgkSSDConnectorLength,
2484                           ssdstiffenerseparation+ssdstiffenershape->GetDY()
2485                        -  fgkSSDConnectorPosition[1]
2486                        -  ssdconnectorshape[0]->GetDY(),0.0);
2487   ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2488                        -  fgkSSDConnectorPosition[0]
2489                        +  fgkSSDConnectorSeparation
2490                        +  1.5*fgkSSDConnectorLength,
2491                           -(ssdstiffenershape->GetDY()
2492                        -  fgkSSDConnectorPosition[1]
2493                        -  ssdconnectorshape[0]->GetDY()),0.0);
2494   ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2495                        -  fgkSSDConnectorPosition[0]
2496                        +  0.5*fgkSSDConnectorLength,
2497                           -(ssdstiffenershape->GetDY()
2498                        -  fgkSSDConnectorPosition[1]
2499                        -  ssdconnectorshape[0]->GetDY()),0.0);
2500   for(Int_t i=0; i<2*kssdconnectornumber; i++)
2501       for(Int_t j=0; j<kssdconnectornumber; j++)
2502             ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2503 ////////////////////////////
2504 // Capacitor 1812-330 nF
2505 ///////////////////////////
2506   Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
2507   TGeoBBox* capacitor1812shape =  new TGeoBBox("Capacitor1812Shape",
2508                                                                                          0.5*fgkSSDCapacitor1812Length,
2509                                                                                          0.5*fgkSSDCapacitor1812Width,
2510                                                                                          0.5*fgkSSDCapacitor1812Height,
2511             ssdcapacitor1812origin);
2512   TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2513                                              fSSDStiffener1812CapacitorMedium);
2514   capacitor1812->SetLineColor(fColorAl);
2515   TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2516                                         0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2517                                       - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.0);
2518   ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
2519 ////////////////////////////
2520 //Hybrid Wire
2521 ////////////////////////////
2522   Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
2523                                  - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2524                                  - fgkSSDConnectorSeparation;
2525   Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
2526                                  - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
2527   Double_t ssdwireradius = TMath::Sqrt(TMath::Power(wirex,2.)
2528                                          + TMath::Power(wirey,2));
2529   Double_t wireangle = TMath::ATan(wirex/wirey);
2530   TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2531                                                 fgkSSDWireRadius, 0.5*ssdwireradius);
2532   TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2533                                              fSSDStiffenerHybridWireMedium);
2534   hybridwire->SetLineColor(fColorPhynox);
2535   TGeoCombiTrans* hybridwirecombitrans[2];
2536   hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
2537                    0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2538                                  + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
2539                    0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
2540                                  + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
2541                                    ssdstiffenershape->GetDZ()
2542                                  + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight,
2543                    new TGeoRotation("HybridWireRot1",0.,90.,0.));
2544   hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
2545                             0.0,
2546                           - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2547                             0.0,
2548                             new TGeoRotation("HybridWireRot2",
2549                           - wireangle*TMath::RadToDeg(),0.,0.));
2550   TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2551   hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2552   hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
2553   ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2554   ssdhybridlist->Add(ssdhybridcapacitormother);
2555   /////////////////////////////////////////////////////////////
2556   // Deallocating memory
2557   /////////////////////////////////////////////////////////////
2558   delete hybridwirecombitrans[0];
2559   delete hybridwirecombitrans[1];
2560   delete ssdchipsystemlist;
2561   return ssdhybridlist;
2562   /////////////////////////////////////////////////////////////
2563 }
2564 ///////////////////////////////////////////////////////////////////////////////
2565 TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2566   /////////////////////////////////////////////////////////////
2567   // SSD Cooling Block System
2568   /////////////////////////////////////////////////////////////
2569   // SSD Cooling Block and Cooling Tube Transformations
2570   /////////////////////////////////////////////////////////////
2571   TGeoRotation* localcoolingblockrot = new TGeoRotation();
2572   localcoolingblockrot->SetAngles(0.,90.,0.);
2573   TGeoCombiTrans* localcoolingblockmatrix =
2574         new TGeoCombiTrans(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
2575   TGeoTranslation* localcoolingblocktrans;
2576   TVector3* coolingblocktransvector;
2577   coolingblocktransvector = new TVector3(fgkSSDModuleSensorSupportDistance
2578                                                                 + fgkSSDCoolingBlockLength,
2579                                                                   fgkSSDSensorLength
2580                                                                 - 2.*fgkSSDModuleStiffenerPosition[1]
2581                                                                 - fgkSSDCoolingBlockWidth);
2582   const Int_t kcoolingblocktransnumber = 2;
2583   const Int_t kcoolingblocknumber = 4;
2584   TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
2585   TGeoHMatrix* coolingtubematrix[kcoolingblocknumber];
2586   TGeoRotation* localcoolingtuberot = new TGeoRotation();
2587   localcoolingtuberot->SetAngles(0.0,90.0,0.0);
2588   TGeoTranslation* localcoolingtubetrans = new TGeoTranslation();
2589   localcoolingtubetrans->SetTranslation(0.5*fgkSSDCoolingBlockLength,
2590                                                                                 0.5*fgkSSDCoolingBlockWidth,
2591                                                                                         fgkSSDCoolingBlockHoleCenter);
2592   TGeoCombiTrans* localcoolingtubematrix = new TGeoCombiTrans(*localcoolingtubetrans,
2593                                                                                                                           *localcoolingtuberot);
2594   Double_t coolingtubedistance = fgkCoolingTubeSupportRmax-fgkCoolingTubeSupportRmin;
2595   for(Int_t i=0; i<kcoolingblocktransnumber; i++){
2596           for(Int_t j=0; j<kcoolingblocktransnumber; j++){
2597                 localcoolingblocktrans=
2598                      new TGeoTranslation(i*coolingblocktransvector->X()+2*coolingtubedistance,
2599                                                                  j*coolingblocktransvector->Y(),
2600                                                                  - 0.5*(fgkSSDCoolingBlockHoleCenter
2601                                                              + fgkCoolingTubeRmax));
2602                 coolingblockmatrix[2*i+j] = new TGeoHMatrix((*localcoolingblocktrans)
2603                                                                  *(*localcoolingblockmatrix));
2604                 coolingtubematrix[2*i+j] = new TGeoHMatrix((*localcoolingblocktrans)
2605                                                                  *(*localcoolingtubematrix));
2606         }
2607   }
2608   /////////////////////////////////////////////////////////////
2609   // Virtual Volume containing CoolingBlock System
2610   /////////////////////////////////////////////////////////////
2611   TGeoXtru* coolingsystemothershape = new TGeoXtru(2);
2612   const Int_t kmothervertexnumber = 16;
2613   Double_t xmothervertex[kmothervertexnumber];
2614   Double_t ymothervertex[kmothervertexnumber];
2615   ///////////////////////
2616   // Setting the vertices
2617   ///////////////////////fgkCoolingTubeSupportRmax
2618   xmothervertex[0] = 0.0,ymothervertex[0] = 0.0;
2619   xmothervertex[1] = xmothervertex[0], ymothervertex[1] = coolingblocktransvector->Y()
2620                                    + fgkSSDCoolingBlockWidth;
2621   xmothervertex[2] = coolingblocktransvector->X()
2622                                    + fgkSSDCoolingBlockLength
2623                                    + 4*coolingtubedistance;
2624   ymothervertex[2] = ymothervertex[1];
2625   xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
2626   xmothervertex[4] = xmothervertex[3]-2.*coolingtubedistance-fgkSSDCoolingBlockLength;
2627   ymothervertex[4] = ymothervertex[0];
2628   xmothervertex[5] = xmothervertex[4], ymothervertex[5] = fgkSSDCoolingBlockWidth;
2629   xmothervertex[6] = xmothervertex[3]-coolingtubedistance;
2630   ymothervertex[6] = ymothervertex[5];
2631   xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
2632                                    - fgkSSDCoolingBlockWidth;
2633   xmothervertex[8] = xmothervertex[5], ymothervertex[8] = ymothervertex[7];
2634   xmothervertex[9] = xmothervertex[8], ymothervertex[9] = ymothervertex[2]
2635                                    - coolingtubedistance;
2636   xmothervertex[10] = fgkSSDCoolingBlockLength+2.*coolingtubedistance;
2637   ymothervertex[10] = ymothervertex[9];
2638   xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[8];
2639   xmothervertex[12] = coolingtubedistance, ymothervertex[12] = ymothervertex[11];
2640   xmothervertex[13] = xmothervertex[12], ymothervertex[13] = fgkSSDCoolingBlockWidth;
2641   xmothervertex[14] = 2.*coolingtubedistance+fgkSSDCoolingBlockLength;
2642   ymothervertex[14] = ymothervertex[13];
2643   xmothervertex[15] = xmothervertex[14], ymothervertex[15] = ymothervertex[0];
2644   //////////////////////////////////////////////////////////
2645   coolingsystemothershape->DefinePolygon(kmothervertexnumber,
2646                                                                         xmothervertex,ymothervertex);
2647   coolingsystemothershape->DefineSection(0,-0.5*(fgkSSDCoolingBlockHoleCenter
2648                                                                                            + fgkCoolingTubeRmax));
2649   coolingsystemothershape->DefineSection(1, 0.5*(fgkSSDCoolingBlockHoleCenter
2650                                                                                            + fgkCoolingTubeRmax));
2651   TGeoVolume* coolingsystemother = new TGeoVolume("CoolingBlockSystem",
2652                                                           coolingsystemothershape,fSSDAir);
2653   /////////////////////////////////////////////////////////////
2654   // SSD Cooling Tube Part
2655   /////////////////////////////////////////////////////////////
2656   TGeoTube* coolingtubeshape[fgkcoolingtubenumber];
2657   coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2658                                                                                  0.5*fgkSSDCoolingBlockWidth);
2659   coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
2660                                                                          0.5*fgkSSDCoolingBlockWidth);
2661   TGeoVolume* coolingtube[fgkcoolingtubenumber];
2662   coolingtube[0] = new TGeoVolume("OuterCoolingTube",coolingtubeshape[0],
2663                                                                         fSSDCoolingTubePhynox);
2664   coolingtube[1] = new TGeoVolume("InnerCoolingTube",coolingtubeshape[1],
2665                                                                         fSSDCoolingTubeWater);
2666   coolingtube[0]->SetLineColor(fColorPhynox);
2667   coolingtube[1]->SetLineColor(fColorWater);
2668   TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2669   /////////////////////////////////////////////////////////////
2670   // Adding Cooling block to mother volume
2671   /////////////////////////////////////////////////////////////
2672    for(Int_t i=0; i<kcoolingblocknumber; i++){
2673         coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
2674         coolingsystemother->AddNode(coolingtube[0],i+1,coolingtubematrix[i]);
2675         coolingsystemother->AddNode(coolingtube[1],i+1,coolingtubematrix[i]);
2676   }
2677   /////////////////////////////////////////////////////////////
2678   // Deallocating memory
2679   /////////////////////////////////////////////////////////////
2680         delete coolingblocktransvector;
2681     delete localcoolingblocktrans;
2682         delete localcoolingblockrot;
2683         delete localcoolingblockmatrix;
2684         delete localcoolingtubetrans;
2685         delete localcoolingtuberot;
2686   /////////////////////////////////////////////////////////////
2687   // Checking overlaps
2688   /////////////////////////////////////////////////////////////
2689         //coolingsystemother->CheckOverlaps(0.01);
2690   /////////////////////////////////////////////////////////////
2691         return coolingsystemother;
2692 }
2693 /////////////////////////////////////////////////////////////////////////////////
2694 TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
2695   /////////////////////////////////////////////////////////////
2696   // SSD Flex
2697   /////////////////////////////////////////////////////////////
2698   const Int_t kssdflexlayernumber = 2;
2699   TGeoXtru* ssdflexshape[kssdflexlayernumber];
2700   for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2701   const Int_t kmothervertexnumber = 17;
2702   Double_t xmothervertex[kmothervertexnumber];
2703   Double_t ymothervertex[kmothervertexnumber];
2704   /////////////////////////////////////////////
2705   // Auxiliary variables for vertex positioning
2706   /////////////////////////////////////////////
2707   const Int_t kssdflexboxnumber = 5;
2708   Double_t ssdflexboxlength[kssdflexboxnumber];
2709   ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
2710                                           *     fgkSSDChipLength+(fgkSSDChipNumber-1)
2711                                           *     fgkSSDChipSeparationLength
2712                                           - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2713                                           - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
2714   ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2715   ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
2716                                           -     fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
2717   ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2718   ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2719                                           -     ssdflexboxlength[1];
2720   Double_t ssdflexboxwidth[kssdflexboxnumber];
2721   ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2722   ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2723   ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2724   ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2725   ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
2726   ///////////////////////
2727   // Setting the vertices
2728   ///////////////////////
2729   xmothervertex[0]  = 0.0;
2730   xmothervertex[1]  = xmothervertex[0];
2731   xmothervertex[2]  = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2732   xmothervertex[3]  = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2733                                         + ssdflexboxlength[4];
2734   xmothervertex[4]  = xmothervertex[3];
2735   xmothervertex[5]  = xmothervertex[4]-ssdflexboxlength[4];
2736   xmothervertex[6]  = xmothervertex[5];
2737   xmothervertex[7]  = xmothervertex[6]-fgkSSDFlexHoleLength;
2738   xmothervertex[8]  = xmothervertex[7];
2739   xmothervertex[9]  = xmothervertex[8]-ssdflexboxlength[2];
2740   xmothervertex[10] = xmothervertex[9];
2741   xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2742   xmothervertex[12] = xmothervertex[11];
2743   xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2744   xmothervertex[14] = xmothervertex[13];
2745   xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2746   xmothervertex[16] = xmothervertex[15];
2747   ymothervertex[0]  = 0.0;
2748   ymothervertex[1]  = fgkSSDFlexWidth[1];
2749   ymothervertex[2]  = fgkSSDFlexWidth[0];
2750   ymothervertex[3]  = ymothervertex[2];
2751   ymothervertex[4]  = ymothervertex[0];
2752   ymothervertex[5]  = ymothervertex[4];
2753   ymothervertex[6]  = ssdflexboxwidth[2];
2754   ymothervertex[7]  = ymothervertex[6];
2755   ymothervertex[8]  = ymothervertex[0];
2756   ymothervertex[9]  = ymothervertex[8];
2757   ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2758   ymothervertex[11] = ymothervertex[10];
2759   ymothervertex[12] = ymothervertex[0];
2760   ymothervertex[13] = ymothervertex[12];
2761   ymothervertex[14] = ymothervertex[7];
2762   ymothervertex[15] = ymothervertex[14];
2763   ymothervertex[16] = ymothervertex[0];
2764   /////////////////////////////////////////////////////////////
2765   // First Mother Volume containing SSDFlex
2766   /////////////////////////////////////////////////////////////
2767   TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2768   ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2769                                                                     ymothervertex);
2770   ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2771   ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
2772   TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2773                                                                                          fSSDAir);
2774   /////////////////////////////////////////////////////////////
2775   // SSDFlex Layer Shapes
2776   /////////////////////////////////////////////////////////////
2777   for(Int_t i=0; i<kssdflexlayernumber; i++){
2778         ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2779                                                                    ymothervertex);
2780     ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2781         ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2782   }
2783   /////////////////////////////////////
2784   // Setting Layers into Mother Volume
2785   /////////////////////////////////////
2786   Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2787   TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2788                                                                                                  fSSDKaptonFlexMedium};
2789   const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2790                                                                                                         "AlFlexLay2","KaptonFlexLay2"};
2791   TGeoVolume* ssdflex[2*kssdflexlayernumber];
2792   TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2793   for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2794         ssdflex[i] = new TGeoVolume(ssdflexname[i],
2795                                                                 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2796                                                                 i%2==0 ? ssdflexmed[0]   : ssdflexmed[1]);
2797         ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2798     ssdflextrans[i]  = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2799                                          +                                         fgkSSDFlexHeight[1]));
2800     ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2801   }
2802   //ssdflexmother->CheckOverlaps(0.01);
2803   return ssdflexmother;
2804 }
2805 /////////////////////////////////////////////////////////////////////////////////
2806 TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
2807   /////////////////////////////////////////////////////////////
2808   // Method generating SSD End Flex
2809   /////////////////////////////////////////
2810   Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2811                                                         /  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2812   Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2813                                                 * TMath::DegToRad()*ssdflexradiusmax
2814                                                 - fgkSSDFlexLength[2]-TMath::Pi()
2815                                                 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
2816   const Int_t knedges = 20;
2817   const Int_t karcnumber = 2;
2818   TVector3* vertexposition[karcnumber*(knedges+1)];
2819   Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2820   Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2821   Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2822   Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2823                                                                                  - 90.0*TMath::DegToRad()};
2824   TVector3* referencetrans[karcnumber];
2825   referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2826                                         +                          radius[0]*SinD(2.*fgkSSDFlexAngle),
2827                                                                    radius[0]);
2828   referencetrans[1] = new TVector3(referencetrans[0]->X()
2829                                         +              fgkSSDFlexLength[2],
2830      -              fgkSSDStiffenerHeight);
2831 for(Int_t i=0; i<karcnumber; i++){
2832         for(Int_t j=0; j<knedges+1; j++){
2833                 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2834                                                                                                radius[i]*SinD(angle[i]));
2835                 angle[i] +=  deltangle[i]*(1.0-2.0*i);
2836         }
2837   }
2838   ///////////////////////
2839   // Setting the vertices
2840   ///////////////////////
2841   const Int_t kendflexlayernumber = 4;
2842   const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2843   TVector3** vertex[kendflexlayernumber];
2844   for(Int_t i=0; i<kendflexlayernumber; i++)
2845                                         vertex[i] = new TVector3*[kendflexvertexnumber];
2846   TVector3* transvector[kendflexlayernumber+1];
2847   TVector3* deltatransvector = new TVector3();
2848   for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2849   transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2850                                 +                radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2851   for(Int_t i=1; i<kendflexlayernumber+1; i++){
2852         deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2853                                         *                 CosD(fgkSSDFlexAngle),
2854                                                           (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2855                                         *         SinD(fgkSSDFlexAngle),0.0);
2856         *transvector[i] = *transvector[i-1]+*deltatransvector;
2857   }
2858   Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2859   ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2860   for(Int_t i=0; i<karcnumber; i++){
2861         for(Int_t j=1; j<kendflexlayernumber+1; j++){
2862                 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2863                                                   * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2864                                               /radius[i];
2865         }
2866   }
2867   for(Int_t i=0; i<kendflexlayernumber; i++){
2868         vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
2869         vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
2870         for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2871                 if(j<(knedges+1)){
2872                         vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2873                                                                                   vertexposition[j]->Y()*ratioradius[0][i+1]);
2874                         vertex[i][j+2]->RotateZ(referenceangle[0]);
2875                         *vertex[i][j+2] += *referencetrans[0];
2876                         vertex[i][4*(knedges+1)-j+1] =
2877                                                          new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2878                                                                                   vertexposition[j]->Y()*ratioradius[0][i]);
2879                         vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2880                         *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2881                 }
2882                 else{
2883
2884                         vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2885                                                                                   vertexposition[j]->Y()*ratioradius[1][i+1]);
2886                         vertex[i][j+2]->RotateZ(referenceangle[1]);
2887                         *vertex[i][j+2] += *referencetrans[1];
2888                         vertex[i][4*(knedges+1)-j+1] =
2889                                                          new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2890                                                                                   vertexposition[j]->Y()*ratioradius[1][i]);
2891                         vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2892                         *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2893            }
2894         }
2895   }
2896   /////////////////////////////////////////////////////////////
2897   // First Mother Volume containing SSDEndFlex
2898   /////////////////////////////////////////////////////////////
2899   TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2900   Double_t xmothervertex[kendflexvertexnumber];
2901   Double_t ymothervertex[kendflexvertexnumber];
2902   xmothervertex[0] = vertex[0][0]->X();
2903   ymothervertex[0] = vertex[0][0]->Y();
2904   for(Int_t i=1; i<kendflexvertexnumber; i++){
2905         if(i<2*(knedges+1)+2){
2906                 xmothervertex[i] = vertex[3][i]->X();
2907                 ymothervertex[i] = vertex[3][i]->Y();
2908         }
2909         else{
2910                 xmothervertex[i] = vertex[0][i]->X();
2911                 ymothervertex[i] = vertex[0][i]->Y();
2912         }
2913   }
2914   ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2915                                                                            xmothervertex,ymothervertex);
2916   ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2917   ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2918   TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2919                                                                  ssdendflexmothershape,fSSDAir);
2920   //////////////////////////////////////
2921   // End Flex TGeoXtru Layer Definition
2922   //////////////////////////////////////
2923   TGeoXtru* ssdendflexshape[kendflexlayernumber];
2924   TGeoVolume* ssdendflex[kendflexlayernumber];
2925   for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2926   Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2927   Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2928   Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2929   TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2930                                                                                                         fSSDKaptonFlexMedium};
2931   const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2932                                                                                                          "AlEndFlexLay2","KaptonEndFlexLay2"};
2933   for(Int_t i=0; i<kendflexlayernumber; i++){
2934         for(Int_t j=0; j<4*(knedges+1)+2; j++){
2935                 xvertex[i][j] = vertex[i][j]->X();
2936                 yvertex[i][j] = vertex[i][j]->Y();
2937         }
2938   ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2939   ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2940   ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2941   ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2942                                                                  i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2943   ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2944   ssdendflexmother->AddNode(ssdendflex[i],1);
2945   }
2946   /////////////////////////////////////////////////////////////
2947   // Deallocating memory
2948   /////////////////////////////////////////////////////////////
2949   for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2950   for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2951   for(Int_t i=0; i<kendflexlayernumber; i++){
2952         for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2953         delete [] vertex[i];
2954   }
2955   for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2956   delete deltatransvector;
2957   /////////////////////////////////////////////////////////////
2958   //ssdendflexmother->CheckOverlaps(0.01);
2959   return ssdendflexmother;
2960 }
2961 ///////////////////////////////////////////////////////////////////////////////
2962 TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
2963   /////////////////////////////////////////////////////////////
2964   // Method generating the Mounting Block
2965   /////////////////////////////////////////////////////////////
2966   const Int_t kvertexnumber = 8;
2967   Double_t xvertex[kvertexnumber];
2968   Double_t yvertex[kvertexnumber];
2969   xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2970   xvertex[1] = xvertex[0];
2971   xvertex[2] = -xvertex[0];
2972   xvertex[3] = xvertex[2];
2973   xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2974                          -                                 fgkSSDMountingBlockLength[2]);
2975   xvertex[5] = xvertex[4];
2976   xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2977                          - 0.5*fgkSSDMountingBlockScrewHoleEdge
2978                          -     fgkSSDMountingBlockScrewHoleRadius[0];
2979   xvertex[7] = xvertex[6];
2980   yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
2981                          +      fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0]
2982                          -  fgkSSDModuleVerticalDisalignment;
2983   yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2984   yvertex[2] = yvertex[1];
2985   yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2986   yvertex[4] = yvertex[3];
2987   yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2988                          - fgkSSDMountingBlockHeight[0];
2989   yvertex[6] = yvertex[5];
2990   yvertex[7] = yvertex[0];
2991   ///////////////////////////////////////////////////////////////////////
2992   // TGeoXTru Volume definition for Mounting Block Part
2993   ///////////////////////////////////////////////////////////////////////
2994   TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2995   ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2996   ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2997   ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
2998   TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
2999                                                                           ssdmountingblockshape,
3000                                                                                   fSSDMountingBlockMedium);
3001   ssdmountingblock->SetLineColor(fColorG10);
3002   TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
3003   mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
3004   TGeoRotation* mountingblockrot = new TGeoRotation();
3005   mountingblockrot->SetAngles(90.,180.,-90.);
3006   mountingblockcombitrans->SetRotation(*mountingblockrot);
3007   /////////////////////////////////////////////////////////////
3008   // Generating the Mounting Block Screw Vertices
3009   /////////////////////////////////////////////////////////////
3010   const Int_t kscrewvertexnumber = 15;
3011   Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
3012                                  -                                      fgkSSDMountingBlockScrewHoleEdge)
3013                                  /                              fgkSSDMountingBlockScrewHoleRadius[0])
3014                                  * TMath::RadToDeg();
3015   Double_t phi0 = 90.+alpha;
3016   Double_t phi = 270.-2*alpha;
3017   Double_t deltaphi = phi/kscrewvertexnumber;
3018   TVector3* screwvertex[kscrewvertexnumber+1];
3019   for(Int_t i=0; i<kscrewvertexnumber+1; i++)
3020         screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
3021                                    *CosD(phi0+i*deltaphi),
3022                                    fgkSSDMountingBlockScrewHoleRadius[0]
3023                                    *SinD(phi0+i*deltaphi));
3024   Double_t xscrewvertex[kscrewvertexnumber+6];
3025   Double_t yscrewvertex[kscrewvertexnumber+6];
3026   xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
3027   yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
3028                                   -               fgkSSDMountingBlockScrewHoleEdge);
3029   xscrewvertex[1] = xscrewvertex[0];
3030   yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3031   xscrewvertex[2] = screwvertex[0]->X();
3032   yscrewvertex[2] = yscrewvertex[1];
3033   for(Int_t i=0; i<kscrewvertexnumber+1; i++){
3034         xscrewvertex[i+3] = screwvertex[i]->X();
3035         yscrewvertex[i+3] = screwvertex[i]->Y();
3036   }
3037   xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3038   yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
3039   xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
3040   yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
3041   TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
3042   ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
3043   ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
3044   ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
3045                                                         +                                  fgkSSDMountingBlockHeight[2]);
3046   TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
3047                                                                                 ssdmountingblockscrewshape,
3048                                                                                             fSSDMountingBlockMedium);
3049   ssdmountingblockscrew->SetLineColor(fColorG10);
3050   TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
3051   for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
3052   ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3053                                                                         -                                yscrewvertex[1],
3054                                                                                                          0.5*fgkSSDMountingBlockHeight[0]
3055                                                                         -                                fgkSSDMountingBlockHeight[2]
3056                                                                         +                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3057                                                                         +                                fgkSSDMountingBlockHeight[2]
3058                                                                         -                                yvertex[0]));
3059   ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3060                                                                                                         -0.5*fgkSSDMountingBlockScrewHoleEdge,
3061                                                                                                                  yscrewvertex[1]
3062                                                                                                         -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3063                                                                                                          +fgkSSDMountingBlockHeight[2]
3064                                                                                                          -yvertex[0]));
3065   ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3066                                                                                                           yscrewvertex[1],
3067                                                                         -                                 0.5*fgkSSDMountingBlockHeight[0]
3068                                                                         +                                 fgkSSDMountingBlockHeight[2]
3069                                                                         -                                 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3070                                                                         +                                 fgkSSDMountingBlockHeight[2]
3071                                                                         -                                 yvertex[0]));
3072   ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3073                                                                                                          yscrewvertex[1],
3074                                                                         -                                yscrewvertex[1]
3075                                                                         +                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3076                                                                         +                                fgkSSDMountingBlockHeight[2]
3077                                                                         -                                yvertex[0]));
3078   TGeoRotation* ssdmountingblockscrewrot[4];
3079   for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
3080         ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
3081     ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
3082     ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
3083   for(Int_t i=1; i<4; i++)
3084         ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
3085   TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
3086   ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
3087   TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
3088   ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
3089                                                          +                                xvertex[0],yscrewvertex[1]
3090                                                          -                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3091                                                          +                                fgkSSDMountingBlockHeight[2]
3092                                                          -                                yvertex[0]),0.);
3093   TGeoHMatrix* ssdmountingblockscrewmatrix[4];
3094   for(Int_t i=0; i<4; i++){
3095         ssdmountingblockscrewmatrix[i] =
3096                 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
3097         ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
3098   }
3099   ///////////////////////////////////////////////////////////////////////
3100   // TGeoXtru for Mother Volume
3101   ///////////////////////////////////////////////////////////////////////
3102   const Int_t kvertexmothernumber = 12;
3103   Double_t xmothervertex[kvertexmothernumber];
3104   Double_t ymothervertex[kvertexmothernumber];
3105   for(Int_t i=0; i<6; i++){
3106         xmothervertex[i] = xvertex[i];
3107         ymothervertex[i] = yvertex[i];
3108   }
3109   xmothervertex[6]  = xvertex[5]+fgkSSDMountingBlockLength[2];
3110   ymothervertex[6]  = ymothervertex[5];
3111   xmothervertex[7]  = xmothervertex[6];
3112   ymothervertex[7]  = ymothervertex[4];
3113   xmothervertex[8]  = xmothervertex[7]
3114                                         + 0.5*(fgkSSDMountingBlockLength[1]
3115                                         -          fgkSSDMountingBlockLength[2]);
3116   ymothervertex[8]  = ymothervertex[4];
3117   xmothervertex[9]  = xmothervertex[8];
3118   ymothervertex[9]  = ymothervertex[2];
3119   xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
3120   ymothervertex[10] = ymothervertex[1];
3121   xmothervertex[11] = xmothervertex[10];
3122   ymothervertex[11] = ymothervertex[0];
3123   TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3124   ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3125   ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3126   ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3127   TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3128                                                                           ssdmountingblockmothershape,
3129                                                                                   fSSDAir);
3130   /////////////////////////////////////////////////////////////
3131   // Placing the Volumes into Mother Volume
3132   /////////////////////////////////////////////////////////////
3133   ssdmountingblockmother->AddNode(ssdmountingblock,1);
3134   ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3135   for(Int_t i=0; i<4; i++)
3136         ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3137                                                                         ssdmountingblockscrewmatrix[i]);
3138   /////////////////////////////////////////////////////////////
3139   // Deallocating memory
3140   /////////////////////////////////////////////////////////////
3141   delete mountingblockrot;
3142   for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3143   delete ssdmountingblockglobalrot;
3144   delete ssdmountingblockglobaltrans;
3145   /////////////////////////////////////////////////////////////
3146   return ssdmountingblockmother;
3147 }
3148 ///////////////////////////////////////////////////////////////////////////////
3149  TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3150   /////////////////////////////////////////////////////////////
3151   // Method generating the Mounting Block Clip
3152   /////////////////////////////////////////////////////////////
3153   const Int_t kmothervertexnumber = 10;
3154   Double_t xmothervertex[kmothervertexnumber];
3155   Double_t ymothervertex[kmothervertexnumber];
3156   xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3157                                    - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3158   xmothervertex[1] = xmothervertex[0];
3159   xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3160                                    - fgkMountingBlockClibScrewRadius);
3161   xmothervertex[3] = xmothervertex[2];
3162   xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3163   xmothervertex[5] = xmothervertex[4];
3164   xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3165   xmothervertex[7] = xmothervertex[6];
3166   xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3167   xmothervertex[9] = xmothervertex[8];
3168   ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
3169                                + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0]
3170                                    - fgkSSDModuleVerticalDisalignment;
3171   ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3172   ymothervertex[2] = ymothervertex[1];
3173   ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3174                                    - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3175                                    - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3176   ymothervertex[4] = ymothervertex[3];
3177   ymothervertex[5] = ymothervertex[2];
3178   ymothervertex[6] = ymothervertex[5];
3179   ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3180   ymothervertex[8] = ymothervertex[7];
3181   ymothervertex[9] = ymothervertex[0];
3182   ///////////////////////////////////////////////////////////////////////
3183   // TGeoXTru Volume definition for Mounting Block Clip Part
3184   ///////////////////////////////////////////////////////////////////////
3185   TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3186   ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3187   ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3188   ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3189   TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3190                                                                           ssdmountingblockclipshape,fSSDAir);
3191   ssdmountingblockclip->SetLineColor(4);
3192   ///////////////////////////////////////////////////////////////////////
3193   // TGeoXTru Volume definition for Clip
3194   ///////////////////////////////////////////////////////////////////////
3195   const Int_t kclipvertexnumber = 6;
3196   Double_t xclipvertex[kclipvertexnumber];
3197   Double_t yclipvertex[kclipvertexnumber];
3198   xclipvertex[0] = xmothervertex[0];
3199   xclipvertex[1] = xclipvertex[0];
3200   xclipvertex[2] = xmothervertex[6];
3201   xclipvertex[3] = xclipvertex[2];
3202   xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3203   xclipvertex[5] = xclipvertex[4];
3204   yclipvertex[0] = ymothervertex[0];
3205   yclipvertex[1] = ymothervertex[1];
3206   yclipvertex[2] = yclipvertex[1];
3207   yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3208   yclipvertex[4] = yclipvertex[3];
3209   yclipvertex[5] = yclipvertex[0];
3210   TGeoXtru* clipshape = new TGeoXtru(2);
3211   clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3212   clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3213   clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3214                                                          +   fgkMountingBlockClibWidth);
3215   TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3216   clip->SetLineColor(18);
3217   ///////////////////////////////////////////////////////////////////////
3218   // Ladder Support Piece
3219   ///////////////////////////////////////////////////////////////////////
3220   const Int_t ksupportvertexnumber = 4;
3221   Double_t xsupportvertex[ksupportvertexnumber];
3222   Double_t ysupportvertex[ksupportvertexnumber];
3223   xsupportvertex[0] = xclipvertex[5];
3224   xsupportvertex[1] = xsupportvertex[0];
3225   xsupportvertex[2] = xmothervertex[9];
3226   xsupportvertex[3] = xsupportvertex[2];
3227   ysupportvertex[0] = yclipvertex[0];
3228   ysupportvertex[1] = yclipvertex[3];
3229   ysupportvertex[2] = ysupportvertex[1];
3230   ysupportvertex[3] = ysupportvertex[0];
3231   TGeoXtru* supportshape = new TGeoXtru(2);
3232   supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3233   supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3234   supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3235   TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3236   support->SetLineColor(9);
3237   ///////////////////////////////////////////////////////////////////////
3238   // TGeoXTru Volume definition for Screw
3239   ///////////////////////////////////////////////////////////////////////
3240   Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3241                                                 0.5*fgkMountingBlockClibScrewRadius};
3242   Int_t edgesnumber[2] = {50,6};
3243   Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3244                                                  +0.5*(ymothervertex[3]-ymothervertex[2])};
3245   TGeoXtru* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
3246   TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3247   clipscrew->SetLineColor(12);
3248   TGeoRotation* screwrot = new TGeoRotation();
3249   screwrot->SetAngles(0.,90.,0.);
3250   TGeoTranslation* screwtrans = new TGeoTranslation();
3251   screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3252                                                          0.5*(ymothervertex[3]+ymothervertex[2]),
3253                                                          0.5*fgkSSDMountingBlockWidth+
3254                                                         -0.5*fgkMountingBlockSupportWidth[0]);
3255   TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3256   ///////////////////////////////////////////////////////////////////////
3257   // Placing the Volumes
3258   ///////////////////////////////////////////////////////////////////////
3259   ssdmountingblockclip->AddNode(clip,1);
3260   ssdmountingblockclip->AddNode(support,1);
3261   ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3262   /////////////////////////////////////////////////////////////
3263   // Deallocating memory
3264   /////////////////////////////////////////////////////////////
3265   delete screwtrans;
3266   delete screwrot;
3267   /////////////////////////////////////////////////////////////
3268   return ssdmountingblockclip;
3269 }
3270 ///////////////////////////////////////////////////////////////////////////////
3271 TList* AliITSv11GeometrySSD::GetCoolingTubeList()const{
3272   /////////////////////////////////////////////////////////////
3273   // Method generating the Cooling Tube
3274   /////////////////////////////////////////////////////////////
3275    TGeoTube** coolingtubeshape[fgkcoolingtubenumber];
3276    for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtubeshape[i] =
3277                                                                                                 new     TGeoTube*[2];
3278    // Ladder Cooling Tubes
3279    coolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3280                                           0.25 * (fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3281                                                   -     2.*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth));
3282    coolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3283                                                                                  coolingtubeshape[0][0]->GetDz());
3284    coolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3285                                                                                  0.5*(fgkSSDModuleStiffenerPosition[1]
3286                                                   -                                       fgkSSDSensorOverlap));
3287    coolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3288                                                                                  coolingtubeshape[1][0]->GetDz());
3289    coolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3290                                                                                  0.5*fgkSSDModuleStiffenerPosition[1]);
3291    coolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3292                                                                                  coolingtubeshape[2][0]->GetDz());
3293    // End Ladder Cooling Tubes
3294    TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3295    for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3296         endladdercoolingtubeshape[i] = new      TGeoTube*[2];
3297    endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3298                                                         0.50 * (fgkEndLadderMountingBlockPosition[0]
3299                                                   -                     fgkendladdercoolingsupportdistance[0]));
3300    endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3301                                                                         endladdercoolingtubeshape[0][0]->GetDz());
3302    endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3303                                                         0.50 * (fgkendladdercoolingsupportdistance[0]
3304                                                   +                     fgkendladdercoolingsupportdistance[1]
3305                                                   -                     fgkCoolingTubeSupportWidth));
3306    endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3307                                                                         endladdercoolingtubeshape[1][0]->GetDz());
3308    endladdercoolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3309                                                         0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
3310                                                   -                     fgkEndLadderMountingBlockPosition[0]
3311                                                   -                     fgkendladdercoolingsupportdistance[1]
3312                                                   -                     fgkCoolingTubeSupportWidth));
3313    endladdercoolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3314                                                                         endladdercoolingtubeshape[2][0]->GetDz());
3315    endladdercoolingtubeshape[3][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3316                                                           0.50 * (fgkMountingBlockToSensorSupport
3317                                                         - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
3318                                                         -                 fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
3319                                                         +                 fgkSSDSensorOverlap
3320                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
3321                                                         -                 fgkendladdercoolingsupportdistance[2]
3322                                                         -                 fgkEndLadderMountingBlockPosition[1]
3323                                                         -                 fgkCoolingTubeSupportWidth));
3324    endladdercoolingtubeshape[3][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3325                                                                         endladdercoolingtubeshape[3][0]->GetDz());
3326    endladdercoolingtubeshape[4][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3327                                                           0.50 * fgkendladdercoolingsupportdistance[2]);
3328    endladdercoolingtubeshape[4][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3329                                                                         endladdercoolingtubeshape[4][0]->GetDz());
3330    // Ladder Cooling Tubes
3331    TGeoVolume** coolingtube[fgkcoolingtubenumber];
3332    for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtube[i] =
3333                                                                                          new TGeoVolume*[2];
3334    coolingtube[0][0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0][0],
3335                                                                           fSSDCoolingTubePhynox);
3336    coolingtube[0][1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[0][1],
3337                                                                           fSSDCoolingTubeWater);
3338    coolingtube[1][0] = new TGeoVolume("OuterCoolingTube2",coolingtubeshape[1][0],
3339                                                                           fSSDCoolingTubePhynox);
3340    coolingtube[1][1] = new TGeoVolume("InnerCoolingTube2",coolingtubeshape[1][1],
3341                                                                           fSSDCoolingTubeWater);
3342    coolingtube[2][0] = new TGeoVolume("OuterCoolingTube3",coolingtubeshape[2][0],
3343                                                                           fSSDCoolingTubePhynox);
3344    coolingtube[2][1] = new TGeoVolume("InnerCoolingTube3",coolingtubeshape[2][1],
3345                                                                           fSSDCoolingTubeWater);
3346    for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3347         coolingtube[i][0]->SetLineColor(fColorPhynox);
3348         coolingtube[i][1]->SetLineColor(fColorWater);
3349    }
3350    // End Ladder Cooling Tubes
3351    TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3352    for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3353    endladdercoolingtube[i] = new TGeoVolume*[2];
3354    endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3355                                                                 endladdercoolingtubeshape[0][0],
3356                                                                 fSSDCoolingTubePhynox);
3357    endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3358                                                                 endladdercoolingtubeshape[0][1],
3359                                                                 fSSDCoolingTubeWater);
3360    endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3361                                                                 endladdercoolingtubeshape[1][0],
3362                                                                 fSSDCoolingTubePhynox);
3363    endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3364                                                                 endladdercoolingtubeshape[1][1],
3365                                                                 fSSDCoolingTubeWater);
3366    endladdercoolingtube[2][0] = new TGeoVolume("OuterEndLadderCoolingTube3",
3367                                                                 endladdercoolingtubeshape[2][0],
3368                                                                 fSSDCoolingTubePhynox);
3369    endladdercoolingtube[2][1] = new TGeoVolume("InnerEndlLadderCoolingTube3",
3370                                                                 endladdercoolingtubeshape[2][1],
3371                                                                 fSSDCoolingTubeWater);
3372    endladdercoolingtube[3][0] = new TGeoVolume("OuterEndLadderCoolingTube4",
3373                                                                 endladdercoolingtubeshape[3][0],
3374                                                                 fSSDCoolingTubePhynox);
3375    endladdercoolingtube[3][1] = new TGeoVolume("InnerEndlLadderCoolingTube4",
3376                                                                 endladdercoolingtubeshape[3][1],
3377                                                                 fSSDCoolingTubeWater);
3378    endladdercoolingtube[4][0] = new TGeoVolume("OuterEndLadderCoolingTube5",
3379                                                                 endladdercoolingtubeshape[4][0],
3380                                                                 fSSDCoolingTubePhynox);
3381    endladdercoolingtube[4][1] = new TGeoVolume("InnerEndlLadderCoolingTube5",
3382                                                                 endladdercoolingtubeshape[4][1],
3383                                                                 fSSDCoolingTubeWater);
3384    for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3385         endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3386         endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3387    }
3388   /////////////////////////////////////////////////////////////
3389   // Virtual Volume containing Cooling Tubes
3390   /////////////////////////////////////////////////////////////
3391   // Ladder Cooling Tubes
3392   TGeoTube* virtualcoolingtubeshape[fgkcoolingtubenumber];
3393   for(Int_t i=0; i<fgkcoolingtubenumber; i++)
3394   virtualcoolingtubeshape[i] = new TGeoTube(coolingtubeshape[i][1]->GetRmin(),
3395                                                                                         coolingtubeshape[i][0]->GetRmax(),
3396                                                                                         coolingtubeshape[i][0]->GetDz());
3397   TGeoVolume* virtualcoolingtube[fgkcoolingtubenumber];
3398   virtualcoolingtube[0] = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape[0],
3399                                                                           fSSDAir);
3400   virtualcoolingtube[1] = new TGeoVolume("CoolingTube2",virtualcoolingtubeshape[1],
3401                                                                           fSSDAir);
3402   virtualcoolingtube[2] = new TGeoVolume("CoolingTube3",virtualcoolingtubeshape[2],
3403                                                                           fSSDAir);
3404   // End Ladder Cooling Tubes
3405   TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3406   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3407   endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3408                                                                                         endladdercoolingtubeshape[i][0]->GetRmax(),
3409                                                                                         endladdercoolingtubeshape[i][0]->GetDz());
3410   TGeoVolume* endladdervirtualcoolingtube[fgkendladdercoolingtubenumber];
3411   endladdervirtualcoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3412                                                                           endladdervirtualcoolingtubeshape[0],
3413                                                                           fSSDAir);
3414   endladdervirtualcoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3415                                                                           endladdervirtualcoolingtubeshape[1],
3416                                                                           fSSDAir);
3417   endladdervirtualcoolingtube[2] = new TGeoVolume("EndLadderCoolingTube3",
3418                                                                           endladdervirtualcoolingtubeshape[2],
3419                                                                           fSSDAir);
3420   endladdervirtualcoolingtube[3] = new TGeoVolume("EndLadderCoolingTube4",
3421                                                                           endladdervirtualcoolingtubeshape[3],
3422                                                                           fSSDAir);
3423   endladdervirtualcoolingtube[4] = new TGeoVolume("EndLadderCoolingTube5",
3424                                                                           endladdervirtualcoolingtubeshape[4],
3425                                                                           fSSDAir);
3426   TList* coolingtubelist = new TList();
3427   for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3428         virtualcoolingtube[i]->AddNode(coolingtube[i][0],1);
3429         virtualcoolingtube[i]->AddNode(coolingtube[i][1],1);
3430     coolingtubelist->Add(virtualcoolingtube[i]);
3431   }
3432         endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3433         endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3434     coolingtubelist->Add(endladdervirtualcoolingtube[0]);
3435         endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3436         endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
3437     coolingtubelist->Add(endladdervirtualcoolingtube[1]);
3438         endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][0],1);
3439         endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][1],1);
3440     coolingtubelist->Add(endladdervirtualcoolingtube[2]);
3441         endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][0],1);
3442         endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][1],1);
3443     coolingtubelist->Add(endladdervirtualcoolingtube[3]);
3444         endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][0],1);
3445         endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][1],1);
3446     coolingtubelist->Add(endladdervirtualcoolingtube[4]);
3447   return coolingtubelist;
3448 }
3449 ///////////////////////////////////////////////////////////////////////////////
3450 TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
3451   /////////////////////////////////////////////////////////////
3452   // Method generating SSD Cooling Block
3453   /////////////////////////////////////////////////////////////
3454   const Int_t kvertexnumber = 8;
3455   ///////////////////////////////////////
3456   // Vertex Positioning for TGeoXTru
3457   ///////////////////////////////////////
3458   TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3459   vertexposition[0] = new TVector3(0.0,0.0);
3460   vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]);
3461   vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3462                                           vertexposition[1]->Y());
3463   vertexposition[3] = new TVector3(vertexposition[2]->X(),
3464                                           vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]);
3465   vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y());
3466   vertexposition[5] = new TVector3(vertexposition[4]->X(),
3467                                         + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]);
3468   vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3469                                           vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3470                                         - fgkSSDCoolingBlockHoleLength[0]
3471                                         - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3472                                           fgkSSDCoolingBlockHeight[0]
3473                                         - fgkSSDCoolingBlockHoleRadius[1],
3474                                           fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]);
3475   vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3476                                         - fgkSSDCoolingBlockHoleLength[0]),
3477                                           vertexposition[6]->Y());
3478   Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3479                            / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3480   Double_t phi = 180.-alpha;
3481   Double_t psi = 180.+2.*alpha;
3482   Double_t deltapsi = psi/nedges;
3483   Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3484   TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3485                                                   fgkSSDCoolingBlockHoleCenter);
3486   for(Int_t i=0; i<nedges+1; i++){
3487         vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3488                                                                                                radius*SinD(phi+i*deltapsi));
3489    *vertexposition[kvertexnumber+i] += (*transvector);
3490   }
3491   Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3492   for(Int_t i=0; i<kvertexnumber; i++)
3493     vertexposition[kvertexnumber+nedges+1+i] =
3494                                                 GetReflection(vertexposition[kvertexnumber-1-i],param);
3495   ///////////////////////////////////////////////////////////////////////
3496   // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3497   ///////////////////////////////////////////////////////////////////////
3498   TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3499   Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3500   Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3501   for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3502         xvertexpoints[i] = vertexposition[i]->X();
3503         yvertexpoints[i] = vertexposition[i]->Y();
3504   }
3505   ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3506                                                                                         yvertexpoints);
3507   ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3508   ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3509   TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3510                                                                           ssdcoolingblockshape,
3511                                                                                   fSSDAlCoolBlockMedium);
3512   ssdcoolingblock->SetLineColor(fColorAl);
3513   /////////////////////////////////////////////////////////////
3514   // Deallocating memory
3515   /////////////////////////////////////////////////////////////
3516   delete [] vertexposition;
3517   delete xvertexpoints;
3518   delete yvertexpoints;
3519   /////////////////////////////////////////////////////////////
3520   return ssdcoolingblock;
3521 }
3522 /////////////////////////////////////////////////////////////////////////////////
3523 TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, Int_t nedges){
3524   ///////////////////////////////////////////////////////
3525   const Int_t kssdchipcablesnumber    = 2;
3526   const Int_t kssdchipcableslaynumber = 2;
3527   const Int_t kvertexnumber                       = 4*(nedges+1)+4;
3528   Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3529   Double_t ssdchipcablesradius[kssdchipcableslaynumber];
3530   ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeigth
3531                                                  -  fgkSSDChipCablesHeight[0]
3532                                                  -  fgkSSDChipCablesHeight[1]);
3533   ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3534   Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3535   ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3536                                                           - 2.*TMath::Pi()*ssdchipcablesradius[0]
3537                                                           - ssdchipcablesradius[0]
3538                                                           - fgkSSDChipCablesWidth[1]
3539                                                           - fgkSSDChipCablesWidth[2]);
3540   ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3541                                                           - 0.5*(fgkSSDModuleStiffenerPosition[1]
3542                                                           +      fgkSSDChipCablesHeight[1]
3543                                                           +      fgkSSDSensorHeight);
3544   ///////////////////////////////////////////////////////
3545   // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3546   ///////////////////////////////////////////////////////
3547   TVector3** vertexposition[kssdchipcableslaynumber];
3548   for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3549                                                                                                   new TVector3*[4*(nedges+1)+4];
3550   Double_t ratio[4];
3551   ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3552   ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3553                    /  ssdchipcablesradius[0];
3554   ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3555                    /  ssdchipcablesradius[0];
3556   ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3557                    +  fgkSSDChipCablesHeight[1])
3558                    /  ssdchipcablesradius[0];
3559   Double_t phi = 180.;
3560   Double_t deltaphi = 180./nedges;
3561   Double_t angle = 0.0;
3562   Double_t **xvertexpoints = new Double_t*[kssdchipcableslaynumber];
3563   Double_t **yvertexpoints = new Double_t*[kssdchipcableslaynumber];
3564   for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3565         xvertexpoints[i] = new Double_t[kvertexnumber];
3566         yvertexpoints[i] = new Double_t[kvertexnumber];
3567   }
3568   TVector3* vertex = new TVector3();
3569   TVector3* transvector[kssdchipcableslaynumber];
3570   transvector[0] = new TVector3(fgkSSDChipWidth,
3571                                                                 SSDChipCablesHeigth-ssdchipcablesradius[0]);
3572   transvector[1] = new TVector3();
3573   TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcableslaynumber];
3574   TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcableslaynumber];
3575   const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcableslaynumber] =
3576                 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3577                  "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3578   for(Int_t k=0; k<kssdchipcablesnumber; k++){
3579         transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3580         transvector[1]->SetY(ssdchipcablesradius[0]
3581                                  +               fgkSSDChipCablesHeight[0]
3582                                  +               fgkSSDChipCablesHeight[1]);
3583         for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3584                 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeigth
3585                                                          - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
3586                 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeigth
3587                                                          - i*fgkSSDChipCablesHeight[0]);
3588                 vertexposition[i][2*(nedges+1)+2] =
3589                                         new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3590                                 +                                fgkSSDChipCablesWidth[1]
3591                                 +                                fgkSSDChipCablesWidth[2],
3592                                                                 ((1.-i)*fgkSSDChipCablesHeight[i]
3593                                 +                                fgkSSDChipCablesHeight[1]));
3594         vertexposition[i][2*(nedges+1)+3] =
3595                                         new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3596                                                                  vertexposition[i][2*(nedges+1)+2]->Y()
3597                                 -                                fgkSSDChipCablesHeight[i]);
3598             for(Int_t j=0; j<nedges+1; j++){
3599                     angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3600                         vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3601                         vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3602                         vertexposition[0][(nedges+1)*i+j+2] =
3603                                                 new TVector3(*vertex+*transvector[i]);
3604                         vertexposition[1][(nedges+1)*i+j+2] =
3605                                                 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3606                                                                          vertex->Y()*ratio[2*i]+transvector[i]->Y());
3607                         vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3608                                                 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3609                         vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3610                                                 new TVector3(vertex->X()*ratio[2*i+1]
3611                                                         +                        transvector[i]->X(),
3612                                                                                  vertex->Y()*ratio[2*i+1]
3613                                                         +                transvector[i]->Y());
3614                 }
3615         }
3616         for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3617                 for(Int_t j=0; j<kvertexnumber; j++){
3618                         xvertexpoints[i][j] = vertexposition[i][j]->X();
3619                         yvertexpoints[i][j] = vertexposition[i][j]->Y();
3620                 }
3621                 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3622                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3623                                                                                 xvertexpoints[i],yvertexpoints[i]);
3624                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3625                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3626                 ssdchipcable[kssdchipcablesnumber*k+i] =
3627                                 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3628                                                            ssdchipcableshape[kssdchipcablesnumber*k+i],
3629                                                           (kssdchipcablesnumber*k+i)%2==0?
3630                                                            fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3631                 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3632         }
3633         for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3634                 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3635   }
3636   /////////////////////////////////////////////////////////////
3637   // Mother Volume definition
3638   /////////////////////////////////////////////////////////////
3639   Double_t ssdchipseparation = fgkSSDSensorLength
3640                                                          - 2.*fgkSSDModuleStiffenerPosition[1]
3641                                                          - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3642                                                          - 0.5*fgkSSDChipWidth)-fgkSSDChipWidth;
3643   Double_t boxorigin[3] = {-0.5*ssdchipseparation,0.,0.5*SSDChipCablesHeigth};
3644   Double_t dx = ssdchipseparation+2.*(fgkSSDChipWidth+ssdchipcablesradius[0]
3645                                                           +fgkSSDChipCablesWidth[1]
3646                                                           +fgkSSDChipCablesWidth[2]);
3647   Double_t dy = fgkSSDChipCablesLength[1];
3648   Double_t dz = SSDChipCablesHeigth;
3649   TGeoBBox* ssdchipcablesmotherbox = new TGeoBBox(0.5*dx,0.5*dy,0.5*dz,boxorigin);
3650   TGeoVolume* ssdchipcablesmother = new TGeoVolume("SSDChipCablesMother",
3651                           ssdchipcablesmotherbox,fSSDAir);
3652   /////////////////////////////////////////////////////////////
3653   // Rotation and Translation Definition for positioning
3654   /////////////////////////////////////////////////////////////
3655   TGeoRotation* ssdchipcablesrot[5];
3656   ssdchipcablesrot[0] = new TGeoRotation("",90.,180.,-90);
3657   ssdchipcablesrot[1] = new TGeoRotation("",0.0,90.0,0.0);
3658   ssdchipcablesrot[2] = new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0]));
3659   ssdchipcablesrot[3] = new TGeoRotation("",180.,0.0,0.0);
3660   ssdchipcablesrot[4] = new TGeoRotation((*ssdchipcablesrot[3])*(*ssdchipcablesrot[2]));
3661   TGeoCombiTrans* ssdchipcablescombitrans = new TGeoCombiTrans(-ssdchipseparation,
3662                                                                                                                 0.,0.,ssdchipcablesrot[2]);
3663   ssdchipcablesmother->AddNode(ssdchipcable[0],1,ssdchipcablesrot[4]);
3664   ssdchipcablesmother->AddNode(ssdchipcable[1],1,ssdchipcablesrot[4]);
3665   ssdchipcablesmother->AddNode(ssdchipcable[2],1,ssdchipcablescombitrans);
3666   ssdchipcablesmother->AddNode(ssdchipcable[3],1,ssdchipcablescombitrans);
3667   /////////////////////////////////////////////////////////////
3668   // Deallocating memory
3669   /////////////////////////////////////////////////////////////
3670   for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3671         delete [] xvertexpoints[i];
3672         delete [] yvertexpoints[i];
3673   }
3674   for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3675   for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3676   delete vertex;
3677   delete ssdchipcablesrot[0];
3678   delete ssdchipcablesrot[1];
3679   delete ssdchipcablesrot[3];
3680   /////////////////////////////////////////////////////////////
3681   return ssdchipcablesmother;
3682 }
3683 ///////////////////////////////////////////////////////////////////////////////
3684 TList* AliITSv11GeometrySSD::GetSSDChipSystem(){
3685   /////////////////////////////////////////////////////////////
3686   // SSD Chip Assembly
3687   /////////////////////////////////////////////////////////////
3688   TGeoVolume* ssdchipassembly = GetSSDChips();
3689   TList* ssdchipsystemlist = new TList();
3690 //  const Int_t knedges = 20;
3691   const Int_t knedges = 5;
3692   const Int_t kchipsystemnumber = 2;
3693   /////////////////////////////////////////////////////////////
3694   // Mother Volume containing SSDChipSystem
3695   /////////////////////////////////////////////////////////////
3696   TGeoXtru* chipsystemothershape[kchipsystemnumber];
3697   for(Int_t i=0; i<kchipsystemnumber; i++) chipsystemothershape[i] = new TGeoXtru(2);
3698   const Int_t kmothervertexnumber = 12;
3699   Double_t xmothervertex[kchipsystemnumber][kmothervertexnumber];
3700   Double_t ymothervertex[kchipsystemnumber][kmothervertexnumber];
3701   Double_t ssdchipcablesradius[kchipsystemnumber];
3702   Double_t ssdchipseparation = fgkSSDSensorLength
3703                              - 2.*fgkSSDModuleStiffenerPosition[1]
3704                              - 2.*(fgkSSDStiffenerWidth
3705                              - fgkSSDStiffenerToChipDist-0.5*fgkSSDChipWidth);
3706   for(Int_t i=0; i<kchipsystemnumber; i++)
3707         ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
3708                                                    -  fgkSSDChipCablesHeight[0]
3709                                                    -  fgkSSDChipCablesHeight[1]);
3710   ///////////////////////
3711   // Setting the vertices
3712   ///////////////////////
3713   xmothervertex[0][0]  = -0.5*fgkSSDChipCablesLength[1];
3714   xmothervertex[0][1]  = xmothervertex[0][0];
3715   xmothervertex[0][2]  = (fgkSSDChipNumber-1)*(fgkSSDChipLength
3716                                            + fgkSSDChipSeparationLength)+0.5*fgkSSDChipCablesLength[1];
3717   xmothervertex[0][3]  = xmothervertex[0][2];
3718   xmothervertex[0][4]  = 0.5*fgkSSDChipCablesLength[1];
3719   xmothervertex[0][5]  = xmothervertex[0][4];
3720   xmothervertex[0][6]  = xmothervertex[0][2]-0.5*fgkSSDChipCablesLength[1];
3721   xmothervertex[0][7]  = xmothervertex[0][6];
3722   xmothervertex[0][8]  = 0.0;
3723   xmothervertex[0][9]  = xmothervertex[0][8];
3724   xmothervertex[0][10] = xmothervertex[0][4];
3725   xmothervertex[0][11] = xmothervertex[0][10];
3726   for(Int_t i=0; i<kmothervertexnumber; i++)
3727         xmothervertex[1][i] = xmothervertex[0][i];
3728   for(Int_t i=0; i<kchipsystemnumber; i++){
3729         ymothervertex[i][0]  = -0.5*fgkSSDChipWidth-ssdchipcablesradius[i]
3730                                                  - fgkSSDChipCablesWidth[1]-fgkSSDChipCablesWidth[2];
3731         ymothervertex[i][1]  = ssdchipseparation-ymothervertex[i][0];
3732         ymothervertex[i][2]  = ymothervertex[i][1];
3733         ymothervertex[i][3]  = ymothervertex[i][0];
3734         ymothervertex[i][4]  = ymothervertex[i][0];
3735         ymothervertex[i][5]  = 0.5*fgkSSDChipWidth;
3736         ymothervertex[i][6]  = ymothervertex[i][5];
3737         ymothervertex[i][7]  = ssdchipseparation-0.5*fgkSSDChipWidth;
3738         ymothervertex[i][8]  = ymothervertex[i][7];
3739         ymothervertex[i][9]  = ymothervertex[i][5];
3740         ymothervertex[i][10] = ymothervertex[i][5];
3741         ymothervertex[i][11] = ymothervertex[i][4];
3742   }
3743   //////////////////////////////////////////////////////////
3744   TGeoVolume* chipsystemother[kchipsystemnumber];
3745   const char* chipsytemothername[kchipsystemnumber] =
3746                                         {"SSDChipSytemother1","SSDChipSytemother2"};
3747   for(Int_t i=0; i<kchipsystemnumber; i++){
3748     chipsystemothershape[i]->DefinePolygon(kmothervertexnumber,
3749                                                                         xmothervertex[i],ymothervertex[i]);
3750     chipsystemothershape[i]->DefineSection(0,-fgkSSDChipCablesHeight[i+2]
3751                                                                                   -0.5*fgkSSDChipHeight);
3752     chipsystemothershape[i]->DefineSection(1,0.5*fgkSSDChipHeight);
3753     chipsystemother[i] = new TGeoVolume(chipsytemothername[i],
3754                                                           chipsystemothershape[i],fSSDAir);
3755   }
3756   /////////////////////////////////////////////////////////////
3757   // SSD Chip Cables
3758   /////////////////////////////////////////////////////////////
3759   TGeoVolume* ssdchipcables[kchipsystemnumber];
3760   TGeoRotation** ssdchipcablesrot[kchipsystemnumber];
3761   TGeoTranslation** ssdchipcablestrans[kchipsystemnumber];
3762   TGeoCombiTrans** ssdchipcablescombitrans[kchipsystemnumber];
3763   //////////////////
3764   for(Int_t i=0; i<kchipsystemnumber; i++){
3765                 ssdchipcables[i] =
3766                 GetSSDChipCables(fgkSSDChipCablesHeight[i+2],knedges);
3767                 ssdchipcablestrans[i] = new TGeoTranslation*[fgkSSDChipNumber];
3768                 ssdchipcablesrot[i] = new TGeoRotation*[fgkSSDChipNumber];
3769                 ssdchipcablescombitrans[i] = new TGeoCombiTrans*[fgkSSDChipNumber];
3770   }
3771   for(Int_t i=0; i<kchipsystemnumber; i++){
3772         for(Int_t j=0; j<fgkSSDChipNumber; j++){
3773                 ssdchipcablestrans[i][j] = new TGeoTranslation();
3774                 ssdchipcablesrot[i][j] = new TGeoRotation();
3775                 ssdchipcablescombitrans[i][j] = new TGeoCombiTrans();
3776                 ssdchipcablesrot[i][j]->SetAngles(-90.0,0.0,0.0);
3777                 ssdchipcablestrans[i][j]->SetTranslation(j*(fgkSSDChipLength
3778                                                   +                fgkSSDChipSeparationLength),
3779                                                                                         0.5*fgkSSDChipWidth,
3780                                                   -                                     0.5*fgkSSDChipHeight
3781                                                   -                                     fgkSSDChipCablesHeight[i+2]);
3782                 ssdchipcablescombitrans[i][j]->SetRotation(*ssdchipcablesrot[i][j]);
3783                 ssdchipcablescombitrans[i][j]->SetTranslation(*ssdchipcablestrans[i][j]);
3784                 chipsystemother[i]->AddNode(ssdchipcables[i],j+1,ssdchipcablescombitrans[i][j]);
3785         }
3786         chipsystemother[i]->AddNode(ssdchipassembly,i+1);
3787         ssdchipsystemlist->Add(chipsystemother[i]);
3788   }
3789   /////////////////////////////////////////////////////////////
3790   // Deallocating memory
3791   /////////////////////////////////////////////////////////////
3792   for(Int_t i=0; i<kchipsystemnumber; i++){
3793         for(Int_t j=0; j<fgkSSDChipNumber; j++){
3794                 delete ssdchipcablesrot[i][j];
3795                 delete ssdchipcablestrans[i][j];
3796         }
3797         delete ssdchipcablesrot[i];
3798         delete ssdchipcablestrans[i];
3799   }
3800   /////////////////////////////////////////////////////////////
3801   return ssdchipsystemlist;
3802 }
3803 ///////////////////////////////////////////////////////////////////////////////
3804 TGeoVolume* AliITSv11GeometrySSD::GetSSDChips() const{
3805   /////////////////////////////////////////////////////////////
3806   // SSD Chip Assembly Generation
3807   /////////////////////////////////////////////////////////////
3808   const Int_t kssdchiprownumber = 2;
3809   TGeoBBox* ssdchipcompshape[2];
3810   ssdchipcompshape[0] =  new TGeoBBox("SSDChipCompShape",
3811                                                                                 0.5*fgkSSDChipLength,
3812                                                                                 0.5*fgkSSDChipWidth,
3813                                                                                 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3814   ssdchipcompshape[1] =  new TGeoBBox("SSDChipGlueCompShape",
3815                                                                                 0.5*fgkSSDChipLength,
3816                                                                                 0.5*fgkSSDChipWidth,
3817                                                                                 0.5*fgkSSDChipGlueHeight);
3818   TGeoVolume* ssdchipcomp[2];
3819   ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3820   ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3821                                                                   fSSDChipGlueMedium);
3822   ssdchipcomp[0]->SetLineColor(fColorSilicon);
3823   ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3824   TGeoTranslation* ssdchipcomptrans[2];
3825   ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3826   ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3827   /////////////////////////////////////////////////////////////
3828   // Virtual Volume containing SSDChip
3829   /////////////////////////////////////////////////////////////
3830   TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3831                                                                                                                  0.5*fgkSSDChipWidth,
3832                                                                                                                  0.5*fgkSSDChipHeight);
3833   TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
3834   /////////////////////////////////////////////////////////////
3835   for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3836   Double_t ssdchipseparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength,
3837                                                   fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3838                                    -  2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3839                                    -  0.5*fgkSSDChipWidth)};
3840   /////////////////////////////////////////////////////////////
3841   // Virtual Volume containing SSDChipAssembly
3842   /////////////////////////////////////////////////////////////
3843   TGeoXtru* ssdchipmothershape = new TGeoXtru(2);
3844   const Int_t kssdmothervertexnumber = 2*fgkSSDChipNumber;
3845   Double_t xmothervertex[kssdmothervertexnumber];
3846   Double_t ymothervertex[kssdmothervertexnumber];
3847   ///////////////////////
3848   // Setting the vertices
3849   ///////////////////////
3850   xmothervertex[0] = -0.5*fgkSSDChipLength,ymothervertex[0] = -0.5*fgkSSDChipWidth;
3851   xmothervertex[1] = xmothervertex[0], ymothervertex[1] = ssdchipseparation[1]
3852                                    - ymothervertex[0];
3853   xmothervertex[2] = (fgkSSDChipNumber-1)*ssdchipseparation[0]-xmothervertex[0];
3854   ymothervertex[2] = ymothervertex[1];
3855   xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
3856   xmothervertex[4] = ssdchipseparation[0]+xmothervertex[0];
3857   ymothervertex[4] = ymothervertex[0];
3858   xmothervertex[5] = xmothervertex[4], ymothervertex[5] = -ymothervertex[4];
3859   xmothervertex[6] = (fgkSSDChipNumber-1)*ssdchipseparation[0]
3860                                    + (0.5*fgkSSDChipLength-fgkSSDChipWidth);
3861   ymothervertex[6] = ymothervertex[5];
3862   xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
3863                                    - fgkSSDChipWidth;
3864   xmothervertex[8] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3865   ymothervertex[8] = ymothervertex[7];
3866   xmothervertex[9] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3867   ymothervertex[9] = ymothervertex[6];
3868   xmothervertex[10] = -xmothervertex[0], ymothervertex[10] = ymothervertex[9];
3869   xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[0];
3870   //////////////////////////////////////////////////////////
3871   ssdchipmothershape->DefinePolygon(kssdmothervertexnumber,
3872                                                                         xmothervertex,ymothervertex);
3873   ssdchipmothershape->DefineSection(0,-0.5*fgkSSDChipHeight);
3874   ssdchipmothershape->DefineSection(1, 0.5*fgkSSDChipHeight);
3875   TGeoVolume* ssdchipmother = new TGeoVolume("SSDChipContainer",
3876                                                           ssdchipmothershape,fSSDAir);
3877    /////////////////////////////////////////////////////////////
3878   for(Int_t i=0; i<kssdchiprownumber; i++)
3879     for(Int_t j=0; j<fgkSSDChipNumber; j++)
3880                 ssdchipmother->AddNode(ssdchip,fgkSSDChipNumber*i+j+1,
3881                 new TGeoTranslation(j*ssdchipseparation[0],i*ssdchipseparation[1],0.));
3882   return ssdchipmother;
3883 }
3884 /////////////////////////////////////////////////////////////////////////////////
3885 TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
3886   /////////////////////////////////////////////////////////////
3887   // Method returning a List containing pointers to Ladder Cable Volumes
3888   /////////////////////////////////////////////////////////////
3889   const Int_t kladdercablesegmentnumber = 2;
3890   /////////////////////////////////////////
3891   // LadderSegmentBBox Volume
3892   /////////////////////////////////////////
3893   TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber];
3894   const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3895                                 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
3896   for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3897                                                   new TGeoBBox(laddercablesegmentbboxshapename[i],
3898                                                                            0.5*fgkSSDFlexWidth[0],
3899                                                                            0.5*fgkSSDLadderCableWidth,
3900                                                                            0.5*fgkSSDFlexHeight[i]);
3901   const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3902                                                   {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3903   TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3904   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3905                         laddercablesegmentbbox[i] =
3906                                                   new TGeoVolume(laddercablesegmentbboxname[i],
3907                                                                                  laddercablesegmentbboxshape[i],
3908                                                                                  (i==0?fSSDAlTraceLadderCableMedium:
3909             fSSDKaptonLadderCableMedium));
3910                         laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3911                                                                                                                    fColorPolyhamide);
3912   }
3913   TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber];
3914   laddercablesegmentbboxtrans[0] =
3915                                                    new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3916                                                                                            0.5*fgkSSDFlexWidth[0],
3917                                                                                            0.5*fgkSSDLadderCableWidth,
3918                                                                                            0.5*fgkSSDFlexHeight[0]);
3919   laddercablesegmentbboxtrans[1] =
3920                                                    new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3921                                                                                            0.5*fgkSSDFlexWidth[0],
3922                                                                                            0.5*fgkSSDLadderCableWidth,
3923                                                                                            fgkSSDFlexHeight[0]
3924                                                                                            +0.5*fgkSSDFlexHeight[1]);
3925   TGeoVolume* laddercablesegmentbboxassembly =
3926                                                    new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly");
3927   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3928                 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3929                                                                                             laddercablesegmentbboxtrans[i]);
3930 /////////////////////////////////////////
3931 // LadderSegmentArb8 Volume
3932 /////////////////////////////////////////
3933   const Int_t kvertexnumber = 4;
3934   TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3935   for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3936                                                                                                   new TVector3*[kvertexnumber];
3937 //Shape Vertex Positioning
3938   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3939         laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
3940         laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3941                                                                                                                   i*fgkSSDFlexHeight[0]);
3942         laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3943                                                                                    +                         fgkSSDFlexHeight[1]
3944                                                                                    +                      i*fgkSSDFlexHeight[0]);
3945         laddercablesegmentvertexposition[i][3] =
3946                                                    new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3947                                                                                 laddercablesegmentvertexposition[i][2]->Y());
3948   }
3949   Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3950                                                                             {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
3951   char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
3952                                         {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
3953   TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3954   for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3955                                         GetArbShape(laddercablesegmentvertexposition[i],
3956                                                                 laddercablesegmentwidth[i],
3957                                                                 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3958                                                                 laddercablesegmentarbshapename[i]);
3959   const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3960                                                   {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
3961   TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3962   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3963                          laddercablesegmentarb[i] =
3964                                                    new TGeoVolume(laddercablesegmentarbname[i],
3965                                                                                   laddercablesegmentarbshape[i],
3966                                                                                   (i==0?fSSDAlTraceLadderCableMedium:
3967             fSSDKaptonLadderCableMedium));
3968                          laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3969                                                                                                                    fColorPolyhamide);
3970 }
3971   TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3972   laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3973                                                                                                  90.,90,-90.);
3974   laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3975                                                                                                   0.,90.,0.);
3976   TGeoCombiTrans* laddercablesegmentarbcombitrans =
3977                                                    new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3978                                                            0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3979                                                          + fgkSSDFlexWidth[0],0.,0.,
3980                                                    new TGeoRotation((*laddercablesegmentarbrot[1])
3981                                                      *(*laddercablesegmentarbrot[0])));
3982   TGeoVolume* laddercablesegmentarbassembly =
3983                                                    new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3984   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3985   laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3986                                                                                    laddercablesegmentarbcombitrans);
3987 /////////////////////////////////////////
3988 // End Ladder Cable Volume
3989 /////////////////////////////////////////
3990   TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3991   const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3992                                 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3993   for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3994                                                   new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3995                                                                            0.5*ssdendladdercablelength,
3996                                                                            0.5*fgkSSDLadderCableWidth,
3997                                                                            0.5*fgkSSDFlexHeight[i]);
3998   const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3999                                                   {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
4000   TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
4001   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
4002                         ladderendcablesegmentbbox[i] =
4003                                                   new TGeoVolume(ladderendcablesegmentbboxname[i],
4004                                                                                  ladderendcablesegmentbboxshape[i],
4005                                                                                  (i==0?fSSDAlTraceLadderCableMedium:
4006             fSSDKaptonLadderCableMedium));
4007                         ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
4008                                                                                                                    fColorPolyhamide);
4009   }
4010   TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
4011   ladderendcablesegmentbboxtrans[0] =
4012                                                    new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
4013                                                                                            0.5*ssdendladdercablelength,
4014                                                                                            0.5*fgkSSDLadderCableWidth,
4015                                                                                            0.5*fgkSSDFlexHeight[0]);
4016   ladderendcablesegmentbboxtrans[1] =
4017                                                    new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
4018                                                                                            0.5*ssdendladdercablelength,
4019                                                                                            0.5*fgkSSDLadderCableWidth,
4020                                                                                            fgkSSDFlexHeight[0]
4021                                                                                            +0.5*fgkSSDFlexHeight[1]);
4022   TGeoVolume* ladderendcablesegmentbboxassembly =
4023                                                    new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
4024   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
4025                 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
4026                                                                                             ladderendcablesegmentbboxtrans[i]);
4027 /////////////////////////////////////////
4028   TList* laddercablesegmentlist = new TList();
4029   laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
4030   laddercablesegmentlist->Add(laddercablesegmentarbassembly);
4031   laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
4032   return laddercablesegmentlist;
4033   }
4034 /////////////////////////////////////////////////////////////////////////////////
4035 TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
4036   /////////////////////////////////////////////////////////////
4037   // Method generating Ladder Cable Volumes Assemblies
4038   /////////////////////////////////////////////////////////////
4039   TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
4040   TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
4041   for(Int_t i=0; i<n; i++){
4042          TGeoTranslation* laddercabletrans = new TGeoTranslation(
4043                                                         i*(fgkCarbonFiberJunctionWidth),
4044                                                         fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4045                                                         i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4046     laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
4047         if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
4048   }
4049   TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
4050                                           (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4051                                                                  fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4052                                           (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4053   laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
4054   return laddercable;
4055 }
4056 /////////////////////////////////////////////////////////////////////////////////
4057 TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
4058   /////////////////////////////////////////////////////////////
4059   // Method generating Ladder Cable Volumes Assembly
4060   /////////////////////////////////////////////////////////////
4061   TGeoVolume* laddercableassembly = new TGeoVolumeAssembly("LadderCableAssembly");
4062   char laddercabletransname[30];
4063   for(Int_t i=0; i<n; i++){
4064         sprintf(laddercabletransname,"LadderCableTrans%i",i+1);
4065     laddercableassembly->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
4066         new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0.,0.));
4067   }
4068   return laddercableassembly;
4069 }
4070 /////////////////////////////////////////////////////////////////////////////////
4071 TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
4072   /////////////////////////////////////////////////////////////
4073   // Method generating Ladder Cable List Assemblies
4074   /////////////////////////////////////////////////////////////
4075   const Int_t kladdercableassemblynumber = 2;
4076   TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
4077   TGeoVolume* ladderCable[kladdercableassemblynumber];
4078   char laddercableassemblyname[30];
4079   TList* laddercableassemblylist = new TList();
4080   for(Int_t i=0; i<kladdercableassemblynumber; i++){
4081         sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
4082         ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
4083         ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
4084                                          new TGeoCombiTrans((n-1)
4085                                          *       fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4086                                              2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
4087                                                                                         0.,new TGeoRotation("",180,0.,0.)));
4088         laddercableassemblylist->Add(ladderCable[i]);
4089 }
4090   return laddercableassemblylist;
4091 }
4092 ///////////////////////////////////////////////////////////////////////////////
4093 void AliITSv11GeometrySSD::SetLadderSegment(){
4094   /////////////////////////////////////////////////////////////
4095   // Method Generating Ladder Segment Array
4096   /////////////////////////////////////////////////////////////
4097   fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
4098   fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
4099   if(!fCreateMaterials) CreateMaterials();
4100   if(!fTransformationMatrices) CreateTransformationMatrices();
4101   if(!fBasicObjects) CreateBasicObjects();
4102   for(Int_t i=0; i<fgkladdersegmentnumber; i++){
4103   // Placing Carbon Fiber Support
4104         for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
4105                 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4106                                                                                         fcarbonfibersupportmatrix[j]);
4107                 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4108                                                                                         fcarbonfibersupportmatrix[j]);
4109   }
4110   // Placing Carbon Fiber Junction
4111     for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++)
4112         fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
4113                                                                    fcarbonfiberjunctionmatrix[j]);
4114   // Placing Carbon Fiber Lower Support
4115         for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++)
4116                 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
4117                                                            fcarbonfiberlowersupportrans[j]);
4118   // Placing SSD Sensor Support
4119     for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
4120         fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
4121                                                                      fssdsensorsupport[1][i],
4122                                                            j+1,fssdsensorsupportmatrix[j]);
4123   // Placing SSD Cooling Tube Support
4124         for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
4125                 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
4126                                                                    fcoolingtubesupportmatrix[j]);
4127   // Placing SSD Cooling Tube
4128         for(Int_t j=0; j<2; j++)
4129                 for(Int_t k=0; k<2; k++){
4130                 fladdersegment[i]->AddNode(fcoolingtube[0],2*j+k+1,fcoolingtubematrix[j][k]);
4131                 fladdersegment[i]->AddNode(fcoolingtube[j+1],k+1,fcoolingtubematrix[2+j][k]);
4132                 }
4133   // Placing SSD Hybrid
4134     switch(i){
4135         case 0:
4136                 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
4137                 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4138                 break;
4139     case 1:
4140                 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
4141                 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4142                 break;
4143         }
4144         // Placing Cooling Block System
4145     fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
4146         // Placing SSD Flex
4147         for(Int_t j=0; j<fgkflexnumber; j++){
4148       fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
4149       fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
4150         }
4151    }
4152 }
4153 ///////////////////////////////////////////////////////////////////////////////
4154 void AliITSv11GeometrySSD::SetEndLadderSegment(){
4155   /////////////////////////////////////////////////////////////
4156   // Method Generating End Ladder
4157   /////////////////////////////////////////////////////////////
4158   // End Ladder Carbon Fiber Junction
4159   /////////////////////////////////////////////////////////////
4160   fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
4161   fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
4162   if(!fCreateMaterials) CreateMaterials();
4163   if(!fTransformationMatrices) CreateTransformationMatrices();
4164   if(!fBasicObjects) CreateBasicObjects();
4165   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
4166         for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
4167                 fendladdersegment[i]->AddNode(j==2 ?
4168                                                         fendladdercarbonfiberjunction[i][1] :
4169                                                         fendladdercarbonfiberjunction[i][0],
4170                                                         j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
4171   }
4172   /////////////////////////////////////////////////////////////
4173   // End Ladder Carbon Fiber Support
4174   /////////////////////////////////////////////////////////////
4175   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
4176       for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
4177                   fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4178                   fendladdercarbonfibermatrix[i][j]);
4179           fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4180                   fendladdercarbonfibermatrix[i][j]);
4181       }
4182   /////////////////////////////////////////////////////////////
4183   // End Ladder Mounting Block
4184   /////////////////////////////////////////////////////////////
4185   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4186        fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
4187                                      fendladdermountingblockcombitrans[i]);
4188   /////////////////////////////////////////////////////////////
4189   // End Ladder Mounting Block Clip
4190   /////////////////////////////////////////////////////////////
4191   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4192         for(Int_t j=0; j<2; j++)
4193                 fendladdersegment[i]->AddNode(fendladdermountingblockclip,j+1,
4194                                               fendladdermountingblockclipmatrix[i][j]);
4195   /////////////////////////////////////////////////////////////
4196   // End Ladder Lower Supports
4197   /////////////////////////////////////////////////////////////
4198   fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
4199                                 fendladderlowersupptrans[0]);
4200   fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
4201                                 fendladderlowersupptrans[1]);
4202   fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
4203                                 fendladderlowersupptrans[2]);
4204   /////////////////////////////////////////////////////////////
4205   // End Ladder Cooling Tube Support
4206   /////////////////////////////////////////////////////////////
4207   for(Int_t i=0; i<2; i++)
4208         for(Int_t j=0; j<(i==0?4:2); j++)
4209                 fendladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
4210                                               fendladdercoolingtubesupportmatrix[i][j]);
4211   /////////////////////////////////////////////////////////////
4212   // End Ladder Cooling Tube Support
4213   /////////////////////////////////////////////////////////////
4214   fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
4215   fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
4216   fendladdersegment[0]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[0][2]);
4217   fendladdersegment[0]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[0][3]);
4218   fendladdersegment[0]->AddNode(fendladdercoolingtube[2],1,fendladdercoolingtubematrix[0][4]);
4219   fendladdersegment[0]->AddNode(fendladdercoolingtube[2],2,fendladdercoolingtubematrix[0][5]);
4220   fendladdersegment[1]->AddNode(fendladdercoolingtube[3],1,fendladdercoolingtubematrix[1][0]);
4221   fendladdersegment[1]->AddNode(fendladdercoolingtube[3],2,fendladdercoolingtubematrix[1][1]);
4222   fendladdersegment[1]->AddNode(fendladdercoolingtube[4],1,fendladdercoolingtubematrix[1][2]);
4223   fendladdersegment[1]->AddNode(fendladdercoolingtube[4],2,fendladdercoolingtubematrix[1][3]);
4224 }
4225 ///////////////////////////////////////////////////////////////////////////////
4226 void AliITSv11GeometrySSD::SetLadder(){
4227   /////////////////////////////////////////////////////////////
4228   // Method Generating Ladder of Layer 5 and 6
4229   /////////////////////////////////////////////////////////////
4230   Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
4231                                                                                                 fgkSSDLay6SensorsNumber};
4232   /////////////////////////////////////////////////////////////////////////////
4233   /// Generating Ladder Mother Volume Containing Ladder
4234   /////////////////////////////////////////////////////////////////////////////
4235   TGeoXtru* laddershape[fgkladdernumber];
4236   for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
4237   const Int_t kmothervertexnumber = 8;
4238   Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
4239   Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
4240   ///////////////////////
4241   // Setting the vertices
4242   ///////////////////////
4243   Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
4244                                                                 * (fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]);
4245   xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
4246   ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
4247                                           -  fgkSSDModuleVerticalDisalignment;
4248   xmothervertex[0][1] = xmothervertex[0][0];
4249   ymothervertex[0][1] = 0.0;
4250   xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
4251                                                 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
4252   ymothervertex[0][2] = ymothervertex[0][1];
4253   ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
4254   xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
4255   xmothervertex[0][4] = -xmothervertex[0][3];
4256   ymothervertex[0][4] = ymothervertex[0][3];
4257   xmothervertex[0][5] = -xmothervertex[0][2];
4258   ymothervertex[0][5] = ymothervertex[0][2];
4259   xmothervertex[0][6] = -xmothervertex[0][1];
4260   ymothervertex[0][6] = ymothervertex[0][1];
4261   xmothervertex[0][7] = -xmothervertex[0][0];
4262   ymothervertex[0][7] = ymothervertex[0][0];
4263   for(Int_t i=0; i<kmothervertexnumber; i++){
4264         xmothervertex[1][i] = xmothervertex[0][i];
4265         ymothervertex[1][i] = ymothervertex[0][i];
4266   }
4267   const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4268   for(Int_t i=0; i<fgkladdernumber; i++){
4269         laddershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
4270                                                                     ymothervertex[i]);
4271     laddershape[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
4272     laddershape[i]->DefineSection(1,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4273                                                                                         +fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4274     fladder[i] = new TGeoVolume(laddername[i],laddershape[i],fSSDAir);
4275         fladder[i]->SetLineColor(4);
4276  }
4277 ///////////////////////////////////////////////////////////////////////////
4278  if(!fCreateMaterials) CreateMaterials();
4279  if(!fTransformationMatrices) CreateTransformationMatrices();
4280  if(!fBasicObjects) CreateBasicObjects();
4281  SetLadderSegment();
4282  SetEndLadderSegment();
4283   for(Int_t i=0; i<fgkladdernumber; i++){
4284         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4285         //////////////////////////
4286         /// Placing Ladder Segment
4287         //////////////////////////
4288                 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4289                                                                      fladdersegment[i==0 ? 1 : 0],
4290                                                                          ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4291         //////////////////////////
4292         /// Placing SSD Sensor
4293         //////////////////////////
4294                 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4295                                                         fssdsensormatrix[i][j]);
4296         }
4297         ///////////////////////////////
4298         /// Placing End Ladder Segment
4299         ///////////////////////////////
4300     fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
4301         fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4302    }
4303 /////////////////////////////////////////////////////////////////////////////
4304 /// Placing Ladder Cables
4305 /////////////////////////////////////////////////////////////////////////////
4306   Int_t sidecablenumber[2][2];
4307   sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4308   sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4309   sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4310   sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4311   Double_t carbonfibertomoduleposition[3];
4312   carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4313   carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4314                          fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4315          +               0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4316          -               0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4317          -            fgkSSDSensorCenterSupportThickness[0]);
4318   carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4319                                                                  +   0.5*fgkCoolingTubeSupportHeight
4320          -         fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4321   const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
4322   Double_t ssdendladdercablelength[4];
4323   ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
4324                                                          + fgkSSDSensorLength
4325                                                          - fgkSSDModuleStiffenerPosition[1]
4326                                                          - fgkSSDStiffenerWidth
4327                                                          - fgkSSDFlexWidth[0]
4328                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
4329   ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
4330                                                          + fgkSSDModuleStiffenerPosition[1]
4331                                                          + fgkSSDStiffenerWidth
4332                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
4333   ssdendladdercablelength[2] = ssdendladdercablelength[1]
4334                                                          - fgkEndLadderCarbonFiberLowerJunctionLength[1]
4335                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4336                                                          - kendladdercablecorrection;
4337   ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4338                                                          + carbonfibertomoduleposition[1]
4339                                                          - fgkSSDModuleStiffenerPosition[1]
4340                                                          - fgkSSDStiffenerWidth)
4341                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
4342   TList* laddercableassemblylist[4];
4343   const Int_t kendladdercablesnumber = 4;
4344   for(Int_t i=0; i<fgkladdercablesnumber; i++)
4345         for(Int_t j=0; j<kendladdercablesnumber; j++){
4346                 laddercableassemblylist[j] =
4347                 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4348                                                                    ssdendladdercablelength[j]);
4349             fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4350                                                                         j<2?1:2,fladdercablematrix[i][j]);
4351   }
4352 }
4353 ////////////////////////////////////////////////////////////////////////////////
4354 void AliITSv11GeometrySSD::SetLayer(){
4355 ////////////////////////////////////////////////////////////////////////////////
4356   // Creating Ladder of Layer 5 and Layer 6
4357   /////////////////////////////////////////////////////////////
4358   if(!fCreateMaterials) CreateMaterials();
4359   if(!fTransformationMatrices) CreateTransformationMatrices();
4360   if(!fBasicObjects) CreateBasicObjects();
4361   SetLadder(); // Generating the ladder of Layer5 and Layer6
4362   const Int_t kssdlayladdernumber[fgklayernumber] =
4363                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4364   /////////////////////////////////////////////////////////////
4365   // Generating mother volumes for Layer5 and Layer6
4366   /////////////////////////////////////////////////////////////
4367   fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
4368   fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
4369   Int_t *ladderindex[fgklayernumber];
4370   Int_t index[fgklayernumber] = {8,9};
4371   for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4372   for(Int_t i=0; i<fgklayernumber; i++)
4373         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4374                 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4375                                                           j+index[i] : j+index[i]-kssdlayladdernumber[i];
4376                 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4377                         fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4378         }
4379   /////////////////////////////////////////////////////////////
4380   // Deallocating memory
4381   /////////////////////////////////////////////////////////////
4382   for(Int_t i=0; i<fgklayernumber; i++) delete ladderindex[i];
4383 }
4384 ////////////////////////////////////////////////////////////////////////////////
4385 void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
4386   /////////////////////////////////////////////////////////////
4387   // Insert the layer 5 in the mother volume.
4388   /////////////////////////////////////////////////////////////
4389   if (! moth) {
4390     printf("Error::AliITSv11GeometrySSD: Can't insert layer5, mother is null!\n");
4391     return;
4392   };
4393   if(!fSSDLayer5) SetLayer();
4394   fMotherVol = moth;
4395   TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4396                                                                                 + fgkLay5CenterITSPosition);
4397   moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
4398  }
4399 ////////////////////////////////////////////////////////////////////////////////
4400 void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
4401   /////////////////////////////////////////////////////////////
4402   // Insert the layer 6 in the mother volume.
4403   /////////////////////////////////////////////////////////////
4404   if (! moth) {
4405     printf("Error::AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
4406     return;
4407   };
4408   if(!fSSDLayer6) SetLayer();
4409   fMotherVol = moth;
4410   TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4411                                                                                 + fgkLay6CenterITSPosition);
4412   moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
4413  }
4414  ////////////////////////////////////////////////////////////////////////////////
4415  TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4416   /////////////////////////////////////////////////////////////
4417   // Method generating the Arc structure of Ladder Support
4418   /////////////////////////////////////////////////////////////
4419   const Int_t kssdlayladdernumber[fgklayernumber] =
4420                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4421   Double_t mountingsupportedge[fgklayernumber];
4422   Double_t mountingblockratio[fgklayernumber];
4423   Double_t theta[fgklayernumber];
4424   Double_t phi[fgklayernumber];
4425   Double_t psi0[fgklayernumber];
4426   Double_t deltapsi[fgklayernumber];
4427   TVector3* mountingsupportedgevector[fgklayernumber];
4428   for(Int_t i=0; i<fgklayernumber; i++){
4429         mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4430     mountingsupportedge[i]    = 0.5*fgkMountingBlockSupportRadius[i]
4431                                                           *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
4432                                                           * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4433                                                           - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4434                                                           / kssdlayladdernumber[i])));
4435     theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4436     phi[i]   = TMath::ASin(0.5*mountingblockratio[i]);
4437         mountingsupportedgevector[i] = new TVector3();
4438     mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4439         mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(1.
4440                                                                  -TMath::Power(mountingsupportedgevector[i]->X()
4441                                                                  /                         fgkMountingBlockSupportRadius[i],2)));
4442     psi0[i] = 0.5*TMath::Pi()-phi[i];
4443     deltapsi[i] = (theta[i]+phi[i])/nedges;
4444   }
4445   TVector3** vertex[fgklayernumber];
4446   TList* vertexlist[fgklayernumber];
4447   Int_t indexedge[fgklayernumber] = {0,0};
4448   for(Int_t i=0; i<fgklayernumber; i++){
4449         vertex[i] = new TVector3*[nedges+1];
4450         vertexlist[i] = new TList();
4451   }
4452   for(Int_t i=0; i<fgklayernumber; i++){
4453         for(Int_t j=0; j<nedges+1; j++){
4454                 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
4455                                                                     fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]));
4456                 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4457                 vertexlist[i]->Add(vertex[i][j]);
4458         }
4459         vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4460   }
4461   Double_t** xsidevertex = new Double_t*[fgklayernumber];
4462   Double_t** ysidevertex = new Double_t*[fgklayernumber];
4463   Double_t** xcentervertex = new Double_t*[fgklayernumber];
4464   Double_t** ycentervertex = new Double_t*[fgklayernumber];
4465   Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4466   Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4467   Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4468   Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4469   for(Int_t i=0; i<fgklayernumber; i++){
4470     xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4471     ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4472     xcentervertex[i] = new Double_t[indexedge[i]+3];
4473     ycentervertex[i] = new Double_t[indexedge[i]+3];
4474         xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4475         ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4476         xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4477         ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4478         for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4479                 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4480                                                                                 ((TVector3*)vertexlist[i]->At(j))->X();
4481                 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4482                                                                                 ((TVector3*)vertexlist[i]->At(j))->Y();
4483                 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4484                 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4485                 if(j<indexedge[i]+1){
4486                         xcentervertex[i][j!=indexedge[i]?j+3:0] =
4487                                                                                 ((TVector3*)vertexlist[i]->At(j))->X();
4488                         ycentervertex[i][j!=indexedge[i]?j+3:0] =
4489                                                                                 ((TVector3*)vertexlist[i]->At(j))->Y();
4490                         xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4491                         ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4492                 }
4493         }
4494         xsidevertex[i][1] = xsidevertex[i][0];
4495         ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4496         xsidevertex[i][2] = xsidevertex[i][3];
4497         ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4498         xcentervertex[i][1] = xcentervertex[i][0];
4499         ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4500         xcentervertex[i][2] = xcentervertex[i][3];
4501         ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4502         xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4503         ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4504         xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4505         ycenterlowervertex[i][0] = ysidevertex[i][0];
4506         xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4507         ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4508   }
4509   /////////////////////////////////////////////////////////////
4510   // Building the Arc Structure of Ladder Supports
4511   /////////////////////////////////////////////////////////////
4512   TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4513   TGeoXtru* centermountingsupportshape[fgklayernumber];
4514   TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4515   TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4516   TGeoVolume* sidemountingblocksupport[fgklayernumber];
4517   TGeoVolume* centermountingblocksupport[fgklayernumber];
4518   TGeoVolume* sideladdersupportpiece[fgklayernumber];
4519   TGeoVolume* centerladdersupportpiece[fgklayernumber];
4520   char sidemountingblockname[40];
4521   char centermountingblockname[40];
4522   char sideladdersupportpiecename[40];
4523   char centerladdersupportpiecename[40];
4524   for(Int_t i=0; i<fgklayernumber; i++){
4525         sprintf(sidemountingblockname,"MountingBlockSupportSideLay%dArc",i+5);
4526         sprintf(centermountingblockname,"MountingBlockSupportCenterLay%dArc",i+5);
4527         sprintf(sideladdersupportpiecename,"SideLadderSupportPieceLay%d",i+5);
4528         sprintf(centerladdersupportpiecename,"CenterLadderSupportPieceLay%d",i+5);
4529         sidemountingblocksupportshape[i] = new TGeoXtru(2);
4530     sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4531                                                                                                 xsidevertex[i],ysidevertex[i]);
4532     sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4533                                                                                                          -fgkMountingBlockSupportWidth[0]);
4534     sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4535     sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4536                                                                           sidemountingblocksupportshape[i],
4537                                                                                   fSSDAlCoolBlockMedium);
4538         sidemountingblocksupport[i]->SetLineColor(9);
4539         centermountingsupportshape[i] = new TGeoXtru(2);
4540     centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4541                                                                                                 xcentervertex[i],ycentervertex[i]);
4542         centermountingsupportshape[i]->DefineSection(0,0.);
4543     centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4544                                                                                                   -fgkMountingBlockSupportWidth[0]);
4545     centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4546                                                                           centermountingsupportshape[i],
4547                                                                                   fSSDAlCoolBlockMedium);
4548         centermountingblocksupport[i]->SetLineColor(9);
4549         sideladdersupportpieceshape[i] = new TGeoXtru(2);
4550     sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4551                                                                                                 xsidelowervertex[i],ysidelowervertex[i]);
4552         sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4553                                                                                                          -fgkMountingBlockSupportWidth[0]);
4554     sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4555     sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4556                                                                           sideladdersupportpieceshape[i],
4557                                                                                   fSSDCarbonFiberMedium);
4558         sideladdersupportpiece[i]->SetLineColor(fColorAl);
4559         centerladdersupportpieceshape[i] = new TGeoXtru(2);
4560     centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4561                                                                                                 xcenterlowervertex[i],ycenterlowervertex[i]);
4562         centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4563     centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4564                                                                                                   -fgkMountingBlockSupportWidth[0]);
4565     centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4566                                                                           centerladdersupportpieceshape[i],
4567                                                                                   fSSDCarbonFiberMedium);
4568         centerladdersupportpiece[i]->SetLineColor(fColorAl);
4569   }
4570   /////////////////////////////////////////////////////////////
4571   // Building the Up Structure of Ladder Supports
4572   /////////////////////////////////////////////////////////////
4573   TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4574   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4575   TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4576   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4577   TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4578   //////////////////////////////////////////////////////////
4579   // Setting the volume for TGeoXtru Mounting Block Piece
4580   //////////////////////////////////////////////////////////
4581   TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4582   TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4583   TGeoVolume* mountingblockpiecedown[fgklayernumber];
4584   TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4585   TGeoVolume* mountingblockpieceup[fgklayernumber];
4586   Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4587   Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4588   Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4589   Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
4590   char mountingblockpiecedownname[34];
4591   char mountingblockpieceupname[34];
4592   for(Int_t i=0; i<fgklayernumber; i++){
4593     ///////////////////////////
4594     // Mounting Block Down Vertex
4595     ///////////////////////////
4596         mountingblockpiecedownshape[i] = new TGeoXtru(2);
4597     sprintf(mountingblockpiecedownname,"MountingBlockPieceDownLay%d",i+5);
4598         mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4599         mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4600                                                                                 + fgkMountingBlockSupportDownHeight;
4601         mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4602         mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4603                                                                                 + fgkSSDMountingBlockHeight[1]
4604                                                                                 - 0.5*fgkCoolingTubeSupportHeight
4605                                                                                 - fgkSSDModuleCoolingBlockToSensor
4606                                                                                 - fgkSSDModuleVerticalDisalignment;
4607         mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4608         mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4609         mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4610         mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4611         mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4612         mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4613         mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4614         mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4615                                                                                 + fgkSSDMountingBlockHeight[2]
4616                                                                                 - fgkSSDMountingBlockHeight[0];
4617         mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4618         mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4619         mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4620         mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4621         mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4622                                                                                                          mountingblockpiecedownyvertex[i]);
4623         mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4624         mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4625         mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
4626                                                                  mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
4627         mountingblockpiecedown[i]->SetLineColor(fColorG10);
4628     ///////////////////////////
4629     // Mounting Block Up Vertex
4630     ///////////////////////////
4631         mountingblockpieceupshape[i] = new TGeoXtru(2);
4632         sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5);
4633         mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4634         mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4635                                                                                 + fgkMountingBlockSupportUpHeight[i];
4636         mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4637         mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4638                                                                                 + fgkSSDMountingBlockHeight[1]
4639                                                                                 - 0.5*fgkCoolingTubeSupportHeight
4640                                                                                 - fgkSSDModuleCoolingBlockToSensor
4641                                                                                 - fgkSSDModuleVerticalDisalignment;
4642         mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4643         mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4644         mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4645         mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4646         mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4647         mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4648         mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4649         mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4650                                                                                 + fgkSSDMountingBlockHeight[2]
4651                                                                                 - fgkSSDMountingBlockHeight[0];
4652         mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4653         mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4654         mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4655         mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
4656         mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4657                                                                                                          mountingblockpieceupyvertex[i]);
4658         mountingblockpieceupshape[i]->DefineSection(0,0.0);
4659         mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4660         mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
4661                                                                 mountingblockpieceupshape[i],fSSDMountingBlockMedium);
4662         mountingblockpieceup[i]->SetLineColor(fColorG10);
4663  }
4664   ///////////////////////////////////////////////////////////////////
4665   // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4666   ///////////////////////////////////////////////////////////////////
4667   TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4668   TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4669   TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4670   TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4671   Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4672   Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4673   Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4674   Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
4675   char mountingblocksupportrapezoidowname[40];
4676   char mountingblocksupportrapezoidupname[40];
4677   Double_t scalefactor = 3./4.;
4678   for(Int_t i=0; i<fgklayernumber; i++){
4679   ////////////////////////////////////////////
4680   // Mounting Block Support Down Trapezoid Vertex
4681   ////////////////////////////////////////////
4682         mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4683         mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4684                                                                                                  - mountingsupportedge[i];
4685         mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4686         mountingblocksupportrapezoidownxvertex[i][1] =
4687                                                                                 mountingblocksupportrapezoidownxvertex[i][0];
4688         mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4689                                                                                                  + scalefactor*(mountingblockpiecedownyvertex[i][1]
4690                                                                                              - mountingblockpiecedownyvertex[i][0]);
4691         mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4692         mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4693         mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4694         mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4695         mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4696         mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
4697         mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4698                                                                                                                mountingblocksupportrapezoidownyvertex[i]);
4699         mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4700                                                                                                                         -fgkMountingBlockSupportWidth[0]);
4701         mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4702         sprintf(mountingblocksupportrapezoidowname,"MountingBlockSuppTrapezoidDownLay%d",i+5);
4703         mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
4704                                                                 mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
4705         mountingblocksupportrapezoidown[i]->SetLineColor(9);
4706   ////////////////////////////////////////////
4707   // Mounting Block Support Up Trapezoid Vertex
4708   ////////////////////////////////////////////
4709         mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4710         mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4711                                                                                                  - mountingsupportedge[i];
4712         mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4713         mountingblocksupportrapezoidupxvertex[i][1] =
4714                                                                                 mountingblocksupportrapezoidupxvertex[i][0];
4715         mountingblocksupportrapezoidupyvertex[i][1] =
4716                                                                                                mountingblockpieceupyvertex[i][0]
4717                                                                                                  + scalefactor*(mountingblockpieceupyvertex[i][1]
4718                                                                                              - mountingblockpieceupyvertex[i][0]);
4719         mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4720         mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4721         mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4722         mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4723         mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4724         mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
4725         mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4726                                                                                                                mountingblocksupportrapezoidupyvertex[i]);
4727         mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4728                                                                                                                         -fgkMountingBlockSupportWidth[0]);
4729         mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4730         sprintf(mountingblocksupportrapezoidupname,"MountingBlockSuppTrapezoidUpLay%d",i+5);
4731         mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
4732                                                                 mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
4733         mountingblocksupportrapezoidup[i]->SetLineColor(9);
4734   }
4735   ///////////////////////////////////////////////////////////////////
4736   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4737   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4738   Double_t boxoriginup[fgklayernumber][2][3];
4739   Double_t boxorigindown[fgklayernumber][2][3];
4740   char mountingblocksupportboxdownname[34];
4741   char mountingblocksupportboxupname[34];
4742   TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4743   mountingblocksupportrot->SetAngles(90.,180.,-90);
4744   TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4745   globalrefladdersupportrot->SetAngles(0.,90.,0.);
4746   TGeoHMatrix* laddersupportmatrix[2];
4747   laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4748   laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4749   /////////////////////////////////////////////////////////////
4750   // Creating Mother Volume for Containment
4751   /////////////////////////////////////////////////////////////
4752   Double_t *xmothervertex[fgklayernumber];
4753   Double_t *ymothervertex[fgklayernumber];
4754   for(Int_t i=0; i<fgklayernumber; i++){
4755         xmothervertex[i] = new Double_t[8];
4756         ymothervertex[i] = new Double_t[8];
4757   }
4758   TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4759   TGeoVolume* downmotherladdersupport[fgklayernumber];
4760   TGeoXtru* upmotherladdersupportshape[fgklayernumber];
4761   TGeoVolume* upmotherladdersupport[fgklayernumber];
4762   char upmotheladdersupportname[30];
4763   char downmotheladdersupportname[30];
4764   for(Int_t i=0; i<fgklayernumber; i++){
4765         xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4766                                                     -  mountingsupportedge[i];
4767         ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4768         xmothervertex[i][1] = xmothervertex[i][0];
4769         ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4770                                                         + fgkMountingBlockSupportWidth[0];
4771         xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4772         ymothervertex[i][2] = ymothervertex[i][1];
4773         xmothervertex[i][3] = xmothervertex[i][2];
4774         ymothervertex[i][3] = -ymothervertex[i][0];
4775         xmothervertex[i][4] = -xmothervertex[i][0];
4776         ymothervertex[i][4] = ymothervertex[i][3];
4777         xmothervertex[i][5] = xmothervertex[i][4];
4778         ymothervertex[i][5] = -ymothervertex[i][1];
4779         xmothervertex[i][6] = -xmothervertex[i][2];
4780         ymothervertex[i][6] = ymothervertex[i][5];
4781         xmothervertex[i][7] = xmothervertex[i][6];
4782         ymothervertex[i][7] = ymothervertex[i][0];
4783         sprintf(downmotheladdersupportname,"LadderSupportDownLay%d",i+5);
4784         sprintf(upmotheladdersupportname,"LadderSupportUpLay%d",i+5);
4785     downmotherladdersupportshape[i] = new TGeoXtru(2);
4786         downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4787         downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4788     downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4789                                                                    +                       fgkMountingBlockSupportDownHeight
4790                                                                    +                       fgkSSDMountingBlockHeight[1]
4791                                                                    -                       0.5*fgkCoolingTubeSupportHeight
4792                                                                    -                       fgkSSDModuleCoolingBlockToSensor
4793                                                                    -                       fgkSSDModuleVerticalDisalignment);
4794     downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4795                                                                           downmotherladdersupportshape[i],fSSDAir);
4796     upmotherladdersupportshape[i] = new TGeoXtru(2);
4797         upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4798         upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4799     upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4800                                                                    +                       fgkMountingBlockSupportUpHeight[i]
4801                                                                    +                       fgkSSDMountingBlockHeight[1]
4802                                                                    -                       0.5*fgkCoolingTubeSupportHeight
4803                                                                    -                       fgkSSDModuleCoolingBlockToSensor
4804                                                                    -               fgkSSDModuleVerticalDisalignment);
4805     upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4806                                                                                           upmotherladdersupportshape[i],fSSDAir);
4807   }
4808   for(Int_t i=0; i<fgklayernumber; i++){
4809         /////////////////////////
4810         // Setting the box origin
4811         /////////////////////////
4812         boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4813         boxorigindown[i][0][1] =  fgkMountingBlockSupportRadius[i]
4814                                                    +  0.5*fgkMountingBlockSupportDownHeight;
4815         boxorigindown[i][0][2] =  fgkMountingBlockSupportWidth[1]
4816                                                    -  0.5*fgkMountingBlockSupportWidth[0];
4817
4818         boxorigindown[i][1][0] = 0.0;
4819         boxorigindown[i][1][1] = boxorigindown[i][0][1];
4820         boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4821                                                    -      fgkMountingBlockSupportWidth[0]);
4822
4823         boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4824         boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
4825                                                  + 0.5*fgkMountingBlockSupportUpHeight[i];
4826         boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4827                                                  - 0.5*fgkMountingBlockSupportWidth[0];
4828
4829         boxoriginup[i][1][0] = 0.0;
4830         boxoriginup[i][1][1] = fgkMountingBlockSupportRadius[i]
4831                                                  + 0.5*fgkMountingBlockSupportUpHeight[i];
4832         boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4833                                                  - fgkMountingBlockSupportWidth[0]);
4834
4835         /////////////////////////
4836     // Setting the boxes
4837         /////////////////////////
4838         mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4839                                                                                  +  fgkSSDMountingBlockLength[0]),
4840                                                                                         0.5*fgkMountingBlockSupportDownHeight,
4841                                                                                         0.5*fgkMountingBlockSupportWidth[0],
4842                                                                                         boxorigindown[i][0]);
4843     mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4844                                                                                         0.5*fgkMountingBlockSupportDownHeight,
4845                                                                                         0.5*(fgkMountingBlockSupportWidth[1]
4846                                                                                  -  fgkMountingBlockSupportWidth[0]),
4847                                                                                         boxorigindown[i][1]);
4848
4849         mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4850                                                                                  +  fgkSSDMountingBlockLength[0]),
4851                                                                                         0.5*fgkMountingBlockSupportUpHeight[i],
4852                                                                                         0.5*fgkMountingBlockSupportWidth[0],
4853                                                                                         boxoriginup[i][0]);
4854
4855         mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4856                                                                                         0.5*fgkMountingBlockSupportUpHeight[i],
4857                                                                                         0.5*(fgkMountingBlockSupportWidth[1]
4858                                                                      -  fgkMountingBlockSupportWidth[0]),
4859                                                                                         boxoriginup[i][1]);
4860         ///////////////////////////////////////
4861     // Adding the Volumes to Mother Volume
4862         ///////////////////////////////////////
4863         for(Int_t j=0; j<2; j++){
4864                 sprintf(mountingblocksupportboxdownname,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4865                 sprintf(mountingblocksupportboxupname,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4866                 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4867                                                                                   mountingblocksupportboxdownshape[i][j],
4868                                                                                   fSSDCarbonFiberMedium);
4869                 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4870                                                                                   mountingblocksupportboxupshape[i][j],
4871                                                                                   fSSDCarbonFiberMedium);
4872                 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4873                 mountingblocksupportboxup[i][j]->SetLineColor(9);
4874                 for(Int_t k=0; k<2; k++){
4875                         downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
4876                         upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
4877                 }
4878         }
4879         for(Int_t k=0; k<2; k++){
4880                 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4881                 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4882                 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4883                 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4884             downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
4885                 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4886                 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4887                 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4888                 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4889                 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4890                 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4891                 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
4892         }
4893   }
4894   TList* laddersupportlist = new TList();
4895   laddersupportlist->Add(downmotherladdersupport[0]);
4896   laddersupportlist->Add(upmotherladdersupport[0]);
4897   laddersupportlist->Add(downmotherladdersupport[1]);
4898   laddersupportlist->Add(upmotherladdersupport[1]);
4899   /////////////////////////////////////////////////////////////
4900   // Deallocating memory
4901   /////////////////////////////////////////////////////////////
4902   for(Int_t i=0; i<fgklayernumber; i++){
4903         for(Int_t j=0; j<nedges+1; j++)
4904                 delete vertex[i][j];
4905         delete mountingsupportedgevector[i];
4906         delete [] vertex[i];
4907         delete vertexlist[i];
4908         delete [] xsidevertex[i];
4909         delete [] ysidevertex[i];
4910         delete [] xcentervertex[i];
4911         delete [] ycentervertex[i];
4912         delete [] xsidelowervertex[i];
4913         delete [] ysidelowervertex[i];
4914         delete [] xcenterlowervertex[i];
4915         delete [] ycenterlowervertex[i];
4916   }
4917   delete xsidevertex;
4918   delete ysidevertex;
4919   delete xcentervertex;
4920   delete ycentervertex;
4921   delete xsidelowervertex;
4922   delete ysidelowervertex;
4923   delete xcenterlowervertex;
4924   delete ycenterlowervertex;
4925   delete globalrefladdersupportrot;
4926   delete mountingblocksupportrot;
4927   /////////////////////
4928   return laddersupportlist;
4929 }
4930  ////////////////////////////////////////////////////////////////////////////////
4931 void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4932 //////////////////////////////////////////
4933 // Method Generating Ladder Support Ring
4934 //////////////////////////////////////////
4935   if(!fCreateMaterials) CreateMaterials();
4936   if(!fTransformationMatrices) CreateTransformationMatrices();
4937   if(!fBasicObjects) CreateBasicObjects();
4938   fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4939   fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4940     const Int_t kssdlayladdernumber[fgklayernumber] =
4941                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4942   Double_t mountingsupportedge[fgklayernumber];
4943   Double_t mountingblockratio[fgklayernumber];
4944   Double_t theta[fgklayernumber];
4945   Double_t phi[fgklayernumber];
4946   for(Int_t i=0; i<fgklayernumber; i++){
4947         mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4948     mountingsupportedge[i]    = 0.5*fgkMountingBlockSupportRadius[i]
4949                                                           *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
4950                                                           * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4951                                                           - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4952                                                           / kssdlayladdernumber[i])));
4953     theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4954                          / fgkMountingBlockSupportRadius[i]);
4955     phi[i]   = TMath::ASin(0.5*mountingblockratio[i]);
4956   }
4957   TGeoRotation* globalrot = new TGeoRotation();
4958   globalrot->SetAngles(0.,-90.,0.);
4959   TGeoRotation** laddersupportrot[fgklayernumber];
4960   TGeoHMatrix**  laddersupportmatrix[fgklayernumber];
4961   for(Int_t i=0; i<fgklayernumber; i++){
4962         laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
4963         laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
4964         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4965                 laddersupportrot[i][j] = new TGeoRotation();
4966                 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
4967                 switch(i){
4968                         case 0: //Ladder of Layer5
4969                                 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4970                                 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
4971                                                                             laddersupportmatrix[i][j]);
4972                         break;
4973                         case 1: //Ladder of Layer6
4974                                 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4975                                 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
4976                                                                               laddersupportmatrix[i][j]);
4977                         break;
4978                 }
4979     }
4980   }
4981   /////////////////////////////////////////////////////////////
4982   // Creating Lower Ladder Support
4983   /////////////////////////////////////////////////////////////
4984   TVector3** ringsupportvertex[fgklayernumber];
4985   Double_t angle = 360./nedges;
4986   for(Int_t i=0; i<fgklayernumber; i++){
4987     ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
4988         ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
4989                                                         *                          TMath::Cos(theta[i]));
4990         ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
4991                                                         -                          mountingsupportedge[i],
4992                                                                                    ringsupportvertex[i][0]->Y());
4993         ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
4994                                                                                    ringsupportvertex[i][1]->Y());
4995     ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
4996         for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4997            ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
4998            ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
4999            ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
5000            ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
5001         }
5002         ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
5003     for(Int_t j=0; j<nedges+1; j++){
5004                 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
5005                         new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*CosD(90.0-j*angle),
5006                                                  (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*SinD(90.0-j*angle));
5007         }
5008   }
5009   Double_t **xmothervertex = new Double_t*[fgklayernumber];
5010   Double_t **ymothervertex = new Double_t*[fgklayernumber];
5011   for(Int_t i=0; i<fgklayernumber; i++){
5012         xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5013         ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5014         for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
5015                 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
5016                 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
5017         }
5018   }
5019   char lowerladdersupportname[30];
5020   TGeoXtru* lowerladdersupportshape[fgklayernumber];
5021   TGeoVolume* lowerladdersupport[fgklayernumber];
5022   TGeoRotation* lowerladdersupportrot = new TGeoRotation();
5023   lowerladdersupportrot->SetAngles(90.,180.,-90);
5024   for(Int_t i=0; i<fgklayernumber; i++){
5025         lowerladdersupportshape[i] = new TGeoXtru(2);
5026         lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
5027                                                                                           xmothervertex[i],ymothervertex[i]);
5028         lowerladdersupportshape[i]->DefineSection(0,0.);
5029     lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
5030         sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
5031     lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
5032                                                         lowerladdersupportshape[i],fSSDSupportRingAl);
5033         lowerladdersupport[i]->SetLineColor(fColorAl);
5034         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
5035         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
5036   }
5037   /////////////////////////////////////////////////////////////
5038   // Deallocating memory
5039   /////////////////////////////////////////////////////////////
5040   for(Int_t i=0; i<fgklayernumber; i++){
5041         for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
5042                 delete ringsupportvertex[i][j];
5043         delete [] ringsupportvertex[i];
5044   }
5045   for(Int_t i=0; i<fgklayernumber; i++){
5046         delete [] xmothervertex[i];
5047         delete [] ymothervertex[i];
5048   }
5049   delete xmothervertex;
5050   delete ymothervertex;
5051   delete globalrot;
5052   for(Int_t i=0; i<fgklayernumber; i++){
5053         for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
5054                 delete laddersupportrot[i][j];
5055         delete [] laddersupportrot[i];
5056   }
5057  }
5058  ////////////////////////////////////////////////////////////////////////////////
5059  TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
5060   /////////////////////////////////////////////////////////////
5061   // Method generating Endcap CoverPlate
5062   /////////////////////////////////////////////////////////////
5063   // Holes Definition
5064   ///////////////////
5065   Int_t nendcapcoverplateholedges = 30;
5066   const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
5067   Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
5068                                                           0.5*fgkEndCapCoverPlateThickness};
5069   TGeoXtru* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
5070                                                                                                               nendcapcoverplateholedges,holesection);
5071   TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
5072                                                                                   endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
5073   endcapcoverplatesmallhole->SetLineColor(6);
5074   TGeoXtru* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
5075                                                                                                               nendcapcoverplateholedges,holesection);
5076   TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
5077                                                                                   endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
5078   endcapcoverplatebighole->SetLineColor(6);
5079   //////////////////////////
5080   // Screw Piece Definition
5081   //////////////////////////
5082   Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
5083   TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
5084                                                                                                       CosD(0.5*smallscrewangle),
5085                                                                                                       0.5*fgkEndCapCoverPlateThickness);
5086   TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
5087                                                                                                 endcapsmallscrewpieceshape,
5088                                                                                                 fSSDCoolingTubePhynox);
5089   endcapsmallscrewpiece->SetLineColor(fColorPhynox);
5090   ///////////////////
5091   // Box Definition
5092   ///////////////////
5093   TGeoBBox* endcapcoverplateboxshape[4];
5094   TGeoVolume* endcapcoverplatebox[4];
5095   Double_t boxorigin[5][3];
5096   boxorigin[0][0] = 0.;
5097   boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
5098   boxorigin[0][2] = 0.;
5099
5100   boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
5101   boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
5102   boxorigin[1][2] = 0.;
5103
5104   boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
5105                                   + fgkEndCapCoverPlateSmallHoleSeparation[1];
5106   boxorigin[2][1] = boxorigin[1][1];
5107   boxorigin[2][2] = 0.;
5108
5109   boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
5110                                   + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
5111   boxorigin[3][1] = boxorigin[1][1];
5112   boxorigin[3][2] = 0.;
5113
5114   endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5115                                                                                 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
5116                                                  -              2.*fgkEndCapCoverPlateSmallHoleRadius),
5117                                                                             0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
5118
5119   endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5120                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
5121                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5122                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
5123                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
5124
5125   endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5126                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
5127                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5128                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
5129                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
5130
5131   endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
5132                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
5133                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5134                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
5135                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
5136
5137   endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
5138                                                                            fSSDAlCoolBlockMedium);
5139   endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
5140                                                                            fSSDAlCoolBlockMedium);
5141   endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
5142                                                                            fSSDAlCoolBlockMedium);
5143   endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
5144                                                                            fSSDAlCoolBlockMedium);
5145   endcapcoverplatebox[0]->SetLineColor(6);
5146   endcapcoverplatebox[1]->SetLineColor(6);
5147   endcapcoverplatebox[2]->SetLineColor(6);
5148   endcapcoverplatebox[3]->SetLineColor(6);
5149   Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
5150   TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5151                                                                                         fgkEndCapCoverPlateSmallHoleRadius,
5152                                                                                         0.5*fgkEndCapCoverPlateThickness,
5153                                                                                         endcapfillingboxorigin);
5154   TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
5155                                                                            fSSDAlCoolBlockMedium);
5156   endcapfillingbox->SetLineColor(6);
5157   ////////////////////////////
5158   // Contour Xtru Definition
5159   ////////////////////////////
5160   const Int_t kcontourvertexnumber = 10;
5161   Double_t xcontourvertex[kcontourvertexnumber];
5162   Double_t ycontourvertex[kcontourvertexnumber];
5163   xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
5164   xcontourvertex[1] = xcontourvertex[0];
5165   xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5166   xcontourvertex[3] = xcontourvertex[2];
5167   xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
5168   xcontourvertex[5] = xcontourvertex[4];
5169   xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5170   xcontourvertex[7] = xcontourvertex[6];
5171   xcontourvertex[8] = xcontourvertex[4];
5172   xcontourvertex[9] = xcontourvertex[8];
5173   ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5174                                         - (kendcapcoverplatesmallholenumber[1]-1)
5175                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5176   ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
5177                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5178   ycontourvertex[2] = ycontourvertex[1];
5179   ycontourvertex[3] = ycontourvertex[0];
5180   ycontourvertex[4] = ycontourvertex[3];
5181   ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
5182   ycontourvertex[6] = ycontourvertex[5];
5183   ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
5184                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]
5185                                         + fgkEndCapCoverPlateSmallHoleRadius;
5186   ycontourvertex[8] = ycontourvertex[7];
5187   ycontourvertex[9] = ycontourvertex[0];
5188   TGeoXtru* contourshape = new TGeoXtru(2);
5189   contourshape->DefinePolygon(kcontourvertexnumber,xcontourvertex,ycontourvertex);
5190   contourshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5191   contourshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5192   TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5193                                                                            fSSDAlCoolBlockMedium);
5194   contour->SetLineColor(6);
5195   /////////////////////////////
5196   // Hole Contour Xtru Definition
5197   ////////////////////////////
5198   const Int_t kholecontourvertexnumber = 10;
5199   Double_t xholecontourvertex[2][kcontourvertexnumber];
5200   Double_t yholecontourvertex[2][kcontourvertexnumber];
5201   xholecontourvertex[0][0] = xcontourvertex[0];
5202   xholecontourvertex[0][1] = xholecontourvertex[0][0];
5203   xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5204   xholecontourvertex[0][3] = xholecontourvertex[0][2];
5205   xholecontourvertex[0][4] = xholecontourvertex[0][0]
5206                                                    + 0.5*(fgkEndCapCoverPlateLength[2]
5207                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5208   xholecontourvertex[0][5] = xholecontourvertex[0][4];
5209   xholecontourvertex[0][6] = xholecontourvertex[0][5]
5210                                                    + 2.*fgkEndCapCoverPlateBigHoleRadius;
5211   xholecontourvertex[0][7] = xholecontourvertex[0][6];
5212   xholecontourvertex[0][8] = xholecontourvertex[0][4];
5213   xholecontourvertex[0][9] = xholecontourvertex[0][8];
5214
5215   yholecontourvertex[0][0] = ycontourvertex[1];
5216   yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5217   yholecontourvertex[0][2] = yholecontourvertex[0][1];
5218   yholecontourvertex[0][3] = yholecontourvertex[0][0];
5219   yholecontourvertex[0][4] = yholecontourvertex[0][3];
5220   yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5221                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5222   yholecontourvertex[0][6] = yholecontourvertex[0][5];
5223   yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5224   yholecontourvertex[0][8] = yholecontourvertex[0][7];
5225   yholecontourvertex[0][9] = yholecontourvertex[0][0];
5226
5227   xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5228   xholecontourvertex[1][1] = xholecontourvertex[1][0];
5229   xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5230   xholecontourvertex[1][3] = xholecontourvertex[1][2];
5231   xholecontourvertex[1][4] = xholecontourvertex[1][0]
5232                                                    + 0.5*(fgkEndCapCoverPlateLength[2]
5233                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5234   xholecontourvertex[1][5] = xholecontourvertex[1][4];
5235   xholecontourvertex[1][6] = xholecontourvertex[1][5]
5236                                                    + 2.*fgkEndCapCoverPlateBigHoleRadius;
5237   xholecontourvertex[1][7] = xholecontourvertex[1][6];
5238   xholecontourvertex[1][8] = xholecontourvertex[1][4];
5239   xholecontourvertex[1][9] = xholecontourvertex[1][8];
5240
5241   yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5242                                                    - fgkEndCapCoverPlateWidth[0]);
5243   yholecontourvertex[1][1] = ycontourvertex[0];
5244   yholecontourvertex[1][2] = yholecontourvertex[1][1];
5245   yholecontourvertex[1][3] = yholecontourvertex[1][0];
5246   yholecontourvertex[1][4] = yholecontourvertex[1][3];
5247   yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5248                                                    - fgkEndCapCoverPlateWidth[0]
5249                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5250   yholecontourvertex[1][6] = yholecontourvertex[1][5];
5251   yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5252   yholecontourvertex[1][8] = yholecontourvertex[1][7];
5253   yholecontourvertex[1][9] = yholecontourvertex[1][0];
5254
5255   TGeoXtru* holecontourshape[2];
5256   holecontourshape[0] = new TGeoXtru(2);
5257   holecontourshape[0]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[0],
5258                                                                   yholecontourvertex[0]);
5259   holecontourshape[0]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5260   holecontourshape[0]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5261
5262   holecontourshape[1] = new TGeoXtru(2);
5263   holecontourshape[1]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[1],
5264                                                                   yholecontourvertex[1]);
5265   holecontourshape[1]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5266   holecontourshape[1]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5267
5268   TGeoVolume* holecontour[2];
5269   holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",holecontourshape[0],
5270                                                                   fSSDAlCoolBlockMedium);
5271   holecontour[0]->SetLineColor(6);
5272   holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",holecontourshape[1],
5273                                                                   fSSDAlCoolBlockMedium);
5274   holecontour[1]->SetLineColor(6);
5275   TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5276                                                                         +     fgkEndCapCoverPlateLength[2],0.,0.);
5277   TGeoTranslation*  bigholetrans[3];
5278   bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5279                                                                                 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5280   bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5281                                   +                     fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5282                                   -                                             fgkEndCapCoverPlateBigHoleRadius,0.0);
5283   bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5284                                                                                 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5285   /////////////////////////////////
5286   // Mother Volume Xtru Definition
5287   /////////////////////////////////
5288   const Int_t kmothervertexnumber = 12;
5289   Double_t xmothervertex[kmothervertexnumber];
5290   Double_t ymothervertex[kmothervertexnumber];
5291   xmothervertex[0]  = xcontourvertex[0];
5292   xmothervertex[1]  = xmothervertex[0];
5293   xmothervertex[2]  = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5294   xmothervertex[3]  = xmothervertex[2];
5295   xmothervertex[4]  = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5296   xmothervertex[5]  = xmothervertex[4];
5297   xmothervertex[6]  = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5298   xmothervertex[7]  = xmothervertex[6];
5299   xmothervertex[8]  = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5300                                         + fgkEndCapCoverPlateLength[2];
5301   xmothervertex[9]  = xmothervertex[8];
5302   xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5303   xmothervertex[11] = xmothervertex[10];
5304
5305   ymothervertex[0]  = ycontourvertex[0];
5306   ymothervertex[1]  = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5307   ymothervertex[2]  = ymothervertex[1];
5308   ymothervertex[3]  = ycontourvertex[1];
5309   ymothervertex[4]  = ymothervertex[3];
5310   ymothervertex[5]  = ymothervertex[1];
5311   ymothervertex[6]  = ymothervertex[5];
5312   ymothervertex[7]  = ymothervertex[0];
5313   ymothervertex[8]  = ymothervertex[7];
5314   ymothervertex[9]  = ymothervertex[8]
5315                                    - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5316   ymothervertex[10] = ymothervertex[9];
5317   ymothervertex[11] = ymothervertex[8];
5318   TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5319   mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5320   mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5321   mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5322   TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5323   ////////////////////////////////////////
5324   // Adding Nodes
5325   ////////////////////////////////////////
5326 //  TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5327   TGeoTranslation*** endcapcoverplatesmallholetrans;
5328   endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5329   Double_t transx[4] = {0,
5330                                                 fgkEndCapCoverPlateSmallHoleSeparation[0],
5331                                                 fgkEndCapCoverPlateSmallHoleSeparation[0]
5332                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1],
5333                                          2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5334                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1]};
5335   Int_t index = 0;
5336   for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5337         endcapcoverplatesmallholetrans[i] =
5338                                         new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5339     for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5340                 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5341             endcapcoverplatesmallholetrans[i][j] =
5342                 new TGeoTranslation(transx[i],
5343                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5344             if(index!=10){
5345                         mothercoverplate->AddNode(endcapcoverplatesmallhole,
5346                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5347                         mothercoverplate->AddNode(endcapsmallscrewpiece,
5348                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5349                 }
5350                 if(j<kendcapcoverplatesmallholenumber[1]-1)
5351                         mothercoverplate->AddNode(endcapcoverplatebox[0],
5352                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5353     }
5354   }
5355   mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5356   mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5357   mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5358   mothercoverplate->AddNode(endcapfillingbox,1);
5359   mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5360   mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5361   mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5362   mothercoverplate->AddNode(holecontour[0],1);
5363   mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5364   mothercoverplate->AddNode(holecontour[1],1);
5365   mothercoverplate->AddNode(contour,1);
5366   /////////////////////////////////
5367   return mothercoverplate;
5368  }
5369  ////////////////////////////////////////////////////////////////////////////////
5370  TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5371   /////////////////////////////////////////////////////////////
5372   // Getting EndCap Cooling Tube
5373   /////////////////////////////////////////////////////////////
5374   TGeoTorus* endcapcoolingtubetorushape[5];
5375   TGeoVolume* endcapcoolingtubetorus[5];
5376   TGeoTube* endcapcoolingtubeshape[4];
5377   TGeoVolume* endcapcoolingtube[4];
5378   char endcapcoolingtubetorusname[30];
5379   char endcapcoolingtubename[30];
5380   TGeoTorus* endcapcoolingwatertubetorushape[5];
5381   TGeoVolume* endcapcoolingwatertubetorus[5];
5382   TGeoTube* endcapcoolingwatertubeshape[4];
5383   TGeoVolume* endcapcoolingwatertube[4];
5384   char endcapcoolingwatertubetorusname[30];
5385   char endcapcoolingwatertubename[30];
5386   for(Int_t i=0; i<5; i++){
5387         sprintf(endcapcoolingtubetorusname,"EndCapCoolingTubeTorus%d",i+1);
5388         sprintf(endcapcoolingtubename,"EndCapCoolingTube%d",i+1);
5389         sprintf(endcapcoolingwatertubetorusname,"EndCapCoolingWaterTubeTorus%d",i+1);
5390         sprintf(endcapcoolingwatertubename,"EndCapCoolingWaterTube%d",i+1);
5391         if(i==3){
5392                 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5393                                                                                 fgkEndCapCoolingTubeRadiusMin,
5394                                                                                 fgkEndCapCoolingTubeRadiusMax,
5395                                                                                 90.0,fgkEndCapCoolingTubeAngle[3]);
5396                 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5397                                                                                 0.,fgkEndCapCoolingTubeRadiusMin,
5398                                                                                 90.0,fgkEndCapCoolingTubeAngle[3]);
5399     }
5400         else{
5401                 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5402                                                                           :fgkEndCapCoolingTubeAxialRadius[1],
5403                                                                            fgkEndCapCoolingTubeRadiusMin,
5404                                                                            fgkEndCapCoolingTubeRadiusMax,
5405                                                                     0.,fgkEndCapCoolingTubeAngle[i]);
5406                 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5407                                                                                :fgkEndCapCoolingTubeAxialRadius[1],
5408                                                                                  0.,fgkEndCapCoolingTubeRadiusMin,
5409                                                                          0.,fgkEndCapCoolingTubeAngle[i]);
5410         }
5411         endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5412                                                                                            endcapcoolingtubetorushape[i],
5413                                                                                            fSSDCoolingTubePhynox);
5414         endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5415                                                                                                         endcapcoolingwatertubetorushape[i],
5416                                                                                                         fSSDCoolingTubeWater);
5417     endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5418     endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5419     if(i<4){
5420                 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5421                                                                   fgkEndCapCoolingTubeRadiusMax,
5422                                                           0.5*fgkEndCapCoolingTubeLength[i]);
5423                 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5424                                                           0.5*fgkEndCapCoolingTubeLength[i]);
5425         endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5426                                                          endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5427         endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5428                                                          endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5429                 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5430                 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5431         }
5432   }
5433   TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5434   /////////////////////////////////////////
5435   // Transformation for Volume Positioning
5436   /////////////////////////////////////////
5437   TGeoCombiTrans* coolingtubecombitrans[6];
5438   TGeoRotation* coolingtuberot[8];
5439   TGeoTranslation* coolingtubetrans[6];
5440   TGeoHMatrix* coolingtubematrix[4];
5441   TGeoCombiTrans* torustubecombitrans[4];
5442   TGeoRotation* torustuberot[7];
5443   TGeoTranslation* torustubetrans[4];
5444   TGeoHMatrix* torustubematrix[5];
5445   TGeoCombiTrans* coolingwatertubecombitrans[6];
5446   TGeoRotation* coolingwatertuberot[8];
5447   TGeoTranslation* coolingwatertubetrans[6];
5448   TGeoHMatrix* coolingwatertubematrix[4];
5449   TGeoCombiTrans* toruswatertubecombitrans[4];
5450   TGeoRotation* toruswatertuberot[7];
5451   TGeoTranslation* toruswatertubetrans[4];
5452   TGeoHMatrix* toruswatertubematrix[5];
5453   for(Int_t i=0; i<8; i++){
5454     if(i<6){
5455          coolingtubetrans[i] = new TGeoTranslation();
5456          coolingwatertubetrans[i] = new TGeoTranslation();
5457     }
5458     if(i<8){
5459          coolingtuberot[i] = new TGeoRotation();
5460          coolingwatertuberot[i] = new TGeoRotation();
5461     }
5462     if(i<4){
5463          torustubetrans[i] = new TGeoTranslation();
5464          toruswatertubetrans[i] = new TGeoTranslation();
5465     }
5466     if(i<7){
5467          torustuberot[i] = new TGeoRotation();
5468          toruswatertuberot[i] = new TGeoRotation();
5469         }
5470   }
5471   /////////////////////////////////////////
5472   // Transformation for Inox Volume Positioning
5473   /////////////////////////////////////////
5474   coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5475                                                                           -endcapcoolingtubeshape[0]->GetDz(),0.);
5476   coolingtuberot[0]->SetAngles(0.,90.,0.);
5477   coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5478                                                                                                 *coolingtuberot[0]);
5479
5480   coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5481   coolingtuberot[1]->SetAngles(0.,90.,0.);
5482   coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5483                                                                                                 *coolingtuberot[1]);
5484
5485   coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5486                                                                          *CosD(fgkEndCapCoolingTubeAngle[0]),
5487                                                                           fgkEndCapCoolingTubeAxialRadius[0]
5488                                                                          *SinD(fgkEndCapCoolingTubeAngle[0]),
5489                                                                           0.);
5490   coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5491   coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5492                                                                                                 *coolingtuberot[2]);
5493
5494   coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5495                                            *                             (*coolingtubecombitrans[1]));
5496
5497   torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5498                                                                          endcapcoolingtubeshape[1]->GetDz());
5499   torustuberot[0]->SetAngles(0.,90.,0.);
5500   torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5501
5502   torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5503
5504   coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5505                                                                           -endcapcoolingtubeshape[2]->GetDz(),0.);
5506   coolingtuberot[3]->SetAngles(0.,90.,0.);
5507   coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5508                                                                                                 *coolingtuberot[3]);
5509   coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5510   coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5511   coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5512
5513   torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5514                                                                         endcapcoolingtubeshape[2]->GetDz());
5515   torustuberot[1]->SetAngles(0.,90.,0.);
5516   torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5517   torustuberot[2]->SetAngles(180.,0.,0.);
5518   torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5519   torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5520
5521   torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5522                                                                         -fgkEndCapCoolingTubeAxialRadius[0]);
5523   torustuberot[3]->SetAngles(0.,90.,0.);
5524   torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5525   torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5526   torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5527   torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5528
5529   coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5530                                                                           fgkEndCapCoolingTubeAxialRadius[0],0.);
5531   coolingtuberot[5]->SetAngles(90.,90.,-90.);
5532   coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5533                                                                                                 *coolingtuberot[5]);
5534   coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5535   coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5536   coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5537
5538   torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5539                                                                         endcapcoolingtubeshape[0]->GetDz());
5540   torustuberot[5]->SetAngles(0.,90.,0.);
5541   torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5542   torustuberot[6]->SetAngles(-90.,0.,0.);
5543   torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5544   torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5545
5546   coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5547                                                                           endcapcoolingtubeshape[3]->GetDz(),0.);
5548   coolingtuberot[6]->SetAngles(0.,90.,0.);
5549   coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5550                                                                                                 *coolingtuberot[6]);
5551   coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5552   coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5553   coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5554     /////////////////////////////////////////
5555   // Transformation for Water Volume Positioning
5556   /////////////////////////////////////////
5557   coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5558                                                                           -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5559   coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5560   coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5561                                                                                                      *coolingwatertuberot[0]);
5562
5563   coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5564   coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5565   coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5566                                                                                                      *coolingwatertuberot[1]);
5567
5568   coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5569                                                                                   *CosD(fgkEndCapCoolingTubeAngle[0]),
5570                                                                                   fgkEndCapCoolingTubeAxialRadius[0]
5571                                                                                   *SinD(fgkEndCapCoolingTubeAngle[0]),
5572                                                                               0.);
5573   coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5574   coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5575                                                                                                     *coolingwatertuberot[2]);
5576
5577   coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5578                                            *                                 (*coolingwatertubecombitrans[1]));
5579
5580   toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5581                                                                          endcapcoolingwatertubeshape[1]->GetDz());
5582   toruswatertuberot[0]->SetAngles(0.,90.,0.);
5583   toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5584                                                                                                    *toruswatertuberot[0]);
5585
5586   toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5587                                                   *                                     (*toruswatertubecombitrans[0]));
5588
5589   coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5590                                                                           -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5591   coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5592   coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5593                                                                                                      *coolingwatertuberot[3]);
5594   coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5595   coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5596                                                         *                                 (*coolingwatertubecombitrans[3]));
5597   coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5598
5599   toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5600                                                                         endcapcoolingwatertubeshape[2]->GetDz());
5601   toruswatertuberot[1]->SetAngles(0.,90.,0.);
5602   toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5603                                                                                                    *toruswatertuberot[1]);
5604   toruswatertuberot[2]->SetAngles(180.,0.,0.);
5605   toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5606                                                   *                 (*toruswatertubecombitrans[1]));
5607   toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5608
5609   toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5610                                                                                    -fgkEndCapCoolingTubeAxialRadius[0]);
5611   toruswatertuberot[3]->SetAngles(0.,90.,0.);
5612   toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5613                                                                                                    *toruswatertuberot[3]);
5614   toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5615   toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5616                                                   *                                     (*toruswatertubecombitrans[2]));
5617   toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5618
5619   coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5620                                                                                 fgkEndCapCoolingTubeAxialRadius[0],0.);
5621   coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5622   coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5623                                                                                                      *coolingwatertuberot[5]);
5624   coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5625   coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5626                                                         *                                 (*coolingwatertubecombitrans[4]));
5627   coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5628
5629   toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5630                                                                               endcapcoolingwatertubeshape[0]->GetDz());
5631   toruswatertuberot[5]->SetAngles(0.,90.,0.);
5632   toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5633                                                                                                    *toruswatertuberot[5]);
5634   toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5635   toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5636                                                   *                 (*toruswatertubecombitrans[3]));
5637   toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5638
5639   coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5640                                                                           endcapcoolingwatertubeshape[3]->GetDz(),0.);
5641   coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5642   coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5643                                                                                                      *coolingwatertuberot[6]);
5644   coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5645   coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5646                                                         *                                 (*coolingwatertubecombitrans[5]));
5647   coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5648   /////////////////////////////////////////
5649   // Positioning Volumes
5650   /////////////////////////////////////////
5651   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5652   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5653
5654   endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5655   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5656
5657   endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5658   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5659
5660   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5661   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5662
5663   endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5664   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5665
5666   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5667   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5668
5669   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5670   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5671
5672   endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5673   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5674
5675   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5676   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5677
5678   endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5679   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5680   /////////////////////////////////////////////////////////////
5681   // Deallocating memory
5682   /////////////////////////////////////////////////////////////
5683   for(Int_t i=0; i<8; i++){
5684     if(i<6){
5685          delete coolingtubetrans[i];
5686          delete coolingwatertubetrans[i];
5687          if(i!=0){
5688           delete coolingtubecombitrans[i];
5689           delete coolingwatertubecombitrans[i];
5690          }
5691         }
5692     if(i<8){
5693           delete coolingtuberot[i];
5694           delete coolingwatertuberot[i];
5695     }
5696     if(i<4){
5697                 delete torustubetrans[i];
5698                 delete toruswatertubetrans[i];
5699                 delete torustubecombitrans[i];
5700                 delete toruswatertubecombitrans[i];
5701         }
5702     if(i<7){
5703          delete torustuberot[i];
5704          delete toruswatertuberot[i];
5705         }
5706   }
5707   /////////////////////////////////////////////////////////////
5708   return endcapcoolingtubemother;
5709  }
5710  ////////////////////////////////////////////////////////////////////////////////
5711  TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5712   /////////////////////////////////////////////////////////////
5713   // Getting EndCap Cover Side
5714   /////////////////////////////////////////////////////////////
5715   const Int_t kendcapcoverholenumber[2] = {7,5};
5716   const Int_t kvertexnumber = 15;
5717   Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5718   xvertex[0]  = 0.0;
5719   xvertex[1]  = xvertex[0];
5720   xvertex[2]  = fgkEndCapSideCoverLength[0];
5721   xvertex[3]  = fgkEndCapSideCoverLength[1];
5722   xvertex[4]  = xvertex[3];
5723   xvertex[5]  = fgkEndCapSideCoverLength[2];
5724   xvertex[6]  = xvertex[5];
5725   xvertex[7]  = xvertex[2];
5726   xvertex[8]  = xvertex[7];
5727   xvertex[9]  = xvertex[6]-fgkEndCapSideCoverLength[0];
5728   xvertex[10] = xvertex[9];
5729   xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5730                           * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5731                           * fgkEndCapSideCoverLength[4];
5732   xvertex[12] = xvertex[11];
5733   xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5734                           * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5735                           * fgkEndCapSideCoverLength[4];
5736   xvertex[14] = xvertex[13];
5737   yvertex[0]  = 0.0;
5738   yvertex[1]  = fgkEndCapSideCoverWidth[0];
5739   yvertex[2]  = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5740   yvertex[3]  = yvertex[2];
5741   yvertex[4]  = fgkEndCapSideCoverWidth[1];
5742   yvertex[5]  = yvertex[4];
5743   yvertex[6]  = yvertex[0];
5744   yvertex[7]  = yvertex[6];
5745   yvertex[8]  = fgkEndCapSideCoverWidth[6];
5746   yvertex[9]  = yvertex[8];
5747   yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5748   yvertex[11] = yvertex[10];
5749   yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5750   yvertex[13] = yvertex[12];
5751   yvertex[14] = yvertex[6];
5752   TGeoXtru* endcapsidecovershape = new TGeoXtru(2);
5753   endcapsidecovershape->DefinePolygon(kvertexnumber,xvertex,yvertex);
5754   endcapsidecovershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5755   endcapsidecovershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5756   TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5757                                                                 endcapsidecovershape,fSSDCoolingTubePhynox);
5758   endcapsidecover->SetLineColor(fColorPhynox);
5759   ////////////////////////////////////////////
5760   // Defininition of Mother Volume
5761   ////////////////////////////////////////////
5762   const Int_t kmothervertexnumber = 7;
5763   Double_t xmothervertex[kmothervertexnumber];
5764   Double_t ymothervertex[kmothervertexnumber];
5765   for(Int_t i=0; i<kmothervertexnumber; i++){
5766         xmothervertex[i] = xvertex[i];
5767         ymothervertex[i] = yvertex[i];
5768   }
5769   TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5770   endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5771   endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5772   endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5773   TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5774                                                                 endcapsidecovermothershape,fSSDAir);
5775   ////////////////////////////////////////////
5776   endcapsidecovermother->AddNode(endcapsidecover,1);
5777   TGeoBBox* endcapsidecoverboxshape[4];
5778   endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5779                                                          +     (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5780                                                                0.5*fgkEndCapSideCoverLength[4],
5781                                                                    0.5*fgkEndCapSideCoverThickness);
5782   endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5783                                                          +     (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5784                                                                0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5785                                                          -     fgkEndCapSideCoverLength[4]),
5786                                                                    0.5*fgkEndCapSideCoverThickness);
5787   endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5788                                                                0.5*fgkEndCapSideCoverLength[4],
5789                                                                    0.5*fgkEndCapSideCoverThickness);
5790   endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5791                                                                0.5*fgkEndCapSideCoverWidth[5],
5792                                                                    0.5*fgkEndCapSideCoverThickness);
5793   TGeoVolume* endcapsidecoverbox[4];
5794   endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5795   endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5796   endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5797   endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5798   for(Int_t i=0; i<4; i++)   endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5799 //  TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5800   TGeoTranslation** endcapsidecoverboxtrans;
5801   endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5802   endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5803                                                          +                                         fgkEndCapSideCoverLength[0],
5804                                                                                                    endcapsidecoverboxshape[0]->GetDY()
5805                                                          +                     yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5806   endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5807                                                          +                     xvertex[11],
5808                                                                                                    endcapsidecoverboxshape[1]->GetDY()
5809                                                          +                     yvertex[12],0.);
5810   endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5811                                                          +                     xvertex[11],
5812                                                                                                    endcapsidecoverboxshape[2]->GetDY()
5813                                                          +                     yvertex[12]
5814                                                          +                                         2.*endcapsidecoverboxshape[1]->GetDY()
5815                                                          +                     fgkEndCapSideCoverWidth[5],0.);
5816   endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5817   endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5818   endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5819   for(Int_t i=0; i<2; i++)
5820         for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5821                 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5822                         new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5823                                                                 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5824                                                                 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5825                                                                 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5826                 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5827                                                                 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5828         }
5829   for(Int_t i=0; i<2; i++)
5830         for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5831                 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5832                 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5833                                                         +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5834                                                         endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5835                                                         +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5836                                                         +fgkEndCapSideCoverLength[4]),0.0);
5837                 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5838                                                                 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5839                                                                 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5840                                                                 +i*(kendcapcoverholenumber[1]-1)+j]);
5841         }
5842         return endcapsidecovermother;
5843  }
5844  ////////////////////////////////////////////////////////////////////////////////
5845  TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5846  ////////////////////////////////////////////////////////////////////////////////
5847  // Method returning Interface Card A, Interface Card B, Supply Card
5848  ////////////////////////////////////////////////////////////////////////////////
5849  /////////////////////
5850  // Supply Card
5851  /////////////////////
5852  // Electronic Board Back Al Plane
5853  const Int_t kelectboardbackvertexnumber = 8;
5854  Double_t xelectboardback[kelectboardbackvertexnumber];
5855  Double_t yelectboardback[kelectboardbackvertexnumber];
5856  xelectboardback[0] = 0.0;
5857  xelectboardback[1] = xelectboardback[0];
5858  xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5859  xelectboardback[3] = xelectboardback[2];
5860  xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5861  xelectboardback[5] = xelectboardback[4];
5862  xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5863  xelectboardback[7] = xelectboardback[6];
5864
5865  yelectboardback[0] = 0.0;
5866  yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5867  yelectboardback[2] = yelectboardback[1];
5868  yelectboardback[3] = yelectboardback[0];
5869  yelectboardback[4] = yelectboardback[3];
5870  yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5871  yelectboardback[6] = yelectboardback[5];
5872  yelectboardback[7] = yelectboardback[4];
5873  TGeoXtru* electboardbackshape = new TGeoXtru(2);
5874  electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5875                                                                         xelectboardback,yelectboardback);
5876  electboardbackshape->DefineSection(0,0.0);
5877  electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5878  TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5879                                                                                          electboardbackshape,fSSDSupportRingAl);
5880  electboardback->SetLineColor(fColorAl);
5881  // Electronic Board Kapton Layer
5882  const Int_t kelectlayervertexnumber = 8;
5883  Double_t xelectlayer[kelectlayervertexnumber];
5884  Double_t yelectlayer[kelectlayervertexnumber];
5885  xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5886  xelectlayer[1] = xelectlayer[0];
5887  xelectlayer[2] = fgkEndCapCardElectBoardLength;
5888  xelectlayer[3] = xelectlayer[2];
5889  for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5890
5891  yelectlayer[0] = 0.0;
5892  yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5893  yelectlayer[2] = yelectlayer[1];
5894  yelectlayer[3] = yelectlayer[0];
5895  yelectlayer[4] = yelectlayer[3];
5896  yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5897  yelectlayer[6] = yelectlayer[5];
5898  yelectlayer[7] = yelectlayer[4];
5899  TGeoXtru* electlayershape = new TGeoXtru(2);
5900  electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5901  electlayershape->DefineSection(0,0.0);
5902  electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5903  TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5904                                                                                          electlayershape,fSSDKaptonFlexMedium);
5905  electlayer->SetLineColor(fColorKapton);
5906  // JMD Connector Female
5907  const Int_t kjmdconnectorvertexnumber = 6;
5908  Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5909  Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5910  xjmdconnectorvertex[0] = 0.0;
5911  xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5912  xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5913  xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5914  xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5915  xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5916
5917  yjmdconnectorvertex[0] = 0.0;
5918  yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5919  yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5920  yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5921  yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5922  yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5923  TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5924  jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5925                                                                   yjmdconnectorvertex);
5926  jmdconnectorshape->DefineSection(0,0.0);
5927  jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
5928  TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
5929                                                                                    jmdconnectorshape,fSSDMountingBlockMedium);
5930  jmdconnector->SetLineColor(fColorG10);
5931  // Top Cable Connector
5932  const Int_t kcableconnectorvertexnumber = 8;
5933  Double_t xconnectorvertex[kcableconnectorvertexnumber];
5934  Double_t yconnectorvertex[kcableconnectorvertexnumber];
5935  xconnectorvertex[0] = 0.0;
5936  xconnectorvertex[1] = xconnectorvertex[0];
5937  xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
5938  xconnectorvertex[3] = xconnectorvertex[2];
5939  xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
5940                                          - fgkEndCapCardCableConnectorLength[2];
5941  xconnectorvertex[5] = xconnectorvertex[4];
5942  xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
5943  xconnectorvertex[7] = xconnectorvertex[6];
5944
5945  yconnectorvertex[0] = 0.0;
5946  yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
5947  yconnectorvertex[2] = yconnectorvertex[1];
5948  yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
5949  yconnectorvertex[4] = yconnectorvertex[3];
5950  yconnectorvertex[5] = yconnectorvertex[1];
5951  yconnectorvertex[6] = yconnectorvertex[5];
5952  yconnectorvertex[7] = yconnectorvertex[0];
5953  TGeoXtru* cableconnectorshape = new TGeoXtru(2);
5954  cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
5955                                                                     yconnectorvertex);
5956  cableconnectorshape->DefineSection(0,0.0);
5957  cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
5958  TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
5959                                                                                    cableconnectorshape,fSSDMountingBlockMedium);
5960  cableconnector->SetLineColor(fColorG10);
5961  // Strip Connection
5962  TGeoBBox* endcapstripconnectionshape =
5963                                                                 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
5964                                                                                          0.5*fgkEndCapStripConnectionThickness,
5965                                                                                          0.5*fgkEndCapStripConnectionWidth);
5966  TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
5967                                                                                                         endcapstripconnectionshape,
5968                                                                                                         fSSDSupportRingAl);
5969  endcapstripconnection->SetLineColor(fColorAl);
5970  // Interface Card B
5971  const Int_t kcardBvertexnumber = 12;
5972  Double_t xcardBvertexnumber[kcardBvertexnumber];
5973  Double_t ycardBvertexnumber[kcardBvertexnumber];
5974
5975  xcardBvertexnumber[0]  = 0.0;
5976  xcardBvertexnumber[1]  = xcardBvertexnumber[0];
5977  xcardBvertexnumber[2]  = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
5978  xcardBvertexnumber[3]  = xcardBvertexnumber[2];
5979  xcardBvertexnumber[4]  = xcardBvertexnumber[1];
5980  xcardBvertexnumber[5]  = xcardBvertexnumber[4];
5981  xcardBvertexnumber[6]  = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
5982  xcardBvertexnumber[7]  = xcardBvertexnumber[6];
5983  xcardBvertexnumber[8]  = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
5984  xcardBvertexnumber[9]  = xcardBvertexnumber[8];
5985  xcardBvertexnumber[10] = xcardBvertexnumber[7];
5986  xcardBvertexnumber[11] = xcardBvertexnumber[10];
5987
5988  ycardBvertexnumber[0]  = 0.0;
5989  ycardBvertexnumber[1]  = fgkEndCapInterfaceCardBWidth[0];
5990  ycardBvertexnumber[2]  = ycardBvertexnumber[1];
5991  ycardBvertexnumber[3]  = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
5992  ycardBvertexnumber[4]  = ycardBvertexnumber[3];
5993  ycardBvertexnumber[5]  = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
5994  ycardBvertexnumber[6]  = ycardBvertexnumber[5];
5995  ycardBvertexnumber[7]  = ycardBvertexnumber[4];
5996  ycardBvertexnumber[8]  = ycardBvertexnumber[7];
5997  ycardBvertexnumber[9]  = ycardBvertexnumber[1];
5998  ycardBvertexnumber[10] = ycardBvertexnumber[9];
5999  ycardBvertexnumber[11] = ycardBvertexnumber[0];
6000
6001  TGeoXtru* interfacecardBshape = new TGeoXtru(2);
6002  interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
6003  interfacecardBshape->DefineSection(0,0.);
6004  interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
6005  TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
6006                                                                                          fSSDMountingBlockMedium);
6007  interfacecardB->SetLineColor(46);
6008  // Interface Card B Electronic Board
6009  const Int_t kelectboardcardBvertexnumber = 14;
6010  Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
6011  Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
6012
6013  xelectboardcardBvertex[0]  = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
6014  xelectboardcardBvertex[1]  = xelectboardcardBvertex[0];
6015  xelectboardcardBvertex[2]  = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
6016  xelectboardcardBvertex[3]  = xelectboardcardBvertex[2];
6017  xelectboardcardBvertex[4]  = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
6018  xelectboardcardBvertex[5]  = xelectboardcardBvertex[4];
6019  xelectboardcardBvertex[6]  = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
6020  xelectboardcardBvertex[7]  = xelectboardcardBvertex[6];
6021  xelectboardcardBvertex[8]  = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
6022  xelectboardcardBvertex[9]  = xelectboardcardBvertex[8];
6023  xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
6024  xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
6025  xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
6026  xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
6027
6028  yelectboardcardBvertex[0]  = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
6029  yelectboardcardBvertex[1]  = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
6030  yelectboardcardBvertex[2]  = yelectboardcardBvertex[1];
6031  yelectboardcardBvertex[3]  = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
6032  yelectboardcardBvertex[4]  = yelectboardcardBvertex[3];
6033  yelectboardcardBvertex[5]  = yelectboardcardBvertex[2];
6034  yelectboardcardBvertex[6]  = yelectboardcardBvertex[5];
6035  yelectboardcardBvertex[7]  = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
6036  yelectboardcardBvertex[8]  = yelectboardcardBvertex[7];
6037  yelectboardcardBvertex[9]  = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
6038  yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
6039  yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
6040  yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
6041  yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
6042
6043  TGeoXtru* electboardcardBshape = new TGeoXtru(2);
6044  electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
6045                                                                          xelectboardcardBvertex,yelectboardcardBvertex);
6046  electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
6047  electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
6048                                                                          + fgkEndCapInterfaceElectBoardCardBThickness);
6049  TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
6050                                                                                           fSSDSupportRingAl);
6051  electboardcardB->SetLineColor(fColorAl);
6052  // Generating Stiffener 2
6053  TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
6054                                                                                            0.5*fgkEndCapStiffenerThickness,
6055                                                                                            0.5*fgkEndCapStiffenerLength);
6056  TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
6057  endcapstiffener->SetLineColor(fColorAl);
6058  // Generating Mother Interface Card B Container
6059  const Int_t kinterfacecardBmothervertexnumber = 10;
6060  Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6061  Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6062
6063  xinterfacecardBmothervertex[0] = 0.0;
6064  xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
6065  xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
6066                                                                 + fgkEndCapInterfaceCardBThickness;
6067  xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
6068  xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
6069                                                                 + fgkEndCapInterfaceElectBoardCardBThickness;
6070  xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
6071  xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
6072  xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
6073  xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
6074                                                                 + fgkEndCapCardJMDConnectorLength[0];
6075  xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
6076
6077  yinterfacecardBmothervertex[0] = 0.0;
6078  yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
6079                                                                 + fgkEndCapInterfaceCardBWidth[1]
6080                                                                 + fgkEndCapInterfaceCardBWidth[2];
6081  yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
6082  yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
6083  yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
6084  yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
6085  yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
6086  yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
6087                                                                 + fgkEndCapCardJMDConnectorWidth[0]
6088                                                                 + fgkEndCapCardJMDConnectorWidth[1];
6089  yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
6090  yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
6091  TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
6092  interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
6093                                                                                   xinterfacecardBmothervertex,
6094                                                                                   yinterfacecardBmothervertex);
6095  interfacecardBmothershape->DefineSection(0,-1.e-15);
6096  interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
6097  TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
6098                                                                                                    interfacecardBmothershape,fSSDAir);
6099  electboardcardB->SetLineColor(fColorAl);
6100  // Positioning Volumes Mother Interface Card B Container
6101  TGeoRotation* interfacecardBrot = new TGeoRotation();
6102  TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
6103  interfacecardBrot->SetAngles(90.,-90.,-90.);
6104  interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
6105  TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
6106  TGeoRotation* electboardcardBrot = new TGeoRotation();
6107  TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
6108  electboardcardBrot->SetAngles(90.,90.,-90.);
6109  electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
6110  TGeoCombiTrans* electboardcardBcombitrans =
6111                                   new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6112  interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6113  interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6114  TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6115  jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6116  TGeoTranslation* jmdconnectorcardBtrans[3];
6117  TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6118  for(Int_t i=0; i<3; i++){
6119    jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6120                                                          + fgkEndCapCardJMDConnectorLength[0],
6121                                                            fgkEndCapCardElectBoardLayerWidth[1],
6122                                                            0.5*fgkEndCapCardJMDConnectorThickness
6123                                                          + 0.5*(fgkEndCapInterfaceCardBLength[1]
6124                                                          - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6125                                                          + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6126    jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6127                                                                                                            *jmdconnectorcardBrot);
6128    interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6129  }
6130  // Mother Supply Card Container
6131  TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6132  // Interface Card Container
6133  TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6134  // Placing Volumes in Mother Supply Card Container
6135  // JMD Connector Positioning
6136  TGeoTranslation* jmdconnectortrans[2];
6137  for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6138  jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6139                                                                                         fgkEndCapCardElectBoardBackLength[0]
6140                                           -                                             fgkEndCapCardJMDConnectorThickness
6141                                           -                                             fgkEndCapCardJMDConnectorToLayer);
6142  TGeoRotation* jmdconnectorot = new TGeoRotation();
6143  jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6144                                                                  + 2.*fgkEndCapCardJMDConnectorLength[0]
6145                                                                  + 2.*fgkEndCapCardElectBoardLayerThickness,
6146                                                                           fgkEndCapCardElectBoardLayerWidth[1],
6147                                                                       fgkEndCapCardJMDConnectorThickness
6148                                                                  +    fgkEndCapCardJMDConnectorToLayer);
6149  jmdconnectorot->SetAngles(90.,180.,-90);
6150  TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6151                                                                                 * jmdconnectorot);
6152  mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6153  mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6154  // Top Cable Connector Placing
6155  TGeoRotation* cableconnectorot[2];
6156  for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6157  TGeoTranslation* cableconnectortrans[3];
6158  for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6159  cableconnectorot[0]->SetAngles(90.,0.,0.);
6160  cableconnectorot[1]->SetAngles(0.,-90.,0.);
6161  cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6162  TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6163                                                                                                                            *cableconnectorot[0]);
6164  TGeoHMatrix* cableconnectormatrix[2];
6165  for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6166                                                         new TGeoHMatrix((*cableconnectorot[1])
6167                                                                                    *(*cableconnectorcombitrans));
6168  cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6169                                            -                               fgkEndCapCardCableConnectorThickness,
6170                                                                                 fgkEndCapCardCableConnectorLength[0]
6171                                            +                            fgkEndCapCardCableConnectorToLayer);
6172  cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6173                                            -                2.*fgkEndCapCardCableConnectorThickness
6174                                            -                            fgkEndCapCardCableConnectorDistance,
6175                                                                                 fgkEndCapCardCableConnectorLength[0]
6176                                            +                            fgkEndCapCardCableConnectorToLayer);
6177  for(Int_t i=0; i<2; i++){
6178         cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6179     mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6180  }
6181  TGeoRotation* electboardbackrot = new TGeoRotation();
6182  TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6183  electboardbackrot->SetAngles(90.,-90.,-90.);
6184  electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6185                                                         +                fgkEndCapCardJMDConnectorLength[0]
6186                                                         +                fgkEndCapCardElectBoardLayerThickness,0.,0.);
6187  TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6188                                                                                                                            *electboardbackrot);
6189  mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6190  // Electronic Board Kapton Layer Positioning
6191  TGeoRotation* electlayerrot = new TGeoRotation();
6192  TGeoTranslation* electlayertrans[2];
6193  TGeoCombiTrans* electlayercombitrans[2];
6194  for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6195  electlayerrot->SetAngles(90.,-90.,-90.);
6196  electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6197                                                                  + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6198  electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6199                                                                  + 2.*fgkEndCapCardElectBoardLayerThickness
6200                                                                  + fgkEndCapCardElectBoardBackThickness,0.,0.);
6201  for(Int_t i=0; i<2; i++){
6202         electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6203         mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6204  }
6205  // Placing Volumes in Mother Interface Card Container
6206  motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6207  motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6208  for(Int_t i=0; i<2; i++){
6209         motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6210  }
6211  /////////////////////////////////////////////////////////////
6212  // Generation of Card Interface Container
6213  /////////////////////////////////////////////////////////////
6214  Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6215                                                   - fgkEndCapCardJMDConnectorLength[0]
6216                                                   - fgkEndCapInterfaceCardBThickness
6217                                                   - 9.*fgkEndCapStripConnectionThickness
6218                                                   - 8.*fgkEndCapCardElectBoardBackThickness;
6219  const Int_t kcardinterfacecontainervertexnumber = 14;
6220  Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6221  Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6222  xcardinterfacecontainervertex[0]  =-6.5*fgkEndCapCardElectBoardBackThickness
6223                                                                    - 7.0*fgkEndCapStripConnectionThickness;
6224  xcardinterfacecontainervertex[1]  = xcardinterfacecontainervertex[0];
6225  xcardinterfacecontainervertex[2]  = xcardinterfacecontainervertex[1]
6226                                                                    + fgkEndCapStripConnectionThickness
6227                                                                    - fgkEndCapCardElectBoardLayerThickness
6228                                                                    - fgkEndCapCardCableConnectorWidth[0];
6229  xcardinterfacecontainervertex[3]  = xcardinterfacecontainervertex[2];
6230  xcardinterfacecontainervertex[4]  = xcardinterfacecontainervertex[1];
6231  xcardinterfacecontainervertex[5]  = xcardinterfacecontainervertex[4];
6232  xcardinterfacecontainervertex[6]  = 1.5*fgkEndCapCardElectBoardBackThickness
6233                                                                    + 2.0*fgkEndCapStripConnectionThickness;
6234  xcardinterfacecontainervertex[7]  = xcardinterfacecontainervertex[6];
6235  xcardinterfacecontainervertex[8]  = xcardinterfacecontainervertex[7]
6236                                                                    + fgkEndCapInterfaceCardBThickness;
6237  xcardinterfacecontainervertex[9]  = xcardinterfacecontainervertex[8];
6238  xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6239                                                                    + fgkEndCapInterfaceElectBoardCardBThickness;
6240  xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6241  xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6242                                    - fgkEndCapInterfaceElectBoardCardBThickness
6243                                                                    + fgkEndCapCardJMDConnectorLength[0]
6244                                                                    + stiffenertransx+fgkEndCapStiffenerWidth;
6245  xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6246
6247  ycardinterfacecontainervertex[0]  = 0.;
6248  ycardinterfacecontainervertex[1]  = fgkEndCapCardElectBoardLayerWidth[1]
6249                                                                    + fgkEndCapCardJMDConnectorWidth[0]
6250                                                                    + fgkEndCapCardJMDConnectorWidth[1];
6251  ycardinterfacecontainervertex[2]  = ycardinterfacecontainervertex[1];
6252  ycardinterfacecontainervertex[3]  = fgkEndCapCardElectBoardBackWidth[0]
6253                                                                    - fgkEndCapStripConnectionWidth;
6254  ycardinterfacecontainervertex[4]  = ycardinterfacecontainervertex[3];
6255  ycardinterfacecontainervertex[5]  = fgkEndCapCardElectBoardBackWidth[0];
6256  ycardinterfacecontainervertex[6]  = ycardinterfacecontainervertex[5];
6257  ycardinterfacecontainervertex[7]  = fgkEndCapInterfaceCardBWidth[0]
6258                                                                    + fgkEndCapInterfaceCardBWidth[1]
6259                                                                    + fgkEndCapInterfaceCardBWidth[2];
6260  ycardinterfacecontainervertex[8]  = ycardinterfacecontainervertex[7];
6261  ycardinterfacecontainervertex[9]  = yelectboardcardBvertex[3];
6262  ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6263  ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6264  ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6265  ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6266
6267  TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6268  interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6269                                                                                   xcardinterfacecontainervertex,
6270                                                                                   ycardinterfacecontainervertex);
6271  interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6272                                                                            -    fgkEndCapCardElectBoardBackLength[0]));
6273  interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6274                                                                            +    fgkEndCapCardElectBoardBackLength[0]));
6275  TGeoVolume** cardinterfacecontainer;
6276  cardinterfacecontainer = new TGeoVolume*[4];
6277  cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6278                                                                                         interfacecardmothershape,fSSDAir);
6279  cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6280                                                                                         interfacecardmothershape,fSSDAir);
6281  cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6282                                                                                         interfacecardmothershape,fSSDAir);
6283  cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6284                                                                                         interfacecardmothershape,fSSDAir);
6285  /////////////////////////////////
6286  // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6287  // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6288  // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6289  // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6290  /////////////////////////////////
6291  TGeoRotation* endcapstripconnectionrot[2];
6292  for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6293  endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6294  endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6295  TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6296                                                                         *                                 (*endcapstripconnectionrot[0]));
6297  TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6298  endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6299                                                                                         -0.5*fgkEndCapCardElectBoardBackThickness,
6300                                                                                          fgkEndCapCardElectBoardBackWidth[0]
6301                                                                                         -endcapstripconnectionshape->GetDZ(),
6302                                                                                          0.5*fgkEndCapCardElectBoardBackLength[0]);
6303  endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6304  TGeoTranslation* cardinterfacetrans[9];
6305  TGeoHMatrix* cardinterfacematrix[9];
6306  for(Int_t i=0; i<7; i++){
6307         cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6308                                                   +                                                     fgkEndCapCardElectBoardBackThickness),
6309                                                                                                 0.0,0.0);
6310         cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6311                                                    *                             (*endcapstripconnectionmatrix));
6312  }
6313  cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6314                                                   +                                             fgkEndCapCardElectBoardBackThickness),
6315                                                                                                 0.0,0.0);
6316  cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6317                                                 *                                 (*endcapstripconnectionmatrix));
6318  cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6319                                                   +                                             fgkEndCapCardElectBoardBackThickness),
6320                                                                                                 0.0,0.0);
6321  cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6322                                                 *                                 (*endcapstripconnectionmatrix));
6323
6324  for(Int_t i=0; i<4; i++){
6325         cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6326                                                                            cardinterfacematrix[7]);
6327         cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6328                                                                            cardinterfacematrix[8]);
6329  }
6330  TGeoTranslation* mothersupplycardtrans =
6331                                         new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6332                                                                                 + 2.*fgkEndCapCardJMDConnectorLength[0]
6333                                                                                 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6334  TGeoHMatrix* mothersupplycardmatrix[7];
6335  Int_t index[4] = {1,1,1,1};
6336  for(Int_t i=0; i<7; i++){
6337         mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6338                                                         *                                 (*mothersupplycardtrans));
6339         for(Int_t j=0; j<4; j++){
6340                 switch(j){
6341                         case 0: //Layer5 EndCap Left Side
6342                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6343                                                                                                    cardinterfacematrix[i]);
6344                                 if(i!=0){
6345                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6346                                                                                                            mothersupplycardmatrix[i]);
6347                                         index[j]++;
6348
6349                                 }
6350                         break;
6351                         case 1: //Layer5 EndCap Rigth Side
6352                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6353                                                                                                    cardinterfacematrix[i]);
6354                                 if(i>0&&i<6){
6355                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6356                                                                                                            mothersupplycardmatrix[i]);
6357                                         index[j]++;
6358                                 }
6359                         break;
6360                         case 2: //Layer6 EndCap Left Side
6361                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6362                                                                                                    cardinterfacematrix[i]);
6363                                 if(i!=6){
6364                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6365                                                                                                            mothersupplycardmatrix[i]);
6366                                         index[j]++;
6367                                 }
6368                         break;
6369                         case 3: //Layer6 EndCap Right Side
6370                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6371                                                                                                    cardinterfacematrix[i]);
6372                                 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6373                                                                                                    mothersupplycardmatrix[i]);
6374                                 index[j]++;
6375                         break;
6376                 }
6377         }
6378  }
6379  // Positioning Interface
6380  TGeoTranslation* motherinterfacecardtrans =
6381                 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6382                                                          +0.5*fgkEndCapCardElectBoardBackThickness
6383                                                          -fgkEndCapCardElectBoardLayerThickness
6384                                                          +fgkEndCapStripConnectionThickness,0.,0.);
6385  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6386                                         motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6387  // Positioning Interface Card B
6388  TGeoTranslation* interfacecardBmothertrans =
6389                                         new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6390                                                                                 + 2.*fgkEndCapStripConnectionThickness
6391                                                                                         + fgkEndCapCardElectBoardBackThickness,0.,
6392                                                                            -0.5 * (fgkEndCapInterfaceCardBLength[1]
6393                                                                                         -  fgkEndCapCardElectBoardBackLength[0]));
6394  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6395                                                                                                                          interfacecardBmothertrans);
6396  // Positioning Stiffener
6397  TGeoTranslation* endcapstiffenertrans =
6398                                                 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6399                                                                            +    2.0*fgkEndCapStripConnectionThickness
6400                                                                            +    fgkEndCapInterfaceCardBThickness
6401                                                                            +    fgkEndCapCardJMDConnectorLength[0]
6402                                                                            +    stiffenertransx
6403                                                                            +    endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6404                                                                                         endcapstiffenershape->GetDZ()
6405                                                                            -    0.5*(fgkEndCapStiffenerLength
6406                                                                            -    fgkEndCapCardElectBoardBackLength[0]));
6407  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6408  /////////////////////////////////////////////////////////////
6409  // Deallocating memory
6410  /////////////////////////////////////////////////////////////
6411  delete interfacecardBrot;
6412  delete interfacecardBtrans;
6413  delete electboardcardBtrans;
6414  delete electboardcardBrot;
6415  delete jmdconnectorcardBrot;
6416  for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6417  delete jmdconnectorot;
6418  delete jmdconnectortrans[1];
6419  for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6420  delete cableconnectorcombitrans;
6421  delete electboardbacktrans;
6422  delete electboardbackrot;
6423  delete electlayerrot;
6424  for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6425  for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6426  delete mothersupplycardtrans;
6427  for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6428  /////////////////////////////////////////////////////////////
6429  return cardinterfacecontainer;
6430  }
6431  ////////////////////////////////////////////////////////////////////////////////
6432  TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6433   /////////////////////////////////////////////////////////////
6434   // Method returning EndCap Mother Volume
6435   /////////////////////////////////////////////////////////////
6436   const Int_t kendcapcoverplatesmallholenumber = 9;
6437   Double_t endcapmotherorigin[3];
6438   endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6439                                                 +  0.5 *(fgkEndCapCoverPlateLength[3]
6440                                             +  2.0 * fgkEndCapCoverPlateLength[2]);
6441   endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6442                                           -                      fgkEndCapCoverPlateWidth[2]
6443                                           -       (kendcapcoverplatesmallholenumber-1)
6444                                           *        fgkEndCapCoverPlateSmallHoleSeparation[2])
6445                                           +  0.5*(fgkEndCapSideCoverLength[2]
6446                                           +               fgkEndCapCoverPlateWidth[1]
6447                                           -       fgkEndCapCoverPlateWidth[0])
6448                                           -      (fgkEndCapCoverPlateWidth[1]
6449                                           -       fgkEndCapCoverPlateWidth[0]);
6450   endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6451                                                 + 2.*fgkEndCapCoolingTubeRadiusMax
6452                                                 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6453                                                 +      fgkEndCapSideCoverWidth[1]
6454                                                 +      fgkEndCapSideCoverThickness
6455                                                 +      fgkEndCapKaptonFoilThickness);
6456   TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6457                                                           +                              2.0* fgkEndCapCoverPlateLength[2]
6458                                                           +              2.0* fgkEndCapSideCoverThickness),
6459                                                                          0.5* (fgkEndCapSideCoverLength[2]
6460                                                           +                    fgkEndCapCoverPlateWidth[1]
6461                                                           -                                        fgkEndCapCoverPlateWidth[0]),
6462                                                                                          0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6463                                                       +                                    fgkEndCapSideCoverWidth[1]
6464                                                           +                                       fgkEndCapSideCoverThickness
6465                                                       +                                   fgkEndCapKaptonFoilThickness),
6466                                                                                          endcapmotherorigin);
6467   TGeoVolume** endcapassembly;
6468   endcapassembly = new TGeoVolume*[4];
6469   endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6470                                                                                         endcapmothershape,fSSDAir);
6471   endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6472                                                                                         endcapmothershape,fSSDAir);
6473   endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6474                                                                                         endcapmothershape,fSSDAir);
6475   endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6476                                                                                         endcapmothershape,fSSDAir);
6477  /////////////////////////////////
6478  // endcapassembly[0]:  Container End Cap Layer 5 Bellegarde Side
6479  // endcapassembly[1]:  Container End Cap Layer 5 Gex Side
6480  // endcapassembly[2]:  Container End Cap Layer 6 Bellegarde Side
6481  // endcapassembly[3]:  Container End Cap Layer 6 Gex Side
6482  /////////////////////////////////
6483   /////////////////////////////////////////////////////
6484   // Placing Endcap Cover Plate
6485   /////////////////////////////////////////////////////
6486   TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6487   TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6488   endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6489   TGeoCombiTrans* endcapcoverplatecombitrans =
6490                                                   new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6491                                                                                          endcapcoverplaterot);
6492   TGeoTranslation* endcapcoverplatetrans =
6493                                                   new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6494   TGeoHMatrix* endcapcoverplatematrix =
6495                                                   new TGeoHMatrix((*endcapcoverplatetrans)
6496                                                                           *       (*endcapcoverplatecombitrans));
6497   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6498   /////////////////////////////////////////////////////
6499   // Placing Endcap Side Cover
6500   /////////////////////////////////////////////////////
6501   TGeoVolume* endcapsidecover = GetEndCapSideCover();
6502   TGeoRotation* endcapsidecoverot[2];
6503   TGeoCombiTrans* endcapsidecovercombitrans[3];
6504   for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6505   endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6506   endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6507                                                                                         - 0.5*(fgkEndCapCoverPlateWidth[0]
6508                                                                                         - fgkEndCapCoverPlateWidth[2]
6509                                                                                     - (kendcapcoverplatesmallholenumber-1)
6510                                                                                         * fgkEndCapCoverPlateSmallHoleSeparation[2])
6511                                                                                         + 0.*fgkEndCapCoverPlateWidth[0]
6512                                                                                         + fgkEndCapSideCoverLength[2],
6513                                                                                           0.5*(fgkEndCapSideCoverThickness
6514                                                                                         + fgkEndCapCoverPlateThickness)
6515                                                                                         - 0.5*fgkEndCapCoverPlateThickness,
6516                                                                                           endcapsidecoverot[0]);
6517   endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6518   endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6519                                                                                                         0.5*fgkEndCapCoverPlateThickness
6520                                                                                                         -fgkEndCapSideCoverWidth[1],
6521                                                                                                         endcapsidecoverot[1]);
6522   endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6523                                                                                                         +fgkEndCapCoverPlateLength[3]
6524                                                                                                         +2.*fgkEndCapCoverPlateLength[2]
6525                                                                                                         +fgkEndCapSideCoverThickness,0.0,
6526                                                                                                         0.5*fgkEndCapCoverPlateThickness
6527                                                                                                         -fgkEndCapSideCoverWidth[1],
6528                                                                                                         endcapsidecoverot[1]);
6529   TGeoHMatrix* endcapsidecovermatrix[2];
6530   for(Int_t i=0; i<2; i++){
6531    endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6532                                                         *                                 (*endcapsidecovercombitrans[0]));
6533         for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6534                                                                                                                 endcapsidecovermatrix[i]);
6535   }
6536   /////////////////////////////////////////////////////
6537   // Placing Endcap Cooling Tube
6538   /////////////////////////////////////////////////////
6539   TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6540   TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6541   endcapcoolingtuberot->SetAngles(0.,180.,0.);
6542   TGeoCombiTrans* endcapccolingtubecombitrans
6543                                                 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6544                                                 + fgkEndCapCoolingTubeAxialRadius[1])
6545                                                 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6546                                                 - fgkEndCapCoolingTubeToCoverSide,
6547                                                   fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6548                                                 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6549   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6550                                                                                                           endcapccolingtubecombitrans);
6551   /////////////////////////////////////////////////////
6552   // Placing Screws
6553   /////////////////////////////////////////////////////
6554   Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6555                                                                            fgkEndCapCoverPlateScrewRadiusMin};
6556   Int_t screwcoverplatedgesnumber[2] = {20,20};
6557   Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6558                                                                                 fgkEndCapCoverPlateThickness
6559                                                                          +  fgkEndCapCoolingTubeRadiusMax};
6560   TGeoXtru* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
6561                                                                                                  screwcoverplatedgesnumber,
6562                                                                                                  screwcoverplatesection);
6563   TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6564                                                                                            screwcoverplateshape,
6565                                                                                            fSSDCoolingTubePhynox);
6566   screwcoverplate->SetLineColor(12);
6567   Double_t transx[4] = {0,
6568                                                 fgkEndCapCoverPlateSmallHoleSeparation[0],
6569                                                 fgkEndCapCoverPlateSmallHoleSeparation[0]
6570                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1],
6571                                          2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6572                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1]};
6573   const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6574 //  TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6575   TGeoTranslation*** endcapcoverplatescrewtrans;
6576   endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6577   Int_t index = 0;
6578   for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6579         endcapcoverplatescrewtrans[i] =
6580                                         new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6581     for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6582                 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6583         if(index==1||index==9||index==28||index==36){
6584                         endcapcoverplatescrewtrans[i][j] =
6585                                 new TGeoTranslation(transx[i],
6586                                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6587                                                                         fgkEndCapSideCoverThickness);
6588                 }
6589                 else{
6590                         endcapcoverplatescrewtrans[i][j] =
6591                                 new TGeoTranslation(transx[i],
6592                                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6593                                                                         0.);
6594                 }
6595             if(index!=19)
6596                 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6597                                                                                           endcapcoverplatescrewtrans[i][j]);
6598         }
6599   }
6600   /////////////////////////////////////////////////////
6601   // Placing Cover Plate Clips
6602   /////////////////////////////////////////////////////
6603   TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6604                                                                                                          0.5*fgkEndCapCoverPlateClipWidth,
6605                                                                                                          0.5*fgkEndCapSideCoverThickness);
6606   TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6607                                                                                                         endcapcoverplateclipshape,
6608                                                                                                         fSSDCoolingTubePhynox);
6609   TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6610                                                                                                          0.5*fgkEndCapCoverPlateDownClipWidth,
6611                                                                                                          0.5*fgkEndCapSideCoverThickness);
6612   TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6613                                                                                                         endcapcoverplatedownclipshape,
6614                                                                                                         fSSDCoolingTubePhynox);
6615   TGeoTranslation* endcapcoverplatecliptrans[4];
6616   endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6617                                                            -                     fgkEndCapCoverPlateLength[0]
6618                                                            -                     fgkEndCapSideCoverThickness,
6619                                                                                                          0.0,
6620                                                                                                  0.5*(fgkEndCapSideCoverThickness
6621                                                            +                                              fgkEndCapCoverPlateThickness));
6622   endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6623                                                            -                     fgkEndCapCoverPlateLength[0]
6624                                                            -                     fgkEndCapSideCoverThickness,
6625                                                                                                          (kendcapcoverplatescrewnumber[1]-1)
6626                                                            *                                     fgkEndCapSideCoverWidth[5],
6627                                                                                                  0.5*(fgkEndCapSideCoverThickness
6628                                                            +                                              fgkEndCapCoverPlateThickness));
6629   endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6630                                                            -                     fgkEndCapCoverPlateLength[0]
6631                                                            +                                     fgkEndCapCoverPlateLength[1]
6632                                                            +                              2.*fgkEndCapCoverPlateLength[0]
6633                                                            -                                     fgkEndCapCoverPlateClipLength
6634                                                            +                                 fgkEndCapSideCoverThickness,
6635                                                                                                          0.0,
6636                                                                                                  0.5*(fgkEndCapSideCoverThickness
6637                                                            +                                              fgkEndCapCoverPlateThickness));
6638   endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6639                                                            -                     fgkEndCapCoverPlateLength[0]
6640                                                            +                                     fgkEndCapCoverPlateLength[1]
6641                                                            +                              2.*fgkEndCapCoverPlateLength[0]
6642                                                            -                                     fgkEndCapCoverPlateClipLength
6643                                                            +                                 fgkEndCapSideCoverThickness,
6644                                                                                                          (kendcapcoverplatescrewnumber[1]-1)
6645                                                            *                                     fgkEndCapSideCoverWidth[5],
6646                                                                                                  0.5*(fgkEndCapSideCoverThickness
6647                                                            +                                              fgkEndCapCoverPlateThickness));
6648   endcapcoverplateclip->SetLineColor(fColorPhynox);
6649   endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6650   for(Int_t i=0; i<4; i++)
6651         for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6652                                                                                                    endcapcoverplatecliptrans[i]);
6653   TGeoTranslation* endcapcoverplatedowncliptrans[4];
6654   endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6655                                                                    -                     fgkEndCapCoverPlateLength[0]
6656                                                                    -                     fgkEndCapSideCoverThickness,
6657                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6658                                                                    -                                 fgkEndCapCoverPlateClipWidth),
6659                                                                                                         0.5*(fgkEndCapSideCoverThickness
6660                                                                +                                         fgkEndCapCoverPlateThickness)
6661                                                                    -                     fgkEndCapSideCoverWidth[1]
6662                                                                    -                                     fgkEndCapSideCoverThickness);
6663   endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6664                                                                    -                     fgkEndCapCoverPlateLength[0]
6665                                                                    -                     fgkEndCapSideCoverThickness,
6666                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6667                                                                    -                                 fgkEndCapCoverPlateClipWidth)
6668                                                                    +                            fgkEndCapSideCoverLength[2]
6669                                                                    -                            fgkEndCapCoverPlateDownClipWidth,
6670                                                                                                         0.5*(fgkEndCapSideCoverThickness
6671                                                                +                                         fgkEndCapCoverPlateThickness)
6672                                                                    -                     fgkEndCapSideCoverWidth[1]
6673                                                                    -                                     fgkEndCapSideCoverThickness);
6674   endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6675                                                                    -                     fgkEndCapCoverPlateLength[0]
6676                                                                    +                     fgkEndCapSideCoverThickness
6677                                                                    +                     fgkEndCapCoverPlateLength[1]
6678                                                                    +                 2.0*fgkEndCapCoverPlateLength[0]
6679                                                                    -                     fgkEndCapCoverPlateDownClipLength,
6680                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6681                                                                    -                                 fgkEndCapCoverPlateClipWidth),
6682                                                                                                         0.5*(fgkEndCapSideCoverThickness
6683                                                                +                                         fgkEndCapCoverPlateThickness)
6684                                                                    -                     fgkEndCapSideCoverWidth[1]
6685                                                                    -                                     fgkEndCapSideCoverThickness);
6686   endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6687                                                                    -                     fgkEndCapCoverPlateLength[0]
6688                                                                    +                     fgkEndCapSideCoverThickness
6689                                                                    +                     fgkEndCapCoverPlateLength[1]
6690                                                                    +                 2.0*fgkEndCapCoverPlateLength[0]
6691                                                                    -                     fgkEndCapCoverPlateDownClipLength,
6692                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6693                                                                    -                                 fgkEndCapCoverPlateClipWidth)
6694                                                                    +                                 fgkEndCapSideCoverLength[2]
6695                                                                    -                                 fgkEndCapCoverPlateDownClipWidth,
6696                                                                                                         0.5*(fgkEndCapSideCoverThickness
6697                                                                +                                         fgkEndCapCoverPlateThickness)
6698                                                                    -                     fgkEndCapSideCoverWidth[1]
6699                                                                    -                                     fgkEndCapSideCoverThickness);
6700   for(Int_t i=0; i<4; i++)
6701         for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6702                                                                                                    endcapcoverplatedowncliptrans[i]);
6703   /////////////////////////////////////////////////////
6704   // Placing Kapton Foil
6705   /////////////////////////////////////////////////////
6706   TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6707                                                                                                  0.5*fgkEndCapKaptonFoilWidth,
6708                                                                                                  0.5*fgkEndCapKaptonFoilThickness);
6709   TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6710                                                                                                 endcapkaptonfoilshape,
6711                                                                                                 fSSDKaptonFlexMedium);
6712   endcapkaptonfoil->SetLineColor(8);
6713   TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6714                                                                                                                            0.5*fgkEndCapKaptonFoilWidth
6715                                                                                  -                     0.5*fgkEndCapCoverPlateClipWidth,
6716                                                                                                                            0.5*fgkEndCapCoverPlateThickness
6717                                                                                  -                     0.5*fgkEndCapKaptonFoilThickness
6718                                                                              -                     fgkEndCapSideCoverWidth[1]
6719                                                                                  -                     fgkEndCapSideCoverThickness);
6720   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6721   /////////////////////////////////////////////////////////////
6722   // Placing Electronic Tubes
6723   /////////////////////////////////////////////////////////////
6724   Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6725                                                                              - fgkEndCapInterfaceCardBThickness
6726                                                                              - 9.*fgkEndCapStripConnectionThickness
6727                                                                              - 8.*fgkEndCapCardElectBoardBackThickness,
6728                                                                                fgkEndCapKaptonFoilWidth
6729                                                                              - fgkEndCapInterfaceCardBThickness
6730                                                                              - 9.*fgkEndCapStripConnectionThickness
6731                                                                              - 8.*fgkEndCapCardElectBoardBackThickness
6732                                                                                  - fgkEndCapInterfaceElectBoardCardBThickness};
6733   TGeoVolume* endcapeffectivecables[2];
6734   endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6735                                                                                          fgkEndCapEffectiveCableRadiusMax,
6736                                                                                          endcapeffectivecableswidth[0],
6737                                                                                          10,"EndCapEffectiveCables1");
6738   endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6739                                                                                          fgkEndCapEffectiveCableRadiusMax,
6740                                                                                          endcapeffectivecableswidth[1],
6741                                                                                          25,"EndCapEffectiveCables2");
6742   TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6743   TGeoTranslation* endcapeffectivecablestrans[2];
6744   endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6745                                           -                                                        0.5*endcapeffectivecableswidth[0]
6746                                           -                            0.5*(fgkEndCapCoverPlateWidth[0]
6747                                           -                                                               fgkEndCapCoverPlateWidth[2]
6748                                           -                                             (kendcapcoverplatesmallholenumber-1)
6749                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6750                                           +                                             fgkEndCapSideCoverLength[2],
6751                                           -                     0.5*fgkEndCapCoverPlateThickness
6752                                           -                                             (fgkEndCapCardElectBoardBackWidth[0]
6753                                           -                                              fgkEndCapInterfaceCardBWidth[0]
6754                                           -                                              fgkEndCapInterfaceCardBWidth[1]));
6755   endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6756                                           -                                                        0.5*endcapeffectivecableswidth[1]
6757                                           -                            0.5*(fgkEndCapCoverPlateWidth[0]
6758                                           -                                                               fgkEndCapCoverPlateWidth[2]
6759                                           -                                             (kendcapcoverplatesmallholenumber-1)
6760                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6761                                           +                                         fgkEndCapSideCoverLength[2],
6762                                           -                     0.5*fgkEndCapCoverPlateThickness
6763                                           -                                             (fgkEndCapCardElectBoardBackWidth[0]
6764                                           -                                              fgkEndCapInterfaceCardBWidth[0])
6765                                           -                     0.5*fgkEndCapInterfaceCardBWidth[2]);
6766   endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6767   TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6768   endcapeffectivecablescombitrans[0]  = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6769                                                                                                                    *endcapeffectivecablesrot);
6770   endcapeffectivecablescombitrans[1]  = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6771                                                                                                                    *endcapeffectivecablesrot);
6772   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6773                                                                                                           endcapeffectivecablescombitrans[0]);
6774   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6775                                                                                                           endcapeffectivecablescombitrans[1]);
6776   /////////////////////////////////////////////////////////////
6777   // Placing End Cap Cards
6778   /////////////////////////////////////////////////////////////
6779   TGeoVolume** endcapcards = GetEndCapCards();
6780   TGeoRotation* endcapcardsrot[2];
6781   for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6782   endcapcardsrot[0]->SetAngles(90.,0.,0.);
6783   TGeoTranslation* endcapcardstrans[2];
6784   endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6785                                                                                         -  fgkEndCapCardElectBoardBackLength[0]));
6786   TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6787   endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6788   TGeoHMatrix* endcapcardsmatrix[2];
6789   endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6790   Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6791                                                   - fgkEndCapCardJMDConnectorLength[0]
6792                                                   - fgkEndCapInterfaceCardBThickness
6793                                                   - 9.*fgkEndCapStripConnectionThickness
6794                                                   - 8.*fgkEndCapCardElectBoardBackThickness;
6795   endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6796                                           -                                             fgkEndCapCoverPlateLength[0]
6797                                           + 0.5 *              (fgkEndCapCoverPlateLength[3]
6798                                           + 2.0 *                               fgkEndCapCoverPlateLength[2]),
6799                                           -                                                     stiffenertransx-fgkEndCapStiffenerWidth
6800                                           -                                                               fgkEndCapCardJMDConnectorLength[0]
6801                                           -                                                               fgkEndCapInterfaceCardBThickness
6802                                           -     2.0 *                                             fgkEndCapStripConnectionThickness
6803                                           - 1.5 *                                             fgkEndCapInterfaceCardBThickness
6804                                           - 0.5 *                                                (fgkEndCapCoverPlateWidth[0]
6805                                           -                                                               fgkEndCapCoverPlateWidth[2]
6806                                           -                                             (kendcapcoverplatesmallholenumber-1)
6807                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6808                                           +                     fgkEndCapKaptonFoilWidth,
6809                                                                                           0.5*fgkEndCapCoverPlateThickness
6810                                           -                                                     fgkEndCapSideCoverWidth[1]);
6811   endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6812   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6813    /////////////////////////////////////////////////////////////
6814   // Deallocating memory
6815   /////////////////////////////////////////////////////////////
6816   delete endcapcoverplaterot;
6817   delete endcapcoverplatecombitrans;
6818   delete endcapcoverplatetrans;
6819   for(Int_t i=0; i<3; i++){
6820    delete endcapsidecovercombitrans[i];
6821    if(i<2) delete endcapsidecoverot[i];
6822   }
6823   for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6824   for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6825   delete endcapcardsmatrix[0];
6826   return endcapassembly;
6827  }
6828  ////////////////////////////////////////////////////////////////////////////////
6829  TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6830                                                                                                                         Double_t radiusmax,
6831                                                                                                                         Double_t width,
6832                                                                                                                         Int_t ncables,
6833                                                                                                                         char* volname){
6834   /////////////////////////////////////////////////////////////
6835   // Generating EndCap High Voltage Tubes
6836   /////////////////////////////////////////////////////////////
6837   Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
6838   Double_t effectiveouteradius = TMath::Sqrt(TMath::Power(effectiveinneradius,2.)
6839                                                            +             TMath::Power(radiusmax,2.)
6840                                -             TMath::Power(radiusmin,2.));
6841   TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6842   TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6843                                                                                                    effectiveouteradius,0.5*width);
6844   TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6845                                                                                                 effectiveinnertubeshape,
6846                                                                                                 fSSDStiffenerConnectorMedium);
6847   effectiveinnertube->SetLineColor(41);
6848   TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6849                                                                                                 effectiveoutertubeshape,
6850                                                                                                 fSSDKaptonChipCableMedium);
6851   effectiveoutertube->SetLineColor(39);
6852   TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6853   TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6854   effectivemothertube->AddNode(effectiveinnertube,1);
6855   effectivemothertube->AddNode(effectiveoutertube,1);
6856   return effectivemothertube;
6857  }
6858  ////////////////////////////////////////////////////////////////////////////////
6859  TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6860   /////////////////////////////////////////////////////////////
6861   // Generating EndCap Support Layer 5 and Layer 6
6862   /////////////////////////////////////////////////////////////
6863   const Int_t knedges = 5;
6864   ///////////////////////////////////////////////
6865   // Setting the vertices for TGeoXtru Up Volume
6866   ///////////////////////////////////////////////
6867   const Int_t klayernumber = 2;
6868   Double_t xupvertex[klayernumber][knedges+3];
6869   Double_t yupvertex[klayernumber][knedges+3];
6870   Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6871   Double_t middledgeangle[klayernumber] = {0.0,0.0};
6872   Double_t middlepsi[klayernumber] = {0.0,0.0};
6873   for(Int_t i=0; i<klayernumber; i++){
6874         xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6875         xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6876         xupvertex[i][2] = -xupvertex[i][1];
6877         xupvertex[i][3] = -xupvertex[i][0];
6878
6879         yupvertex[i][0] =  fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6880         yupvertex[i][1] =  0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6881         yupvertex[i][2] =  yupvertex[i][1];
6882         yupvertex[i][3] =  yupvertex[i][0];
6883
6884     middledgeangle[i] = upedgeangle[i]/knedges;
6885     middlepsi[i] = 90.0-0.5*upedgeangle[i];
6886     for(Int_t j=1; j<knedges; j++){
6887                 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6888                 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6889         }
6890   }
6891   ////////////////////////////////////
6892   // Generating Up TGeoXtru
6893   ////////////////////////////////////
6894   TGeoXtru* upendcapsupportshape[klayernumber];
6895   TGeoVolume* upendcapsupport[klayernumber];
6896   char upendcapsupportname[30];
6897   for(Int_t i=0; i<klayernumber; i++){
6898    upendcapsupportshape[i] = new TGeoXtru(2);
6899    sprintf(upendcapsupportname,"UpEndCapSupportPieceLayer%i",i+5);
6900    upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6901    upendcapsupportshape[i]->DefineSection(0,0.);
6902    upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6903    upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
6904                                                                         fSSDSupportRingAl);
6905    upendcapsupport[i]->SetLineColor(5);
6906   }
6907   ///////////////////////////////////////////////
6908   // Setting the vertices for TGeoXtru Down Volume
6909   ///////////////////////////////////////////////
6910   Double_t xdownvertex[klayernumber][2*(knedges+1)];
6911   Double_t ydownvertex[klayernumber][2*(knedges+1)];
6912   for(Int_t i=0; i<klayernumber; i++){
6913         xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6914         xdownvertex[i][1] =  xupvertex[i][0];
6915         ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6916         ydownvertex[i][1] =  yupvertex[i][0];
6917         for(Int_t j=0; j<knedges; j++){
6918                 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6919                 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6920         }
6921         for(Int_t j=0; j<knedges; j++){
6922                 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6923                                                                         * CosD(middlepsi[i]+j*middledgeangle[i]);
6924                 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6925                                                                         * SinD(middlepsi[i]+j*middledgeangle[i]);
6926         }
6927   }
6928   ////////////////////////////////////
6929   // Generating Down TGeoXtru
6930   ////////////////////////////////////
6931   TGeoXtru* downendcapsupportshape[klayernumber];
6932   TGeoVolume* downendcapsupport[klayernumber];
6933   char downendcapsupportname[30];
6934   for(Int_t i=0; i<klayernumber; i++){
6935         downendcapsupportshape[i] = new TGeoXtru(2);
6936     sprintf(downendcapsupportname,"DownEndCapSupportPieceLayer%i",i+5);
6937         downendcapsupportshape[i] = new TGeoXtru(2);
6938         downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
6939     if(i==0){
6940                 downendcapsupportshape[i]->DefineSection(0,0.);
6941                 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
6942     }
6943         else{
6944                 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
6945                                                                  -                 fgkEndCapSupportLowWidth[i]);
6946                 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6947         }
6948     downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
6949                                                                 downendcapsupportshape[i],fSSDSupportRingAl);
6950         downendcapsupport[i]->SetLineColor(5);
6951   }
6952   ///////////////////////////////////////////////
6953   // Setting TGeoPgon Volume
6954   ///////////////////////////////////////////////
6955   const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6956                                                                                                    fgkSSDLay6LadderNumber};
6957   TGeoPgon* endcapsupportmothershape[klayernumber];
6958   TGeoVolume** endcapsupportmother;
6959   endcapsupportmother = new TGeoVolume*[klayernumber];
6960   char endcapsupportmothername[30];
6961   for(Int_t i=0; i<klayernumber; i++){
6962         endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6963     sprintf(endcapsupportmothername,"EndCapSupportMotherLayer%i",i+5);
6964         endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
6965     endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
6966                                                                                           ydownvertex[i][0],yupvertex[i][1]);
6967     endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
6968                                                                                         fSSDAir);
6969   }
6970   ////////////////////////////////////
6971   TGeoRotation** endcapsupportrot[klayernumber];
6972   for(Int_t i=0; i<2; i++){
6973         endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
6974         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6975            endcapsupportrot[i][j] = new TGeoRotation();
6976            endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
6977        endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
6978        endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
6979         }
6980   }
6981   return endcapsupportmother;
6982  }
6983  ////////////////////////////////////////////////////////////////////////////////
6984  void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
6985   /////////////////////////////////////////////////////////////
6986   // Setting End Cap Support Layer 5 and 6.
6987   /////////////////////////////////////////////////////////////
6988   const Int_t kendcapcoverplatesmallholenumber = 9;
6989   const Int_t klayernumber = 2;
6990   const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6991                                                                                                    fgkSSDLay6LadderNumber};
6992   Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
6993                                                                                 360.0/kssdlayladdernumber[1]};
6994   TGeoVolume** endcapsupport = EndCapSupport();
6995   TGeoVolume** endcapassembly = GetEndCapAssembly();
6996   TGeoPgon* endcapsupportshape[klayernumber];
6997   Double_t* radiusmin[klayernumber];
6998   Double_t* radiusmax[klayernumber];
6999   for(Int_t i=0; i<klayernumber; i++){
7000     endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
7001         radiusmin[i] = endcapsupportshape[i]->GetRmin();
7002         radiusmax[i] = endcapsupportshape[i]->GetRmax();
7003   }
7004   TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
7005   Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
7006                                                                           endcapassemblyshape->GetDY(),
7007                                                                           endcapassemblyshape->GetDZ()};
7008   ///////////////////////////////////////////////
7009   // Setting TGeoPgon Volume for Mother Container
7010   ///////////////////////////////////////////////
7011   TGeoPgon* endcapsupportsystemshape[klayernumber];
7012   char endcapsupportsystemothername[30];
7013   for(Int_t i=0; i<klayernumber; i++){
7014         endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
7015     sprintf(endcapsupportsystemothername,"EndCapSupportSystemLayer%i",i+5);
7016         endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
7017                                                                                              - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
7018                                                                                           (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7019                                                                                            +2.*endcapassemblycenter[2])
7020                                                                                            /CosD(0.5*upedgeangle[i]));
7021     endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
7022                                                                                                  -(fgkEndCapCoverPlateWidth[1]
7023                                                                                              - fgkEndCapCoverPlateWidth[0]),
7024                                                                                            *radiusmin[i],
7025                                                                                           (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7026                                                                                            +2.*endcapassemblycenter[2])
7027                                                                                            /CosD(0.5*upedgeangle[i]));
7028   }
7029   fgkEndCapSupportSystem = new TGeoVolume*[4];
7030   fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
7031                                                                           endcapsupportsystemshape[0],fSSDAir);
7032   fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
7033                                                                           endcapsupportsystemshape[0],fSSDAir);
7034   fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
7035                                                                           endcapsupportsystemshape[1],fSSDAir);
7036   fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
7037                                                                           endcapsupportsystemshape[1],fSSDAir);
7038   ///////////////////////////////////////////////
7039   TGeoTranslation* endcapassemblytrans[klayernumber];
7040   for(Int_t i=0; i<klayernumber; i++)
7041         endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
7042                                                                            -  fgkEndCapSideCoverThickness
7043                                                                            +  endcapassemblycenter[0],
7044                                                                            -  0.5*fgkEndCapCoverPlateThickness
7045                                                                            -  2.0*fgkEndCapCoolingTubeRadiusMax
7046                                                                            +  2.0*endcapassemblycenter[2]
7047                                                                            +  0.5*fgkEndCapSupportLength[i]
7048                                                                            /  TanD(0.5*upedgeangle[i]),
7049                                                                                   0.5*(fgkEndCapCoverPlateWidth[0]
7050                                                                            -  fgkEndCapCoverPlateWidth[2]
7051                                                                            - (kendcapcoverplatesmallholenumber-1)
7052                                                                            *  fgkEndCapCoverPlateSmallHoleSeparation[2]));
7053   TGeoRotation** endcapassemblyrot[klayernumber];
7054   TGeoHMatrix** endcapassemblymatrix[klayernumber];
7055   for(Int_t i=0; i<klayernumber; i++){
7056    endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
7057    endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
7058    for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
7059    endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
7060    endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
7061    endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
7062    endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
7063    for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
7064         endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
7065         endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
7066    }
7067   }
7068   TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
7069                                                         fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
7070   for(Int_t i=0; i<2*klayernumber; i++){
7071         for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
7072                 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
7073                                                                                                                                            endcapassemblymatrix[1][j+2]);
7074         }
7075         fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
7076   }
7077    /////////////////////////////////////////////////////////////
7078   // Deallocating memory
7079   /////////////////////////////////////////////////////////////
7080   for(Int_t i=0; i<klayernumber; i++){
7081         for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
7082                 delete endcapassemblyrot[i][j];
7083         }
7084         delete endcapassemblyrot[i];
7085         delete endcapassemblymatrix[i][0];
7086         delete endcapassemblymatrix[i][1];
7087   }
7088   /////////////////////////////////////////////////////////////
7089   }
7090   void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
7091   /////////////////////////////////////////////////////////////
7092   // Setting End Cap Support + End Cap Assembly of Layer 5.
7093   /////////////////////////////////////////////////////////////
7094   if (! moth) {
7095     printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer5, mother is null!\n");
7096     return;
7097   };
7098   if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
7099   TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7100   endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7101                                                                                                 fgkEndCapSupportCenterLay5ITSPosition
7102                                                                            +            fgkEndCapSupportCenterLay5Position
7103                                                                            -            fgkEndCapSideCoverLength[2]);
7104   endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7105                                                                                                 fgkEndCapSideCoverLength[2]
7106                                                                            -        fgkEndCapSupportCenterLay5Position
7107                                                                            -        fgkEndCapSupportCenterLay5ITSPosition);
7108   TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7109   endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7110   TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7111         new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7112   moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7113   moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7114    /////////////////////////////////////////////////////////////
7115   // Deallocating memory
7116   /////////////////////////////////////////////////////////////
7117   delete endcapsupportsystemrot;
7118   delete endcapsupportsystemITSCentertrans[1];
7119  }
7120   /////////////////////////////////////////////////////////////
7121   void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7122   /////////////////////////////////////////////////////////////
7123   // Setting End Cap Support + End Cap Assembly of Layer 6.
7124   /////////////////////////////////////////////////////////////
7125   if (! moth) {
7126     printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer6, mother is null!\n");
7127     return;
7128   };
7129   if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
7130   TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7131   endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7132                                                                                                 fgkEndCapSupportCenterLay6ITSPosition
7133                                                                            +            fgkEndCapSupportCenterLay6Position
7134                                                                            -            fgkEndCapSideCoverLength[2]);
7135   endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7136                                                                                                 fgkEndCapSideCoverLength[2]
7137                                                                            -        fgkEndCapSupportCenterLay6Position
7138                                                                            -        fgkEndCapSupportCenterLay6ITSPosition);
7139   TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7140   endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7141   TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7142         new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7143   moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7144   moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7145    /////////////////////////////////////////////////////////////
7146   // Deallocating memory
7147   /////////////////////////////////////////////////////////////
7148   delete endcapsupportsystemrot;
7149   delete endcapsupportsystemITSCentertrans[1];
7150  }
7151  ////////////////////////////////////////////////////////////////////////////////
7152  void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7153   /////////////////////////////////////////////////////////////
7154   // Setting Ladder Support of Layer 5.
7155   /////////////////////////////////////////////////////////////
7156   if (! moth) {
7157     printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer5, mother is null!\n");
7158     return;
7159   };
7160   if(!fLay5LadderSupportRing) SetLadderSupport(100);
7161   fMotherVol = moth;
7162   TGeoTranslation* centerITSRingSupportLay5trans[2];
7163   for(Int_t i=0; i<2; i++){
7164         centerITSRingSupportLay5trans[i] =
7165                 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7166     moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7167   }
7168  }
7169  ////////////////////////////////////////////////////////////////////////////////
7170  void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7171   /////////////////////////////////////////////////////////////
7172   // Setting Ladder Support of Layer 6.
7173   /////////////////////////////////////////////////////////////
7174   if (! moth) {
7175     printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer6, mother is null!\n");
7176     return;
7177   };
7178   if(!fLay6LadderSupportRing) SetLadderSupport(100);
7179   fMotherVol = moth;
7180   TGeoTranslation* centerITSRingSupportLay6trans[2];
7181   for(Int_t i=0; i<2; i++){
7182         centerITSRingSupportLay6trans[i] =
7183                 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7184     moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7185   }
7186  }
7187  ////////////////////////////////////////////////////////////////////////////////
7188 TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
7189                                                                         Double_t height, char* shapename, Int_t isign) const{
7190   /////////////////////////////////////////////////////////////
7191   // Method generating an Arb shape
7192   /////////////////////////////////////////////////////////////
7193   const Int_t kvertexnumber = 8;
7194   const Int_t ktransvectnumber = 2;
7195   TVector3* vertex[kvertexnumber];
7196   TVector3* transvector[2];
7197   for(Int_t i=0; i<ktransvectnumber; i++) transvector[i] = new TVector3(0.,width[i]);
7198   /////////////////////////////////////////////////////////////
7199   //Setting the vertices for TGeoArb8
7200   /////////////////////////////////////////////////////////////
7201   vertex[0] = new TVector3(*vertexpos[0]);
7202   vertex[1] = new TVector3(*vertexpos[1]);
7203   vertex[2] = new TVector3(*vertex[1]+isign*(*transvector[0]));
7204   vertex[3] = new TVector3(*vertex[0]+isign*(*transvector[0]));
7205   vertex[4] = new TVector3(*vertexpos[2]);
7206   vertex[5] = new TVector3(*vertexpos[3]);
7207   vertex[6] = new TVector3(*vertex[5]+isign*(*transvector[1]));
7208   vertex[7] = new TVector3(*vertex[4]+isign*(*transvector[1]));
7209   /////////////////////////////////////////////////////////////
7210   TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
7211   for(Int_t i = 0; i<kvertexnumber;i++)
7212                                                         arbshape->SetVertex(i,vertex[i]->X(),vertex[i]->Y());
7213   /////////////////////////////////////////////////////////////
7214   // Deallocating memory
7215   /////////////////////////////////////////////////////////////
7216   for(Int_t i=0; i< kvertexnumber; i++) delete vertex[i];
7217   for(Int_t i=0; i< ktransvectnumber; i++) delete transvector[i];
7218   /////////////////////////////////////////////////////////////
7219   return arbshape;
7220 }
7221 ///////////////////////////////////////////////////////////////////////////////
7222 TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
7223                                                                 Double_t rmax, Int_t nedges, Double_t height){
7224   /////////////////////////////////////////////////////////////
7225   // Method generating Arc shape
7226   /////////////////////////////////////////////////////////////
7227         const Int_t kvertexnumber = 2*nedges+2;
7228         TGeoXtru* arcshape = new TGeoXtru(2);
7229         TVector3** vertexposition[2];
7230         for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
7231         Double_t angle = 0.;
7232     for(Int_t i=0; i<nedges+1; i++){
7233                 angle = 90.+0.5*phi-i*(phi/nedges);
7234                 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
7235                 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
7236         }
7237         Double_t *xvertexpoints = new Double_t[kvertexnumber];
7238         Double_t *yvertexpoints = new Double_t[kvertexnumber];
7239         for(Int_t i=0; i<kvertexnumber; i++){
7240                 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
7241                                   yvertexpoints[i] = vertexposition[0][i]->Y();
7242                 }
7243                 else if(i>=1&&i<nedges+2)
7244                 {
7245                         xvertexpoints[i] = vertexposition[1][i-1]->X();
7246                         yvertexpoints[i] = vertexposition[1][i-1]->Y();
7247                 }
7248         else
7249                 {
7250                         xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
7251                         yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
7252                 }
7253     }
7254   arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
7255   arcshape->DefineSection(0,-0.5*height);
7256   arcshape->DefineSection(1,0.5*height);
7257   /////////////////////////////////////////////////////////////
7258   // Deallocating memory
7259   /////////////////////////////////////////////////////////////
7260   for(Int_t i=0; i<2; i++){
7261         for(Int_t j=0; j<nedges+1; j++)
7262                 delete vertexposition[i][j];
7263         delete [] vertexposition[i];
7264   }
7265   delete [] xvertexpoints;
7266   delete [] yvertexpoints;
7267   /////////////////////////////////////////////////////////////
7268         return arcshape;
7269 }
7270 ////////////////////////////////////////////////////////////////////////////////
7271 TGeoXtru* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
7272   ///////////////////////////////////////////////////////////////////////
7273   // Method Generating the Screw Shape
7274   // radius[0]: outer radius
7275   // radius[1]: inner radius
7276   // edgesnumber[0]: outer number of edges
7277   // edgesnumber[1]: inner number of edges
7278   // section[0]: lower section position
7279   // section[1]: higher section position
7280   ///////////////////////////////////////////////////////////////////////
7281   Double_t outradius = radius[0];
7282   Double_t inradius = radius[1];
7283   Int_t outvertexnumber = edgesnumber[0];
7284   Int_t invertexnumber = edgesnumber[1];
7285   Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
7286   Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
7287   for(Int_t i=0; i<outvertexnumber+1; i++){
7288         xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
7289         yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
7290   }
7291   for(Int_t i=0; i<invertexnumber+1; i++){
7292         xscrewvertex[outvertexnumber+i+1] = inradius*CosD(90.-i*360./invertexnumber);
7293         yscrewvertex[outvertexnumber+i+1] = inradius*SinD(90.-i*360./invertexnumber);
7294   }
7295   TGeoXtru* screwshape = new TGeoXtru(2);
7296   screwshape->DefinePolygon(outvertexnumber+invertexnumber+2,xscrewvertex,yscrewvertex);
7297   screwshape->DefineSection(0,section[0]);
7298   screwshape->DefineSection(1,section[1]);
7299   delete [] xscrewvertex;
7300   delete [] yscrewvertex;
7301   return screwshape;
7302 }
7303 ////////////////////////////////////////////////////////////////////////////////
7304 TGeoXtru* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
7305   ///////////////////////////////////////////////////////////////////////
7306   // Method Generating the Hole Shape
7307   // radius of the Hole
7308   // nedges: number of edges to approximate the circle
7309   ///////////////////////////////////////////////////////////////////////
7310   Int_t vertexnumber = nedges+6;
7311   Double_t* xholevertex = new Double_t[vertexnumber];
7312   Double_t* yholevertex = new Double_t[vertexnumber];
7313   xholevertex[0] = radius;
7314   xholevertex[1] = xholevertex[0];
7315   xholevertex[2] = -xholevertex[1];
7316   xholevertex[3] = xholevertex[2];
7317   xholevertex[4] = xholevertex[0];
7318   yholevertex[0] = 0.;
7319   yholevertex[1] = -radius;
7320   yholevertex[2] = yholevertex[1];
7321   yholevertex[3] = -yholevertex[1];
7322   yholevertex[4] = yholevertex[3];
7323   for(Int_t i=0; i<nedges+1; i++){
7324         xholevertex[i+5] = radius*CosD(i*360./nedges);
7325         yholevertex[i+5] = radius*SinD(i*360./nedges);
7326   }
7327   TGeoXtru* holeshape = new TGeoXtru(2);
7328   holeshape->DefinePolygon(vertexnumber,xholevertex,yholevertex);
7329   holeshape->DefineSection(0,section[0]);
7330   holeshape->DefineSection(1,section[1]);
7331   delete [] xholevertex;
7332   delete [] yholevertex;
7333   return holeshape;
7334 }
7335 ////////////////////////////////////////////////////////////////////////////////
7336 TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
7337   /////////////////////////////////////////////////////////////
7338   // Given an axis specified by param, it gives the reflection of the point
7339   // respect to the axis
7340   /////////////////////////////////////////////////////////////
7341   TVector3* n = new TVector3(param[0],param[1],param[2]);
7342   Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
7343   TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
7344   /////////////////////////////////////////////////////////////
7345   // Deallocating memory
7346   /////////////////////////////////////////////////////////////
7347   delete n;
7348   /////////////////////////////////////////////////////////////
7349   return reflectedvector;
7350 }
7351 ////////////////////////////////////////////////////////////////////////////////
7352 TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct,
7353                                                        Double_t dx,
7354                                                        Double_t dy,
7355                                                        Double_t dz) const{
7356   /////////////////////////////////////////////////////////////
7357   // Add a dx,dy,dz translation to the initial TGeoCombiTrans
7358   /////////////////////////////////////////////////////////////
7359   TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
7360   const Double_t *vect = hmatrix->GetTranslation();
7361   Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
7362   hmatrix->SetTranslation(newvect);
7363   TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
7364   delete hmatrix;
7365   return matrix;
7366 }
7367 ////////////////////////////////////////////////////////////////////////////////
7368 TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
7369   /////////////////////////////////////////////////////////////
7370   // Method returning the Medium type
7371   /////////////////////////////////////////////////////////////
7372   char ch[30];
7373   sprintf(ch, "ITS_%s",mediumName);
7374   TGeoMedium* medium =  gGeoManager->GetMedium(ch);
7375   if (! medium)
7376     printf("Error(AliITSv11GeometrySSD)::medium %s not found !\n", mediumName);
7377   return medium;
7378 }
7379 ////////////////////////////////////////////////////////////////////////////////
7380 void AliITSv11GeometrySSD::CreateMaterials(){
7381 ///////////////////////////////////
7382 // This part has to be modified
7383 ///////////////////////////////////
7384   ///////////////////////////////////
7385   // Silicon for Sensor
7386   ///////////////////////////////////
7387   fSSDSensorMedium = GetMedium("SI$");
7388   ///////////////////////////////////
7389   // Silicon Mixture for Sensor
7390   ///////////////////////////////////
7391   fSSDChipMedium = GetMedium("SPD SI CHIP$");
7392   fSSDChipGlueMedium = GetMedium("EPOXY$");
7393   ///////////////////////////////////
7394   // Stiffener Components Materials
7395   ///////////////////////////////////
7396   fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
7397   ///////////////////////////
7398   // Stiffener Connectors
7399   ///////////////////////////
7400   fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
7401   ////////////////////////////////
7402   // Stiffener 0603-1812 Capacitor
7403   ////////////////////////////////
7404   fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
7405   fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
7406   ///////////////////////////
7407   // Stiffener Hybrid Wire
7408   ///////////////////////////
7409   fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
7410   ///////////////////////////
7411   // Al for Cooling Block
7412   ///////////////////////////
7413   fSSDAlCoolBlockMedium = GetMedium("AL$");
7414   //////////////////////////////////////////////////////
7415   // Kapton and Al for Chip Cable Flex and Ladder Cables
7416   //////////////////////////////////////////////////////
7417   fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
7418   fSSDAlTraceChipCableMedium = GetMedium("AL$");
7419   fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
7420   fSSDAlTraceFlexMedium = GetMedium("AL$");
7421   fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
7422   fSSDAlTraceLadderCableMedium = GetMedium("AL$");
7423   /////////////////////////////////////////////////////////////////
7424   // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
7425   //////////////////////////////////////////////////////////////////
7426   fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
7427   /////////////////////////////////////////////////////////////////
7428   // G10 for Detector Leg, TubeHolder
7429   //////////////////////////////////////////////////////////////////
7430   fSSDTubeHolderMedium = GetMedium("G10FR4$");
7431   fSSDSensorSupportMedium = GetMedium("G10FR4$");
7432   fSSDMountingBlockMedium = GetMedium("G10FR4$");
7433   fSSDMountingBlockMedium = GetMedium("G10FR4$");
7434   /////////////////////////////////////////////////////////////////
7435   // Water and Phynox for Cooling Tube
7436   //////////////////////////////////////////////////////////////////
7437   fSSDCoolingTubeWater = GetMedium("WATER$");
7438   fSSDCoolingTubePhynox = GetMedium("INOX$");
7439   /////////////////////////////////////////////////////////////////////
7440   // Material for Support Rings
7441   /////////////////////////////////////////////////////////////////////
7442   fSSDSupportRingAl = GetMedium("AL$");
7443   /////////////////////////////////////////////////////////////////////
7444   fSSDAir = GetMedium("SDD AIR$");
7445   fCreateMaterials = kTRUE;
7446 }
7447 /////////////////////////////////////////////////////////////////////