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 "TGeoBoolNode.h"
  33 #include "TGeoTube.h"
  34 #include "TGeoBBox.h"
  35 #include "TGeoXtru.h"
  36 #include "TGeoTorus.h"
  37 #include "TGeoPgon.h"
  38 #include "TGeoPcon.h"
  39 #include "TRotation.h"
  40 #include "AliITSv11GeometrySSD.h"
  41
  42 /////////////////////////////////////////////////////////////////////////////////
  43 // Names of the Sensitive Volumes of Layer 5 and Layer 6
  44 /////////////////////////////////////////////////////////////////////////////////
  45 const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName5 = "ITSssdSensitivL5";
  46 const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName6 = "ITSssdSensitivL6";
  47 /////////////////////////////////////////////////////////////////////////////////
  48 //Parameters for SSD Geometry
  49 /////////////////////////////////////////////////////////////////////////////////
  50 // Variable for Vertical Disalignement of Modules
  51 /////////////////////////////////////////////////////////////////////////////////
  52 const Double_t AliITSv11GeometrySSD::fgkSSDTolerance = 0.0001*fgkmm;
  53 const Double_t AliITSv11GeometrySSD::fgkSSDModuleVerticalDisalignment = 0.2*fgkmm;
  54 const Double_t AliITSv11GeometrySSD::fgkSSDModuleSideDisalignment     = 0.2*fgkmm;
  55 // For ladders:
  56 const Double_t AliITSv11GeometrySSD::fgkSSDLadderVerticalDisalignment = 0.520*fgkmm;
  57 /////////////////////////////////////////////////////////////////////////////////
  58 // Layer5 (lengths are in mm and angles in degrees)
  59 /////////////////////////////////////////////////////////////////////////////////
  60 const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength      = 950.7*fgkmm;
  61 const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber        =  22;
  62 const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber         =  34;
  63 const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin         = 378.0*fgkmm;
  64 const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax         = 384.0*fgkmm;
  65 const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition    = 467.85*fgkmm;
  66 /////////////////////////////////////////////////////////////////////////////////
  67 // Layer6 (lengths are in mm and angles in degrees)
  68 /////////////////////////////////////////////////////////////////////////////////
  69 const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength      = 1068.0*fgkmm;
  70 const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber        =   25;
  71 const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber         =   38;
  72 const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin         =  428.0*fgkmm;
  73 const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax         =  434.0*fgkmm;
  74 const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition    = 526.50*fgkmm;
  75 /////////////////////////////////////////////////////////////////////////////////
  76 // SSD Chips and Hybrid (lengths are in mm and angles in degrees)
  77 /////////////////////////////////////////////////////////////////////////////////
  78 const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber               =   6;
  79 const Double_t AliITSv11GeometrySSD::fgkSSDChipLength            =  11.100*fgkmm;
  80 const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth             =   3.850*fgkmm;
  81 const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight            =   0.180*fgkmm;
  82 const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength  =   1.000*fgkmm;
  83 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength     = fgkSSDChipLength;
  84 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth      =  fgkSSDChipWidth;
  85 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight        =   0.030*fgkmm;
  86 /////////////////////////////////////////////////////////////////////////////////
  87 // Stiffener (lengths are in mm and angles in degrees)
  88 /////////////////////////////////////////////////////////////////////////////////
  89 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength       =  73.000*fgkmm;
  90 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth        =   6.500*fgkmm;
  91 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight       =   0.295*fgkmm;
  92 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist   =   2.500*fgkmm;
  93 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603CapLength  =  0.900*fgkmm;  // Includes solder
  94 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length   = 1.600*fgkmm;
  95 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width    =   0.870*fgkmm;
  96 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height   =   0.800*fgkmm;
  97 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812CapLength  =  0.215*fgkmm;
  98 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length   =   4.600*fgkmm;
  99 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width    =   3.400*fgkmm;
 100 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height   =   1.400*fgkmm;
 101 const Double_t AliITSv11GeometrySSD::fgkSSDWireLength            =  30.000*fgkmm;
 102 const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius            =   0.185*fgkmm;
 103 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2]  = {44.32*fgkmm, 0.33*fgkmm};
 104 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation   =        0.44*fgkmm;
 105 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength       =        2.16*fgkmm;
 106 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth        =        3.60*fgkmm;
 107 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight       =   0.25*fgkSSDStiffenerHeight;
 108 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight     =       0.030*fgkmm;
 109 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight     =   0.002*fgkmm;
 110 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSnHeight     =   0.15*fgkmm;
 111 /////////////////////////////////////////////////////////////////////////////////
 112 // Cooling Block (lengths are in mm and angles in degrees)
 113 /////////////////////////////////////////////////////////////////////////////////
 114 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength    =   3.000*fgkmm;
 115 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth     =   4.000*fgkmm;
 116 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
 117                                                                                  {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
 118 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
 119   {1.025*fgkmm, 0.120*fgkmm};  // Added 50 micron tolerance for thicker wall cooling pipe (March 2010)
 120 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
 121                                                                                                           {1.900*fgkmm, 0.400*fgkmm};
 122 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter    =
 123                                                                                                                                          1.500*fgkmm;
 124 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight    =
 125                                                                                                                                          0.300*fgkmm;
 126 /////////////////////////////////////////////////////////////////////////////////
 127 // SSD Sensor (lengths are in mm and angles in degrees)
 128 /////////////////////////////////////////////////////////////////////////////////
 129 const char*  AliITSv11GeometrySSD::fgkSSDSensitiveVolName       =
 130                                                                                                                  "SSDSensorSensitiveVol";
 131 const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength          =  42.000*fgkmm;
 132 const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight          =   0.300*fgkmm;
 133 const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth           =  75.000*fgkmm;
 134 const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap         =
 135                                                                                                    fgkSSDSensorLength-39.1*fgkmm;
 136 const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength    = 1.*fgkmm;
 137 const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth     = 1.*fgkmm;
 138 /////////////////////////////////////////////////////////////////////////////////
 139 // Flex (lengths are in mm and angles in degrees)
 140 /////////////////////////////////////////////////////////////////////////////////
 141 const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength       =  106.000*fgkmm;
 142 const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4]        =
 143                         {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
 144                                  + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
 145                          0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
 146                                  + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)
 147                                                                            - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm};
 148 const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2]         =
 149                                                                                                    {  9.340*fgkmm,  5.380*fgkmm};
 150 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2]        =
 151                                                                                                    {  0.030*fgkmm,  0.020*fgkmm};
 152 const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle            =   30.000;
 153 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength       =    1.430*fgkmm;
 154 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth        =    3.000*fgkmm;
 155 const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
 156                          {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
 157 const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
 158                                                                                    {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
 159 /////////////////////////////////////////////////////////////////////////////////
 160 // SSD Ladder Cable (lengths are in mm and angles in degrees)
 161 /////////////////////////////////////////////////////////////////////////////////
 162 const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth     =     23.5*fgkmm;
 163 const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableHeight[2] = {  0.030*fgkmm*17.5/23.5,  1.25 * 0.030*fgkmm};   // Al covers ~ 17.5/23.5 of surface, Kapton includes glue+foam
 164 /////////////////////////////////////////////////////////////////////////////////
 165 // SSD Module (lengths are in mm and angles in degrees)
 166 /////////////////////////////////////////////////////////////////////////////////
 167 const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2]  =
 168                                                                                                          { 1.000*fgkmm, 3.900*fgkmm};
 169 const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
 170                                                                                                                                         45.600*fgkmm;
 171 const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor  =
 172                                                                                                                                          5.075*fgkmm;
 173 /////////////////////////////////////////////////////////////////////////////////
 174 // Sensor Support (lengths are in mm and angles in degrees)
 175 /////////////////////////////////////////////////////////////////////////////////
 176 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength                     =
 177                                                                                                                                          5.800*fgkmm;
 178 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth          =
 179                                                                                                                                          2.000*fgkmm;
 180 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2]      =
 181                                                                                                      { 4.620*fgkmm-fgkSSDModuleVerticalDisalignment,
 182                                                                                                        5.220*fgkmm-fgkSSDModuleVerticalDisalignment};
 183 //const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2]      =
 184 //                                                                                                   { 4.520*fgkmm, 5.130*fgkmm};
 185 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2]   =
 186                                                                                                          { 0.450*fgkmm, 0.450*fgkmm};
 187 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition
 188                                                                 = 0.5 * (fgkSSDModuleSensorSupportDistance
 189                                                             +  fgkSSDSensorSideSupportThickness[0])
 190                                                                 -  fgkSSDSensorSideSupportLength;
 191 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength       =
 192                                                                                                                                     5.250*fgkmm;
 193 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth        =
 194                                                                                                                                         1.680*fgkmm;
 195 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]
 196                                                                   = {fgkSSDSensorSideSupportHeight[0]
 197                                                                   +  fgkSSDSensorSideSupportThickness[0],
 198                                                                          fgkSSDSensorSideSupportHeight[1]
 199                                                                   +  fgkSSDSensorSideSupportThickness[1]};
 200 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2]
 201                                                                   =  {fgkSSDSensorSideSupportThickness[0],
 202                                                                           fgkSSDSensorSideSupportThickness[1]};
 203 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition     =
 204                                                                                                                                    19.000*fgkmm;
 205 /////////////////////////////////////////////////////////////////////////////////
 206 // Chip Cables (lengths are in mm and angles in degrees)
 207 /////////////////////////////////////////////////////////////////////////////////
 208 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2]   =
 209                                   {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
 210 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4]   =
 211                                   {  0.014*fgkmm,  0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
 212                                                                   -  (fgkSSDSensorSideSupportHeight[1]
 213                                                                   -   fgkSSDSensorSideSupportHeight[0])
 214                                                                   -   fgkSSDModuleVerticalDisalignment
 215                                                                   -   fgkSSDCoolingBlockHoleCenter
 216                                                                   -   fgkSSDStiffenerHeight
 217                                                                   -   fgkSSDChipHeight-fgkSSDSensorHeight,
 218                                                                           fgkSSDModuleCoolingBlockToSensor
 219                                                                   -   fgkSSDModuleVerticalDisalignment
 220                                                                   -   fgkSSDCoolingBlockHoleCenter
 221                                                                   -       fgkSSDStiffenerHeight
 222                                                                   -   fgkSSDChipHeight-fgkSSDSensorHeight};
 223 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3]    =
 224                                             { 11.000*fgkmm,  0.800*fgkmm,  0.600*fgkmm};
 225 /////////////////////////////////////////////////////////////////////////////////
 226 // Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
 227 /////////////////////////////////////////////////////////////////////////////////
 228 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          =
 229                                                                                                                                         3.820*fgkmm;
 230 //const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          =
 231 //                                                                                                                                         3.780;
 232 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth           =
 233                                                                                  fgkSSDSensorLength-fgkSSDSensorOverlap;
 234 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2]         =
 235                                                                                                         {  0.86*fgkmm,  0.30*fgkmm};
 236 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2]        =
 237                                                                                                                                 { 30.00, 90.00};
 238 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
 239                                                                                                                                          1.78*fgkmm;
 240 /////////////////////////////////////////////////////////////////////////////////
 241 //Carbon Fiber Parameters (lengths are in mm and angles in degrees)
 242 /////////////////////////////////////////////////////////////////////////////////
 243 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength
 244                                                                    = fgkSSDModuleSensorSupportDistance
 245                                                                    - 2. * fgkCarbonFiberJunctionToSensorSupport;
 246 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
 247 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2]   =
 248                                                                                                   {  0.751*fgkmm,  0.482*fgkmm};
 249 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength  =
 250                                                                                                                                         1.630*fgkmm;
 251 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth =   0.950*fgkmm;
 252 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength
 253                                                                         = fgkCarbonFiberTriangleLength
 254                                                                         - 0.5*fgkCarbonFiberSupportTopEdgeDist[1]
 255                                                                         / TMath::Cos(fgkCarbonFiberTriangleAngle
 256                                                                         * TMath::DegToRad());
 257 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength
 258                                                                         = 0.5*(fgkCarbonFiberJunctionWidth
 259                                                                         - fgkCarbonFiberSupportWidth)
 260                                                                         - fgkCarbonFiberSupportTopEdgeDist[0]
 261                                                                         - fgkCarbonFiberSupportWidth;
 262 /////////////////////////////////////////////////////////////////////////////////
 263 // Carbon Fiber Lower Support Parameters (lengths are in mm)
 264 /////////////////////////////////////////////////////////////////////////////////
 265 const Double_t AliITSv11GeometrySSD::fgkLowerSupportToSensorZ           = 11.575*fgkmm;
 266 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
 267                                                                                                                                           =  0.950*fgkmm;
 268 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
 269                                                                                                                                           =  1.600*fgkmm;
 270 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
 271                                                                                                                                           =  0.830*fgkmm;
 272 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
 273                                                                                           = 0.5*fgkCarbonFiberSupportWidth;
 274 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
 275                                                                         = fgkCarbonFiberJunctionWidth
 276                                                                         - 2. * (fgkCarbonFiberLowerSupportWidth
 277                                                                         + fgkCarbonFiberLowerSupportVolumeSeparation);
 278 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
 279                                                                         = {fgkCarbonFiberLowerSupportWidth
 280                                                                         +  fgkCarbonFiberLowerSupportVolumeSeparation,
 281                                                                            fgkCarbonFiberLowerSupportWidth
 282                                                                         +  fgkCarbonFiberLowerSupportVolumeSeparation
 283                                                                         +  fgkCarbonFiberLowerSupportTransverseWidth};
 284 /////////////////////////////////////////////////////////////////////////////////
 285 // End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
 286 /////////////////////////////////////////////////////////////////////////////////
 287 const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
 288                                                            {0.5 * (fgkSSDLay5LadderLength
 289                                                                         -  fgkSSDLay5SensorsNumber
 290                                                                         *  fgkCarbonFiberJunctionWidth
 291                                                                         -  fgkCarbonFiberLowerSupportWidth),
 292                                                                 0.5 * (fgkSSDLay5LadderLength
 293                                                                         -  fgkSSDLay5SensorsNumber
 294                                                                         *  fgkCarbonFiberJunctionWidth
 295                                                                         +  fgkCarbonFiberLowerSupportWidth)};
 296 const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
 297                                                 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
 298                                                  fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
 299 const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
 300                                                 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
 301                                                  fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
 302 const Double_t AliITSv11GeometrySSD::fgkendladdercoolingsupportdistance[3] =
 303                                                                                         {15.0*fgkmm, 13.5*fgkmm, 14.5*fgkmm};
 304 /////////////////////////////////////////////////////////////////////////////////
 305 // Cooling Tube Support (lengths are in mm and angles in degrees)
 306 /////////////////////////////////////////////////////////////////////////////////
 307 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax      =  1.45*fgkmm;
 308 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
 309                                                                                           = fgkSSDCoolingBlockHoleRadius[0];
 310 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength    =  8.55*fgkmm;
 311 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight    =  0.85*fgkmm;
 312 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth     =  2.00*fgkmm;
 313 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation    =
 314                                         fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
 315 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber =
 316                                                                                                                                           11.70*fgkmm;
 317 /////////////////////////////////////////////////////////////////////////////////
 318 // Cooling Tube (lengths are in mm and angles in degrees)
 319 /////////////////////////////////////////////////////////////////////////////////
 320 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
 321 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin =  1.915*fgkmm/2; // Nominal + 50 micron tolerance; real pipes are closer to 450 micron wall thickness
 322 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
 323                                                                                                         fgkCarbonFiberJunctionWidth;
 324 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
 325                                                                          fgkSSDModuleSensorSupportDistance
 326                                                                   +      fgkSSDCoolingBlockLength;
 327 const Double_t AliITSv11GeometrySSD::fgkMountingBlockToSensorSupport = 30.7*fgkmm;
 328 /////////////////////////////////////////////////////////////////////////////////
 329 // SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
 330 /////////////////////////////////////////////////////////////////////////////////
 331 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3]            =
 332                                                                                    { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
 333 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4]            =
 334                                                            {  4.0*fgkmm,  8.0*fgkmm,  5.0*fgkmm,  0.2*fgkmm};
 335 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth                =
 336                                                                                                                                           20.0*fgkmm;
 337 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle   =
 338                                                                                                                                                     40.0;
 339 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight  =
 340                    0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
 341 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
 342                                                                                                                                           2.5*fgkmm;
 343 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2]    =
 344                                                                                                           { 56.0*fgkmm, 12.0*fgkmm};
 345 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2]     =
 346                                                                                                       {  5.0*fgkmm,  2.9*fgkmm};
 347 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius           =
 348                                                                                                                                           1.0*fgkmm;
 349 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge        =
 350                                                                                                                                           6.0*fgkmm;
 351 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeight      =
 352                                                                                                                                           4.0*fgkmm;
 353 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2]   =
 354                                                           {  1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
 355 /////////////////////////////////////////////////////////////////////////////////
 356 // SSD Mounting Block Clip Parameters (lengths are in mm and angles in degrees)
 357 /////////////////////////////////////////////////////////////////////////////////
 358 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipLength        = 15.1*fgkmm;
 359 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipThickness     = 0.3*fgkmm;
 360 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewRadius   = 1.6*fgkmm;
 361 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewPosition = 4.0*fgkmm;
 362 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibWidth         = 9.0*fgkmm;
 363 /////////////////////////////////////////////////////////////////////////////////
 364 // SSD Mounting Block Support Parameters (lengths are in mm and angles in degrees)
 365 /////////////////////////////////////////////////////////////////////////////////
 366 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportWidth[2] = {9.5*fgkmm,10.0*fgkmm};
 367 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportDownHeight   = 4.0*fgkmm;
 368 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDLay5RadiusMin
 369                                                                                                   -  fgkSSDMountingBlockHeight[1]
 370                                                                                                   +  0.5*fgkCoolingTubeSupportHeight
 371                                                                                                   +      fgkSSDModuleCoolingBlockToSensor
 372                                                                                                   -      fgkMountingBlockSupportDownHeight,
 373                                                                                                          fgkSSDLay6RadiusMin
 374                                                                                                   -  fgkSSDMountingBlockHeight[1]
 375                                                                                                   +  0.5*fgkCoolingTubeSupportHeight
 376                                                                                                   +      fgkSSDModuleCoolingBlockToSensor
 377                                                                                                   -      fgkMountingBlockSupportDownHeight};
 378 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax
 379                                                                                                     -  fgkSSDMountingBlockHeight[1]
 380                                                                                                     +  0.5*fgkCoolingTubeSupportHeight
 381                                                                                                     +  fgkSSDModuleCoolingBlockToSensor
 382                                                                                                         -  fgkMountingBlockSupportRadius[0],
 383                                                                                                            fgkSSDLay6RadiusMax
 384                                                                                                     -  fgkSSDMountingBlockHeight[1]
 385                                                                                                     +  0.5*fgkCoolingTubeSupportHeight
 386                                                                                                     +  fgkSSDModuleCoolingBlockToSensor
 387                                                                                                         -  fgkMountingBlockSupportRadius[1]};
 388 const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeight = 10.0*fgkmm; // To be verified
 389 const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
 390 const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
 391 /////////////////////////////////////////////////////////////////////////////////
 392 // SSD End Cap Cover Plate Parameters (lengths are in mm and angles in degrees)
 393 /////////////////////////////////////////////////////////////////////////////////
 394 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleRadius = 1.25*fgkmm;
 395 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateBigHoleRadius = 2.45*fgkmm;
 396 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateThickness = 0.5*fgkmm;
 397 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleSeparation[3] =
 398                                                                                                 {16.5*fgkmm,22.0*fgkmm,7.*fgkmm};
 399 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateLength[6] =
 400                                   {7.*fgkmm,55.*fgkmm,8.0*fgkmm,53.*fgkmm,61.0*fgkmm,25.5*fgkmm};
 401 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateWidth[3] =
 402                                                                                            {68.5*fgkmm,75.5*fgkmm,6.5*fgkmm};
 403 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMin = 0.750*fgkmm;
 404 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMax = 2.*fgkmm;
 405 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipLength = 10.4*fgkmm;
 406 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipWidth = 6.0*fgkmm;
 407 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipLength = 5.7*fgkmm;
 408 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipWidth = 5.0*fgkmm;
 409 /////////////////////////////////////////////////////////////////////////////////
 410 // SSD End Cap Kapton Foil Parameters (lengths are in mm and angles in degrees)
 411 /////////////////////////////////////////////////////////////////////////////////
 412 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilThickness = 0.4*fgkmm;
 413 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilLength = 68.0*fgkmm;
 414 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilWidth = 75.0*fgkmm;
 415 /////////////////////////////////////////////////////////////////////////////////
 416 // SSD End Cap Cooling Tube Parameters (lengths are in mm and angles in degrees)
 417 /////////////////////////////////////////////////////////////////////////////////
 418 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAxialRadius[2] =
 419                                                                                                                 {10.5*fgkmm,9.25*fgkmm};
 420 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMin = 1.3*fgkmm;
 421 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMax = 1.5*fgkmm;
 422 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAngle[5] =
 423                                                                                                         {182.3,177.9,84.4,70.0,35.0};
 424 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeLength[5] =
 425                                                                         {49.5*fgkmm,41.7*fgkmm,47.6*fgkmm,5.0*fgkmm};
 426 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeToCoverSide = 13.0*fgkmm;
 427 /////////////////////////////////////////////////////////////////////////////////
 428 // SSD End Cap Cover Side Parameters (lengths are in mm and angles in degrees)
 429 /////////////////////////////////////////////////////////////////////////////////
 430 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverLength[5] = {3.5*fgkmm,
 431                                                                           6.5*fgkmm,75.0*fgkmm,8.0*fgkmm,2.0*fgkmm};
 432 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverWidth[7] = {30.9*fgkmm,
 433                                                                           47.5*fgkmm,12.6*fgkmm,5.6*fgkmm,
 434                                                                           20.0*fgkmm,7.0*fgkmm,5.9*fgkmm};
 435 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm;
 436 /////////////////////////////////////////////////////////////////////////////////
 437 // SSD End Cap Cards Parameters (lengths are in mm and angles in degrees)
 438 /////////////////////////////////////////////////////////////////////////////////
 439 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] =
 440                                                                                                            {62.0*fgkmm,21.87*fgkmm};
 441 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] =
 442                                                                                                             {47.0*fgkmm,0.35*fgkmm};
 443 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness =
 444                                                                                                                                           1.0*fgkmm;
 445 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm;
 446 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerWidth[2] =
 447                                                                                                            {43.5*fgkmm, 0.70*fgkmm};
 448 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerThickness =
 449                                                                                                                                          0.15*fgkmm;
 450 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorThickness =
 451                                                                                                                                          19.0*fgkmm;
 452 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorLength[2] =
 453                                                                                                                  {4.80*fgkmm,1.1*fgkmm};
 454 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorWidth[2] =
 455                                                                                                                  {3.3*fgkmm,1.10*fgkmm};
 456 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorToLayer =
 457                                                                                                                                           2.1*fgkmm;
 458 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorLength[3] =
 459                                                                                                 {5.2*fgkmm,3.5*fgkmm,1.2*fgkmm};
 460 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorWidth[2] =
 461                                                                                                                  {1.9*fgkmm,0.15*fgkmm};
 462 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorThickness =
 463                                                                                                                                            19*fgkmm;
 464 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorDistance =
 465                                                                                                                                           1.0*fgkmm;
 466 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorToLayer =
 467                                                                                                                                           3.6*fgkmm;
 468 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionLength =
 469                                                                                                                                          61.0*fgkmm;
 470 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionThickness =
 471                                                                                                                                          5.97*fgkmm;
 472 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionWidth = 3.0*fgkmm;
 473 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBLength[7] =
 474                                                                                                 {3.1*fgkmm,68.0*fgkmm,3.6*fgkmm,
 475                                                                           1.9*fgkmm,2.5*fgkmm,14.2*fgkmm,1.5*fgkmm};
 476 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBWidth[5] =
 477                                                   {17.0*fgkmm,10.0*fgkmm,5.9*fgkmm,6.4*fgkmm,3.9*fgkmm};
 478 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBThickness =
 479                                                                                                                                           1.0*fgkmm;
 480 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceElectBoardCardBThickness
 481                                                                                                                                    = 0.15*fgkmm;
 482 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBJMDConnectorSeparation =
 483                                                                                                                                          20.0*fgkmm;
 484 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerLength = 68.0*fgkmm;
 485 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerWidth = 5.0*fgkmm;
 486 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerThickness = 5.0*fgkmm;
 487 const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMin = 1.25*fgkmm; // To Be Checked
 488 const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMax = 1.575*fgkmm; // To Be Checked
 489 /////////////////////////////////////////////////////////////////////////////////
 490 // SSD End Cap SupportLayer5/6 Side Parameters (lengths are in mm and angles in degrees)
 491 /////////////////////////////////////////////////////////////////////////////////
 492 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLength[2] = {70.424*fgkmm,72.919*fgkmm};
 493 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fgkmm,437.0*fgkmm};
 494 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {375.0*fgkmm,435.0*fgkmm};
 495 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm;
 496 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm};
 497 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 625.0*fgkmm;
 498 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
 499 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
 500 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
 501 /////////////////////////////////////////////////////////////////////////////////
 502 // SSD Cone Parameters (lengths are in mm and angles in degrees)
 503 /////////////////////////////////////////////////////////////////////////////////
 504 const Double_t AliITSv11GeometrySSD::fgkSSDLowerPConeRadius = 296.5*fgkmm;
 505 const Double_t AliITSv11GeometrySSD::fgkSSDPConeAngle = 39.0;
 506 const Double_t AliITSv11GeometrySSD::fgkSSDPConeZLength[2] = {168.0*fgkmm,153.0*fgkmm};
 507 const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleRadius = 317.5*fgkmm;
 508 const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleLength = 20.*fgkmm;
 509 const Double_t AliITSv11GeometrySSD::fgkSSDConeMiddleRadius = 350.*fgkmm;
 510 const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleLength = 30.*fgkmm;
 511 const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleWidth = 40.*fgkmm;
 512 const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpRadius = 400.*fgkmm;
 513 const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMaxRadius = 459.*fgkmm;
 514 const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMiddleRadius = 472.5*fgkmm;
 515 const Double_t AliITSv11GeometrySSD::fgkSSDPConeDownRadius = 282.0*fgkmm;
 516 const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidAngle = 42.0;
 517 const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidBasis = 200.0*fgkmm;
 518 const Double_t AliITSv11GeometrySSD::fgkSSDPConeExternalRadius = 492.5*fgkmm;
 519 const Double_t AliITSv11GeometrySSD::fgkSSDPConeRadiusWidth = 16.75*fgkmm;
 520 const Double_t AliITSv11GeometrySSD::fgkSSDPConeLength = 168.0*fgkmm;
 521 const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportLength = 1020.*fgkmm;
 522 const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportRadius = 297.5*fgkmm;
 523 const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportWidth = 6.28*fgkmm;
 524 const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportLength = 60.0*fgkmm;
 525 const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportWidth = 2.5*fgkSSDCentralSupportWidth;
 526 /////////////////////////////////////////////////////////////////////////////////
 527 // SSD Cables Parameters (lengths are in mm and angles in degrees)
 528 /////////////////////////////////////////////////////////////////////////////////
 529 const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5TubeRadiusMin = 11.9*fgkmm;
 530 const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6TubeRadiusMin = 11.9*fgkmm;
 531 const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideHeight = 7.*fgkmm;  // to be fixed in order to reproduce material budget
 532 const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6RightSideHeight = 7.*fgkmm;  // to be fixed in order to reproduce material budget
 533 const Double_t AliITSv11GeometrySSD::fgkSSDCableAngle = 22.5;
 534 const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideWaterHeight = 2.5*fgkmm;  // to be fixed in order to reproduce material budget
 535 const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB26Angle[2] = {25.0,53.2};
 536 const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB24Angle[2] = {23.0,53.6};
 537 const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26ITSDistance = 975.0*fgkmm;
 538 const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24ITSDistance = 1020.0*fgkmm;
 539 const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = 451.3*fgkmm;
 540 const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = 451.3*fgkmm;
 541 const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanelHeight = 87.5*fgkmm;
 542 const Double_t AliITSv11GeometrySSD::fgkSSDCableMaterialBudgetHeight = 20.0*fgkmm;
 543 //const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = fgkSSDPConeExternalRadius;
 544 //const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = fgkSSDPConeExternalRadius;
 545 /////////////////////////////////////////////////////////////////////////////////
 546 ClassImp(AliITSv11GeometrySSD)
 547 /////////////////////////////////////////////////////////////////////////////////
 548 AliITSv11GeometrySSD::AliITSv11GeometrySSD():
 549   AliITSv11Geometry(),
 550   fSSDChipMedium(),
 551   fSSDChipGlueMedium(),
 552   fSSDStiffenerMedium(),
 553   fSSDStiffenerConnectorMedium(),
 554   fSSDStiffener0603CapacitorMedium(),
 555   fSSDStiffener1812CapacitorMedium(),
 556   fSSDStiffenerCapacitorCapMedium(),
 557   fSSDStiffenerHybridWireMedium(),
 558   fSSDKaptonFlexMedium(),
 559   fSSDAlTraceFlexMedium(),
 560   fSSDAlTraceLadderCableMedium(),
 561   fSSDKaptonLadderCableMedium(),
 562   fSSDKaptonChipCableMedium(),
 563   fSSDAlTraceChipCableMedium(),
 564   fSSDAlCoolBlockMedium(),
 565   fSSDSensorMedium(),
 566   fSSDSensorSupportMedium(),
 567   fSSDCarbonFiberMedium(),
 568   fSSDTubeHolderMedium(),
 569   fSSDCoolingTubeWater(),
 570   fSSDCoolingTubePhynox(),
 571   fSSDSupportRingAl(),
 572   fSSDMountingBlockMedium(),
 573   fSSDRohaCellCone(),
 574   fSSDAir(),
 575   fSSDCopper(),
 576   fSSDSn(),
 577   fCreateMaterials(kFALSE),
 578   fTransformationMatrices(kFALSE),
 579   fBasicObjects(kFALSE),
 580   fcarbonfiberjunction(),
 581   fcoolingtubesupport(),
 582   fhybridmatrix(),
 583   fssdcoolingblocksystem(),
 584   fcoolingblocksystematrix(),
 585   fssdstiffenerflex(),
 586   fssdendflex(),
 587   fcoolingtube(0),
 588   fendladdercoolingtubesupportmatrix(),
 589   fendladdermountingblock(),
 590   fendladdermountingblockclip(),
 591   fSSDSensor5(),
 592   fSSDSensor6(),
 593   fSSDLayer5(),
 594   fSSDLayer6(),
 595   fMotherVol(),
 596   fLay5LadderSupportRing(),
 597   fLay6LadderSupportRing(),
 598   fgkEndCapSupportSystem(),
 599   fSSDCone(),
 600   fColorCarbonFiber(4),
 601   fColorRyton(5),
 602   fColorPhynox(14),
 603   fColorSilicon(3),
 604   fColorAl(38),
 605   fColorNiSn(40),
 606   fColorKapton(6),
 607   fColorPolyhamide(5),
 608   fColorStiffener(9),
 609   fColorEpoxy(30),
 610   fColorWater(7),
 611   fColorG10(41)
 612 {
 613   ////////////////////////
 614   // Standard constructor
 615   ////////////////////////
 616 }
 617 /////////////////////////////////////////////////////////////////////////////////
 618 AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
 619   AliITSv11Geometry(s.GetDebug()),
 620   fSSDChipMedium(s.fSSDChipMedium),
 621   fSSDChipGlueMedium(s.fSSDChipGlueMedium),
 622   fSSDStiffenerMedium(s.fSSDStiffenerMedium),
 623   fSSDStiffenerConnectorMedium(s.fSSDStiffenerConnectorMedium),
 624   fSSDStiffener0603CapacitorMedium(s.fSSDStiffener0603CapacitorMedium),
 625   fSSDStiffener1812CapacitorMedium(s.fSSDStiffener1812CapacitorMedium),
 626   fSSDStiffenerCapacitorCapMedium(s.fSSDStiffenerCapacitorCapMedium),
 627   fSSDStiffenerHybridWireMedium(s.fSSDStiffenerHybridWireMedium),
 628   fSSDKaptonFlexMedium(s.fSSDKaptonFlexMedium),
 629   fSSDAlTraceFlexMedium(s.fSSDAlTraceFlexMedium),
 630   fSSDAlTraceLadderCableMedium(s.fSSDAlTraceLadderCableMedium),
 631   fSSDKaptonLadderCableMedium(s.fSSDKaptonLadderCableMedium),
 632   fSSDKaptonChipCableMedium(s.fSSDKaptonChipCableMedium),
 633   fSSDAlTraceChipCableMedium(s.fSSDAlTraceChipCableMedium),
 634   fSSDAlCoolBlockMedium(s.fSSDAlCoolBlockMedium),
 635   fSSDSensorMedium(s.fSSDSensorMedium),
 636   fSSDSensorSupportMedium(s.fSSDSensorSupportMedium),
 637   fSSDCarbonFiberMedium(s.fSSDCarbonFiberMedium),
 638   fSSDTubeHolderMedium(s.fSSDTubeHolderMedium),
 639   fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
 640   fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
 641   fSSDSupportRingAl(s.fSSDSupportRingAl),
 642   fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
 643   fSSDRohaCellCone(s.fSSDRohaCellCone),
 644   fSSDAir(s.fSSDAir),
 645   fSSDCopper(s.fSSDCopper),
 646   fSSDSn(s.fSSDSn),
 647   fCreateMaterials(s.fCreateMaterials),
 648   fTransformationMatrices(s.fTransformationMatrices),
 649   fBasicObjects(s.fBasicObjects),
 650   fcarbonfiberjunction(s.fcarbonfiberjunction),
 651   fcoolingtubesupport(s.fcoolingtubesupport),
 652   fhybridmatrix(s.fhybridmatrix),
 653   fssdcoolingblocksystem(s.fssdcoolingblocksystem),
 654   fcoolingblocksystematrix(s.fcoolingblocksystematrix),
 655   fssdstiffenerflex(s.fssdstiffenerflex),
 656   fssdendflex(s.fssdendflex),
 657   fcoolingtube(s.fcoolingtube),
 658   fendladdercoolingtubesupportmatrix(s.fendladdercoolingtubesupportmatrix),
 659   fendladdermountingblock(s.fendladdermountingblock),
 660   fendladdermountingblockclip(s.fendladdermountingblockclip),
 661   fSSDSensor5(s.fSSDSensor5),
 662   fSSDSensor6(s.fSSDSensor6),
 663   fSSDLayer5(s.fSSDLayer5),
 664   fSSDLayer6(s.fSSDLayer6),
 665   fMotherVol(s.fMotherVol),
 666   fLay5LadderSupportRing(s.fLay5LadderSupportRing),
 667   fLay6LadderSupportRing(s.fLay6LadderSupportRing),
 668   fgkEndCapSupportSystem(s.fgkEndCapSupportSystem),
 669   fSSDCone(s.fSSDCone),
 670   fColorCarbonFiber(s.fColorCarbonFiber),
 671   fColorRyton(s.fColorRyton),
 672   fColorPhynox(s.fColorPhynox),
 673   fColorSilicon(s.fColorSilicon),
 674   fColorAl(s.fColorAl),
 675   fColorNiSn(s.fColorNiSn),
 676   fColorKapton(s.fColorKapton),
 677   fColorPolyhamide(s.fColorPolyhamide),
 678   fColorStiffener(s.fColorStiffener),
 679   fColorEpoxy(s.fColorEpoxy),
 680   fColorWater(s.fColorWater),
 681   fColorG10(s.fColorG10)
 682 {
 683   ////////////////////////
 684   // Copy Constructor
 685   ////////////////////////
 686 }
 687 /////////////////////////////////////////////////////////////////////////////////
 688 AliITSv11GeometrySSD& AliITSv11GeometrySSD::
 689 operator=(const AliITSv11GeometrySSD &s){
 690   ////////////////////////
 691   // Assignment operator
 692   ////////////////////////
 693   this->~AliITSv11GeometrySSD();
 694   new(this) AliITSv11GeometrySSD(s);
 695   return *this;
 696 /*
 697   if(&s == this) return *this;
 698   fMotherVol = s.fMotherVol;
 699   return *this;
 700  */
 701 }
 702 ///////////////////////////////////////////////////////////////////////////////
 703 void AliITSv11GeometrySSD::CreateTransformationMatrices(){
 704   ///////////////////////////////////////////////////////////////////////
 705   // Method generating the trasformation matrix for the whole SSD Geometry
 706   ///////////////////////////////////////////////////////////////////////
 707   // Setting some variables for Carbon Fiber Supportmatrix creation
 708   //////////////////////////////////////////////////////////////////////
 709   Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
 710                                                                                    * CosD(fgkCarbonFiberJunctionAngle[0]);
 711   Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
 712                                                                  +      fgkCarbonFiberSupportTopEdgeDist[0]
 713                                                                  +      fgkCarbonFiberSupportWidth);
 714   Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
 715                                                                         * TanD(fgkCarbonFiberJunctionAngle[0]);
 716   TGeoRotation* carbonfiberot[3];
 717   for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
 718   carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
 719   carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
 720   carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
 721   Double_t transvector[3] = {fgkCarbonFiberTriangleLength
 722                                                   *  CosD(fgkCarbonFiberTriangleAngle),0.,
 723                                                   -  fgkCarbonFiberTriangleLength
 724                                                   *      SinD(fgkCarbonFiberTriangleAngle)};
 725   ///////////////////////////////////////////
 726   //Setting Local Translations and Rotations:
 727   ///////////////////////////////////////////
 728   TGeoCombiTrans* localcarbonfibersupportmatrix[3];
 729   localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
 730                                                                          0.5*carbonfibersupportheight,NULL);
 731   localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
 732                                                                          2.*symmetryplaneposition+transvector[1],
 733                                                                          transvector[2], carbonfiberot[2]);
 734   localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
 735   /////////////////////////////////////////////////////////////
 736   // Carbon Fiber Support Transformations
 737   /////////////////////////////////////////////////////////////
 738   const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
 739   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
 740                 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
 741                 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
 742                         fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
 743   }
 744   /////////////////////////////////////////////////////////////
 745   // Carbon Fiber Junction Transformation
 746   /////////////////////////////////////////////////////////////
 747   const Int_t kcarbonfiberjunctionmatrixnumber = 2;
 748   TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
 749   TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
 750   TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
 751   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
 752         localcarbonfiberjunctionmatrix[i] =
 753                                                 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
 754         localcarbonfiberjunctionrot[i] =
 755                                                 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
 756         localcarbonfiberjunctiontrans[i] =
 757                                                 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
 758   }
 759   ///////////////////////
 760   // Setting Translations
 761   ///////////////////////
 762   localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
 763   localcarbonfiberjunctiontrans[1][0] =
 764                                  new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
 765   localcarbonfiberjunctiontrans[2][0] =
 766                                  new TGeoTranslation(fgkCarbonFiberTriangleLength
 767                                  * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
 768                                  fgkCarbonFiberTriangleLength
 769                                  * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
 770   localcarbonfiberjunctiontrans[0][1] =
 771                                  new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
 772   localcarbonfiberjunctiontrans[1][1] =
 773                                  new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
 774   localcarbonfiberjunctiontrans[2][1] =
 775                                  new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
 776   ////////////////////
 777   // Setting Rotations
 778   ////////////////////
 779   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
 780                 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
 781                         localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
 782   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
 783         localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
 784   localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
 785   localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
 786   localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
 787   ////////////////////////////////////////
 788   // Setting Carbon Fiber Junction matrix
 789   ////////////////////////////////////////
 790   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
 791                 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
 792                 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
 793                         localcarbonfiberjunctionmatrix[i][j] =
 794                         new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
 795                                                            *localcarbonfiberjunctionrot[i][j]);
 796                     fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
 797          }
 798   }
 799   /////////////////////////////////////////////////////////////
 800   // Carbon Fiber Lower Support Transformations
 801   /////////////////////////////////////////////////////////////
 802   TGeoTranslation* localcarbonfiberlowersupportrans[2];
 803   localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
 804                                                                          fgkCarbonFiberLowerSupportVolumePosition[1]
 805                                                                 +    fgkCarbonFiberLowerSupportVolumePosition[0],
 806                                                                          0.0);
 807   localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
 808                                                                          fgkCarbonFiberJunctionWidth
 809                                                                 -    fgkCarbonFiberLowerSupportWidth
 810                                                                 -    fgkCarbonFiberLowerSupportVolumePosition[0]
 811                                                                 -    fgkCarbonFiberLowerSupportVolumePosition[1],
 812                                                                 -    0.5*fgkCarbonFiberLowerSupportHeight);
 813    localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
 814    fcarbonfiberlowersupportrans[0] =
 815                                                 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
 816    fcarbonfiberlowersupportrans[1] =
 817                                                 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
 818   /////////////////////////////////////////////////////////////
 819   // SSD Sensor Support Transformations
 820   /////////////////////////////////////////////////////////////
 821   const Int_t kssdsensorsupportmatrixnumber = 3;
 822   TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
 823   TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
 824   TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
 825   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 826         localssdsensorsupportmatrix[i] =
 827                                                 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
 828         localssdsensorsupportrot[i] =
 829                                                 new TGeoRotation*[kssdsensorsupportmatrixnumber];
 830         localssdsensorsupportrans[i] =
 831                                                 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
 832   }
 833   ///////////////////////
 834   // Setting Translations
 835   ///////////////////////
 836   localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
 837                                                                           0.5*fgkSSDSensorSideSupportWidth,
 838                                                                           0.0);
 839   localssdsensorsupportrans[1][0] =
 840                                                  new TGeoTranslation(*localssdsensorsupportrans[0][0]);
 841   localssdsensorsupportrans[2][0] =
 842                                                  new TGeoTranslation(*localssdsensorsupportrans[0][0]);
 843   localssdsensorsupportrans[0][1] =
 844                                                  new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
 845                                                                                 0.5*fgkSSDSensorSideSupportThickness[0],
 846                                                                                 0.0);
 847   localssdsensorsupportrans[1][1] =
 848                                                  new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
 849                                                                         -   0.5*fgkSSDSensorSideSupportThickness[0]
 850                                                                     -   fgkSSDModuleSensorSupportDistance,
 851                                                                                 0.0);
 852   localssdsensorsupportrans[2][1] =
 853                                                  new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
 854                                                                         -    fgkSSDSensorCenterSupportPosition,
 855                                                                                  0.5*fgkSSDSensorCenterSupportWidth
 856                                                                         -    0.5*fgkSSDModuleSensorSupportDistance,
 857                                                                                  fgkSSDSensorCenterSupportThickness[0]);
 858   localssdsensorsupportrans[0][2] =
 859                                                  new TGeoTranslation(fgkCarbonFiberTriangleLength
 860                                                                         +    fgkCarbonFiberJunctionToSensorSupport,
 861                                                                                  fgkCarbonFiberJunctionWidth
 862                                                                     -    0.5*(fgkCarbonFiberLowerSupportWidth
 863                                                                         +    fgkSSDSensorCenterSupportLength
 864                                                                         -    fgkSSDSensorCenterSupportThickness[0])
 865                                                                         -    fgkSSDSensorCenterSupportPosition,
 866                                                                              0.0);
 867   localssdsensorsupportrans[1][2] =
 868                                                 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
 869   localssdsensorsupportrans[2][2] =
 870                                                 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
 871   ////////////////////
 872   // Setting Rotations
 873   ////////////////////
 874   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
 875                 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
 876                         localssdsensorsupportrot[i][j] = new TGeoRotation();
 877   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 878         localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
 879         localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
 880   }
 881   localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
 882   localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
 883   localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
 884   ////////////////////////////////////////
 885   // SSD Sensor Support matrix
 886   ////////////////////////////////////////
 887   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 888                 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
 889                 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
 890                         localssdsensorsupportmatrix[i][j] =
 891                         new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
 892                                                            *localssdsensorsupportrot[i][j]);
 893                     fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
 894          }
 895   }
 896   /////////////////////////////////////////////////////////////
 897   // SSD Cooling Tube Support Transformations
 898   /////////////////////////////////////////////////////////////
 899   const Int_t kcoolingtubesupportmatrixnumber = 2;
 900   TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
 901   TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
 902   TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
 903   Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
 904                                                                                                         /fgkCoolingTubeSupportRmax);
 905   localcoolingtubesupportrans[0] =
 906                         new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
 907                                                 +  2.*(fgkCoolingTubeSupportLength
 908                                                 -  fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
 909                                                 +  fgkCarbonFiberTriangleLength
 910                                                 -  2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
 911   localcoolingtubesupportrans[1] =
 912                         new TGeoTranslation(fgkCarbonFiberJunctionLength
 913                                         - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
 914                                         - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 915                                                    fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 916                     +  0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 917                     -  0.5*(fgkCarbonFiberLowerSupportWidth
 918                                         +          fgkSSDSensorCenterSupportLength
 919                     -      fgkSSDSensorCenterSupportThickness[0])
 920                                         +  0.5*fgkSSDSensorLength,
 921                                         -  0.5*fgkCoolingTubeSupportHeight);
 922   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
 923   localcoolingtubesupportrot[i] = new TGeoRotation();
 924   localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
 925   localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
 926   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
 927         localcoolingtubesupportmatrix[i] =
 928                 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
 929                                                    *localcoolingtubesupportrot[i]);
 930   fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
 931   fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
 932                                                                 (*localcoolingtubesupportmatrix[0]));
 933   /////////////////////////////////////////////////////////////
 934   // End Ladder SSD Cooling Tube Support Transformations
 935   /////////////////////////////////////////////////////////////
 936   TGeoTranslation** localendladdercooltubetrans[2];
 937   localendladdercooltubetrans[0] = new TGeoTranslation*[4];
 938   localendladdercooltubetrans[1] = new TGeoTranslation*[2];
 939   for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
 940   localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
 941                                                                                         -          (fgkCoolingTubeSupportLength
 942                                                                                         -               fgkCoolingTubeSupportRmax),
 943                                                                                                         fgkEndLadderMountingBlockPosition[0]
 944                                                                                         -               fgkendladdercoolingsupportdistance[0]
 945                                                                                         +   0.5*fgkCoolingTubeSupportWidth,
 946                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 947   localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
 948                                                                                         -          (fgkCoolingTubeSupportLength
 949                                                                                         -               fgkCoolingTubeSupportRmax),
 950                                                                                                         fgkEndLadderMountingBlockPosition[0]
 951                                                                                         +               fgkendladdercoolingsupportdistance[1]
 952                                                                                         +   0.5*fgkCoolingTubeSupportWidth,
 953                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 954   localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
 955                                                                                         -       fgkCoolingTubeSupportRmax)
 956                                                                                         +               fgkCarbonFiberTriangleLength
 957                                                                                         -   2.0*fgkCarbonFiberJunctionLength,
 958                                                                                                 0.0,
 959                                                                                                 0.0);
 960   localendladdercooltubetrans[0][3]->SetTranslation(0.0,
 961                                                                                                         fgkendladdercoolingsupportdistance[0]
 962                                                                                         +               fgkendladdercoolingsupportdistance[1],
 963                                                                                                         0.0);
 964   for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
 965   localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
 966                                                                                         +               fgkCarbonFiberJunctionLength
 967                                                                                         -               fgkCoolingTubeSupportLength,
 968                                                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[1]
 969                                                                                         -       0.5*fgkCoolingTubeSupportWidth
 970                                                                                                    -fgkendladdercoolingsupportdistance[2],
 971                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 972   localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
 973                                                                                         +               fgkCoolingTubeSupportLength
 974                                                                                         -               fgkCoolingTubeSupportRmax
 975                                                                                         -               fgkCarbonFiberJunctionLength,
 976                                                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[1]
 977                                                                                         -       0.5*fgkCoolingTubeSupportWidth
 978                                                                                         -               fgkendladdercoolingsupportdistance[2],
 979                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 980   fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
 981   fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
 982   fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
 983   fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
 984   (*localcoolingtubesupportrot[1]));
 985   fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
 986   (*localcoolingtubesupportrot[1]));
 987   fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
 988   fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
 989   fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
 990   fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
 991   fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
 992
 993   fendladdercoolingtubesupportmatrix[1][0] =
 994                                                         new TGeoHMatrix((*localendladdercooltubetrans[1][0])
 995                                                                                    *(*localcoolingtubesupportrot[1]));
 996   fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
 997   fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
 998   fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
 999   /////////////////////////////////////////////////////////////
1000   // SSD Cooling Tube Transformations
1001   /////////////////////////////////////////////////////////////
1002   TGeoRotation* localcoolingtuberot = new TGeoRotation();
1003   localcoolingtuberot->SetAngles(0.,90.,0.);
1004   TGeoTranslation* localcoolingtubetrans[2];
1005   TVector3* localcoolingtubevect[2];
1006
1007   localcoolingtubevect[0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
1008                                                   -fgkCarbonFiberTriangleLength),
1009                                             fgkCarbonFiberJunctionWidth         // Y-coord is local Z, from sensor translation
1010                                             - fgkCarbonFiberLowerSupportWidth
1011                                             - fgkLowerSupportToSensorZ ,
1012                                                   -  0.5*fgkCoolingTubeSupportHeight);
1013   localcoolingtubevect[1] = new TVector3( -localcoolingtubevect[0]->X()+fgkCarbonFiberTriangleLength,
1014                                               localcoolingtubevect[0]->Y(),
1015                                               localcoolingtubevect[0]->Z());
1016   for(Int_t j=0; j<2; j++){
1017     localcoolingtubetrans[j] =
1018         new TGeoTranslation(localcoolingtubevect[j]->X(),
1019                             localcoolingtubevect[j]->Y(),
1020                             localcoolingtubevect[j]->Z());
1021      fcoolingtubematrix[j] = new TGeoHMatrix((*localcoolingtubetrans[j])
1022                                              *(*localcoolingtuberot));
1023   }
1024   /////////////////////////////////////////////////////////////
1025   // SSD End Ladder Cooling Tube Transformations
1026   /////////////////////////////////////////////////////////////
1027   TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
1028   localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
1029   TGeoTranslation** localendlladdercoolingtubetrans[2];
1030   localendlladdercoolingtubetrans[0] = new TGeoTranslation*[2];
1031   localendlladdercoolingtubetrans[1] = new TGeoTranslation*[2];
1032   for(Int_t i=0; i<2; i++)
1033         for(Int_t j=0; j<2; j++)
1034                 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
1035
1036   Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
1037   localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1038                                                                         -        fgkCoolingTubeSupportRmax)
1039                                                                         +        fgkCarbonFiberJunctionLength,
1040                                                         0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
1041                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1042   localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1043                                                                         -        fgkCoolingTubeSupportRmax)
1044                                                                         -        fgkCarbonFiberJunctionLength
1045                                                                         +    fgkCarbonFiberTriangleLength,
1046                                                         0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
1047                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1048
1049   localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1050                                                           -   fgkCoolingTubeSupportRmax)
1051                                                         +       fgkCarbonFiberJunctionLength,
1052                                                         0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
1053                                                   -             0.5*fgkCoolingTubeSupportHeight);
1054   localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1055                                                   -      fgkCoolingTubeSupportRmax)
1056                                                   -      fgkCarbonFiberJunctionLength
1057                                                   +    fgkCarbonFiberTriangleLength,
1058                                                         0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
1059                                                   -             0.5*fgkCoolingTubeSupportHeight);
1060   for(Int_t i=0; i<2; i++)
1061         for(Int_t j=0; j<2; j++){
1062                 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1063                 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1064         }
1065   /////////////////////////////////////////////////////////////
1066   // SSD Hybrid Components Transformations
1067   /////////////////////////////////////////////////////////////
1068   const Int_t khybridmatrixnumber = 3;
1069   TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1070   localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1071                                             0.5*fgkSSDStiffenerWidth,
1072                                             0.5*fgkSSDStiffenerHeight);
1073   localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1074                                             fgkSSDModuleStiffenerPosition[1],0.0);
1075
1076   localhybridtrans[2] = new TGeoTranslation(
1077                       -  0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1078                       -      (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1079                               fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1080                       +         0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1081                       -         0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1082                       -       fgkSSDSensorCenterSupportThickness[0]),
1083                       -      (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
1084                       -       fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight
1085                                           -       fgkSSDModuleVerticalDisalignment));
1086   fhybridmatrix = new TGeoHMatrix();
1087   for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1088   /////////////////////////////////////////////////////////////
1089   // SSD Cooling Block Transformations
1090   /////////////////////////////////////////////////////////////
1091   TGeoTranslation localcoolingblocktrans (fcoolingtubematrix[0]->GetTranslation()[0]
1092                                           - 0.5*fgkSSDCoolingBlockLength,
1093                                           fhybridmatrix->GetTranslation()[1]-0.5*fgkSSDStiffenerWidth,
1094                                           fhybridmatrix->GetTranslation()[2]+0.5*fgkSSDStiffenerHeight+
1095                                           0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1096   fcoolingblocksystematrix = new TGeoHMatrix(localcoolingblocktrans);
1097   /////////////////////////////////////////////////////////////
1098   // SSD Stiffener Flex Transformations
1099   /////////////////////////////////////////////////////////////
1100   const Int_t klocalflexmatrixnumber = 4;
1101   TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1102   for(Int_t i=0; i<fgkflexnumber; i++)
1103       localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1104   for(Int_t i=0; i<fgkflexnumber; i++)
1105       for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1106             localflexmatrix[i][j] = new TGeoCombiTrans();
1107   Double_t ssdstiffenerseparation = fgkSSDSensorLength
1108                                                                   - 2.*fgkSSDModuleStiffenerPosition[1]
1109                                                                   -    fgkSSDStiffenerWidth;
1110   localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1111                                         +0.5*fgkSSDStiffenerLength,
1112                                          0.5*fgkSSDStiffenerWidth,
1113                                         -0.5*fgkSSDStiffenerHeight
1114                                         -0.5*fgkSSDFlexHeight[0]);
1115   localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1116                                         +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1117                                         -0.5*fgkSSDStiffenerWidth,
1118                                         -0.5*fgkSSDStiffenerHeight
1119                                         -0.5*fgkSSDFlexHeight[0]);
1120   TGeoRotation* localflexrot = new TGeoRotation();
1121   localflexrot->SetAngles(180.,0.,0.);
1122   localflexmatrix[1][0]->SetRotation(localflexrot);
1123   for(Int_t i=0; i<fgkflexnumber; i++)
1124       for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1125             localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1126   for(Int_t i=0; i<fgkflexnumber; i++){
1127       fstiffenerflexmatrix[i] = new TGeoHMatrix();
1128       for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1129             fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
1130   }
1131   /////////////////////////////////////////////////////////////
1132   // SSD End Flex Transformations
1133   /////////////////////////////////////////////////////////////
1134   TGeoRotation* localendflexrot = new TGeoRotation();
1135   localendflexrot->SetAngles(0.0,90.0,0.0);
1136   TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1137   Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1138                             /  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1139   Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1140                             * TMath::DegToRad()*ssdflexradiusmax
1141                                                                - fgkSSDFlexLength[2]-TMath::Pi()
1142                                                                * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1143                                                                                    - 0.1*fgkSSDFlexFullLength;
1144   Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1145                             + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1146                             +      fgkSSDFlexLength[2];
1147   localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1148                               0.5*fgkSSDFlexWidth[0],
1149                               2.*fgkSSDStiffenerHeight
1150                             + 0.5*fgkSSDFlexHeight[0]);
1151   localendflexmatrix->SetRotation(localendflexrot);
1152   for(Int_t i=0; i<fgkflexnumber; i++)
1153       fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1154   /////////////////////////////////////////////////////////////
1155   // End Ladder Carbon Fiber Junction
1156   /////////////////////////////////////////////////////////////
1157   TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1158   TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1159   TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1160   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1161       localendladdercarbonfiberjunctionmatrix[i]
1162             = new TGeoCombiTrans*[fgkendladdercabonfiberjunctionmatrixnumber];
1163       localendladdercarbonfiberjunctionrot[i]
1164             = new TGeoRotation*[fgkendladdercabonfiberjunctionmatrixnumber];
1165       localendladdercarbonfiberjunctiontrans[i]
1166             = new TGeoTranslation*[fgkendladdercabonfiberjunctionmatrixnumber];
1167       fendladdercarbonfiberjunctionmatrix[i]
1168             = new TGeoHMatrix*[fgkendladdercabonfiberjunctionmatrixnumber];
1169   }
1170   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1171       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1172             localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1173             localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1174       }
1175   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1176       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
1177           localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1178   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1179       localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1180                               0.0,0.0);
1181       localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1182                 *                     CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1183                 *                     SinD(fgkCarbonFiberTriangleAngle),
1184                         0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1185   -                          fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1186   }
1187   TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1188   TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1189   TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1190   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1191       localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1192       localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1193       localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1194       localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1195             0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1196       localendladdercarbonfiberjunctionglobalmatrix[i] =
1197             new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1198                                *localendladdercarbonfiberjunctionglobalrot[i]);
1199   }
1200   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1201       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1202             localendladdercarbonfiberjunctionmatrix[i][j] =
1203                   new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1204                                      *localendladdercarbonfiberjunctionrot[i][j]);
1205            fendladdercarbonfiberjunctionmatrix[i][j] =
1206             new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1207             *               (*localendladdercarbonfiberjunctionmatrix[i][j]));
1208       }
1209   /////////////////////////////////////////////////////////////
1210   // End Ladder Carbon Fiber Support
1211   /////////////////////////////////////////////////////////////
1212   TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1213   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1214       localendladdercarbonfibertrans[i] = new TGeoTranslation();
1215       localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1216             i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1217       fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1218   }
1219   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1220       for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1221             fendladdercarbonfibermatrix[i][j] =
1222             new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1223             *(*fcarbonfibersupportmatrix[j]));
1224   /////////////////////////////////////////////////////////////
1225   // End Ladder SSD Mounting Block
1226   /////////////////////////////////////////////////////////////
1227   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1228       fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1229   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1230       fendladdermountingblockcombitrans[i]->SetTranslation(-  0.25*(fgkSSDMountingBlockLength[0]
1231                                 +        fgkSSDMountingBlockLength[1])
1232                                 +  0.5*fgkCarbonFiberTriangleLength,
1233                                 fgkEndLadderMountingBlockPosition[i],
1234                                 -  fgkSSDMountingBlockHeight[1]
1235                                 +  0.5*fgkSSDMountingBlockHeight[0]);
1236   TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1237   endladdermountingblockrot->SetAngles(0.,90.,0.);
1238   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1239         fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1240   /////////////////////////////////////////////////////////////
1241   // End Ladder SSD Mounting Block Clip Matrix
1242   /////////////////////////////////////////////////////////////
1243   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1244         fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1245
1246   TGeoRotation* localendladdercliprot = new TGeoRotation();
1247   TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1248   localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1249                                                                                   -     fgkSSDMountingBlockLength[1])
1250                                                                                   + fgkSSDMountingBlockLength[0],0.,0.);
1251   localendladdercliprot->SetAngles(90.,180.,-90.);
1252   TGeoCombiTrans* localendladderclipcombitrans =
1253                         new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1254   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1255         for(Int_t j=0; j<2; j++){
1256                 fendladdermountingblockclipmatrix[i][j] =
1257                                                 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1258                 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1259         }
1260   /////////////////////////////////////////////////////////////
1261   // End Ladder Carbon Fiber Lower Support
1262   /////////////////////////////////////////////////////////////
1263   for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1264       fendladderlowersupptrans[i] =
1265             new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1266                         +  0.5*fgkSSDMountingBlockWidth),
1267                         -  0.5*fgkCarbonFiberLowerSupportHeight);
1268   fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1269                                                                          fgkCarbonFiberLowerSupportVolumePosition[1]
1270                                                                 +    fgkCarbonFiberLowerSupportVolumePosition[0],
1271                                                                          0.0);
1272   fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1273  /////////////////////////////////////////////////////////////
1274   // Matrix for positioning Ladder into mother volume
1275   /////////////////////////////////////////////////////////////
1276   TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1277   for(Int_t i=0; i<fgkladdernumber; i++)
1278         ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1279   TGeoRotation* localladdermotherrot = new TGeoRotation();
1280   localladdermotherrot->SetAngles(0.,90.,0.);
1281   TGeoTranslation* localladdermothertrans[fgkladdernumber];
1282   TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1283   for(Int_t i=0; i<fgkladdernumber; i++){
1284         localladdermothertrans[i] = new TGeoTranslation(0.,
1285                                                           - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1286                                                           + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1287                                                           + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1288                                                           * fgkCarbonFiberJunctionWidth,0.);
1289         localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1290                                                                                                                 *localladdermotherrot);
1291         ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1292         ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
1293   }
1294   /////////////////////////////////////////////////////////////
1295   // Ladder Cables Matrices
1296   /////////////////////////////////////////////////////////////
1297   Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
1298                                              + fgkSSDFlexHeight[1];
1299   Double_t ssdladdercabletransx[3];
1300   ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1301                                                   *   SinD(2.*fgkSSDFlexAngle)
1302                                                   *       CosD(2.*fgkSSDFlexAngle);
1303   ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1304                                                   -     ssdladdercabletransx[0]
1305                                                   /     SinD(2.*fgkSSDFlexAngle))
1306                                                   *     CosD(fgkSSDFlexAngle);
1307   ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1308                                                   *       TMath::DegToRad()*ssdflexradiusmax
1309                                                   -     fgkSSDFlexLength[2]-TMath::Pi()
1310                                                   *       fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1311                                                   -       fgkSSDLadderCableWidth)
1312                                                   *       CosD(2.*fgkSSDFlexAngle);
1313   Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
1314                                                   *     TanD(2.*fgkSSDFlexAngle),
1315                                                         ssdladdercabletransx[1]
1316                                                   *     TanD(fgkSSDFlexAngle),
1317                                                         ssdladdercabletransx[2]
1318                                                   *     TanD(2.*fgkSSDFlexAngle)};
1319   TGeoRotation* localladdercablerot[3];
1320   for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1321   localladdercablerot[0]->SetAngles(90.,0.,0.);
1322   localladdercablerot[1]->SetAngles(90.,60.,-90.);
1323   localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1324                                                  *                        (*localladdercablerot[0]));
1325   //TGeoRotation* localladdercablerot = new TGeoRotation();
1326   //localladdercablerot->SetAngles(90.,0.,0.);
1327   ////////////////////////////////////////////
1328   // LocalLadderCableCombiTransMatrix
1329   ////////////////////////////////////////////
1330   const Int_t klocalladdersidecablesnumber = 2;
1331   const Int_t klocalladdercombitransnumber = 5;
1332   TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1333   for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1334          localladdercablecombitransmatrix[i] =
1335                                                            new TGeoCombiTrans*[klocalladdercombitransnumber];
1336   ///////////////////////////////////////////
1337   // Left Side Ladder Cables Transformations
1338   ///////////////////////////////////////////
1339   localladdercablecombitransmatrix[0][0]  =
1340                                                 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1341                                                 0.,0.,NULL);
1342   localladdercablecombitransmatrix[0][1] =
1343         new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1344                                            - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1345                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1346                                            + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1347                                            - 0.5*(fgkCarbonFiberLowerSupportWidth
1348                                            + fgkSSDSensorCenterSupportLength
1349                                            - fgkSSDSensorCenterSupportThickness[0]),
1350                                            - (fgkSSDModuleCoolingBlockToSensor
1351                                            + 0.5*fgkCoolingTubeSupportHeight
1352                                            - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1353                                            - fgkSSDChipHeight),NULL);
1354   localladdercablecombitransmatrix[0][2] =
1355                                                 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1356                                                                                    fgkSSDModuleStiffenerPosition[1],0.,0);
1357   localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1358                                         0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1359                                    +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1360                                    fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1361                                          - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1362                                                                                                 new TGeoRotation("",180.,0.,0.));
1363   localladdercablecombitransmatrix[0][4] =
1364                                                 new TGeoCombiTrans(-ssdladdercabletransx[0]
1365                                                 -     ssdladdercabletransx[1]-ssdladdercabletransx[2]
1366                                                 +     fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1367                                                           0.,
1368                                                           0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1369                                                 +         fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
1370                                                 +     ssdladdercabletransz[0]-ssdladdercabletransz[1]
1371                                                 +         ssdladdercabletransz[2],localladdercablerot[2]);
1372   ///////////////////////////////////////////
1373   // Rigth Side Ladder Cables Transformations
1374   ///////////////////////////////////////////
1375   TGeoCombiTrans* localladdercablessdmodulematrix =
1376         new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1377                                                                   - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1378                                                                          fgkSSDStiffenerWidth,
1379                                                                   - 0.5*fgkSSDFlexHeight[0],NULL);
1380   for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1381    localladdercablecombitransmatrix[1][i] =
1382                         (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1383                                         new TGeoCombiTrans(*localladdercablessdmodulematrix));
1384   ///////////////////////////////////////////
1385   // Setting LadderCableHMatrix
1386   ///////////////////////////////////////////
1387   Int_t beamaxistrans[2][3];
1388   beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1389   beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1390   beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1391   beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1392   beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1393   beamaxistrans[1][2] = beamaxistrans[1][0];
1394   TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1395   TGeoRotation* laddercablerot = new TGeoRotation();
1396   TGeoTranslation* laddercabletrans = new TGeoTranslation();
1397   TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1398   Double_t* laddercabletransvector;
1399   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1400         localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1401         fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1402   }
1403   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1404         for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1405                 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1406                 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1407                         localladdercablehmatrix[i][j]->MultiplyLeft(
1408                         localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1409         }
1410                 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1411                 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1412                 laddercabletrans->SetTranslation(laddercabletransvector[0],
1413                                                                          laddercabletransvector[1]
1414                                         +                (j==0 ? beamaxistrans[i][0] : 0.)
1415                                         *                                fgkCarbonFiberJunctionWidth,
1416                                                                          laddercabletransvector[2]);
1417                 laddercablecombitrans->SetRotation(*laddercablerot);
1418                 laddercablecombitrans->SetTranslation(*laddercabletrans);
1419                 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1420         }
1421     fladdercablematrix[i][2] =
1422                                         AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1423                                         beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1424         fladdercablematrix[i][3] =
1425                                         AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1426                                         beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1427   }
1428   for(Int_t i=0; i<fgkladdercablesnumber; i++)
1429     for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1430       fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1431
1432   ///////////////////////////////////////////
1433   // Setting Ladder HMatrix
1434   ///////////////////////////////////////////
1435   Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1436                                                                                                 fgkSSDLay6SensorsNumber};
1437   for(Int_t i=0; i<fgkladdernumber; i++){
1438         fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1439         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1440                 fladdermatrix[i][j] = new TGeoHMatrix();
1441                 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1442                 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1443                 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1444         }
1445   }
1446   ///////////////////////////////////////////
1447   // Setting SSD Sensor Matrix
1448   ///////////////////////////////////////////
1449   TGeoCombiTrans* localssdsensorcombitrans[2];
1450   TGeoRotation* localssdsensorrot = new TGeoRotation();
1451   localssdsensorrot->SetAngles(0.,90.,0.);
1452   TGeoTranslation* localssdsensortrans[2];
1453   for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1454   localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1455                                          fgkCarbonFiberJunctionWidth
1456                                          - fgkCarbonFiberLowerSupportWidth
1457                                          - fgkLowerSupportToSensorZ,
1458                                                         0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1459                                           -             fgkSSDModuleCoolingBlockToSensor
1460                                           +    (fgkSSDSensorSideSupportHeight[1]
1461                                           -             fgkSSDSensorSideSupportHeight[0]));
1462   localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1463                                          fgkCarbonFiberJunctionWidth
1464                                          - fgkCarbonFiberLowerSupportWidth
1465                                          - fgkLowerSupportToSensorZ,
1466                                                     0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1467                                                         -fgkSSDModuleCoolingBlockToSensor);
1468
1469   for(Int_t i=0; i<2; i++)
1470         localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1471                                                                                                          *localssdsensorrot);
1472     for(Int_t i=0; i<fgkladdernumber; i++){
1473         fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1474         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1475                 switch(i){
1476                         case 0: //Ladder of Layer5
1477                         fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1478                                                                    * ((j%2==0 ? *localssdsensorcombitrans[0] :
1479                                                                                                 *localssdsensorcombitrans[1])));
1480                         break;
1481                         case 1: //Ladder of Layer6
1482                         fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1483                                                                    * ((j%2==0 ? *localssdsensorcombitrans[1] :
1484                                                                                                 *localssdsensorcombitrans[0])));
1485                 break;
1486                 }
1487           }
1488   }
1489   //////////////////////////
1490   // Setting SSD End Ladder
1491   //////////////////////////
1492   for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1493   for(Int_t i=0; i<2; i++){
1494         fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1495         fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1496         fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1497         fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1498         fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1499         fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1500         fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1501         fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1502    }
1503   /////////////////////////////////////////////////////
1504   // Setting the CombiTransformation to pass ITS center
1505   /////////////////////////////////////////////////////
1506   Double_t itscentertransz[fgklayernumber];
1507   itscentertransz[0] = fgkSSDLay5LadderLength
1508                                          - fgkLay5CenterITSPosition;
1509   itscentertransz[1] = fgkSSDLay6LadderLength
1510                                          - fgkLay6CenterITSPosition;
1511   Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1512                                                    + 0.5*fgkCoolingTubeSupportHeight;
1513   TGeoRotation* itscenterrot[3];
1514   for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1515   itscenterrot[0]->SetAngles(90.,180.,-90.);
1516   itscenterrot[1]->SetAngles(0.,90.,0.);
1517   itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1518   TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1519   for(Int_t i=0; i<fgklayernumber; i++)
1520         itscentercombitrans[i] = new TGeoCombiTrans(0.,
1521                                                          itssensortransy,
1522                                                          fgkEndLadderCarbonFiberLowerJunctionLength[1]
1523                                                    - itscentertransz[i],itscenterrot[2]);
1524   TGeoRotation** locallayerrot[fgklayernumber];
1525   TGeoTranslation** locallayertrans[fgklayernumber];
1526   TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1527   TGeoTranslation* localbeamaxistrans[fgklayernumber];
1528   localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1529                                          - fgkLay5CenterITSPosition);
1530   localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1531                                          - fgkLay6CenterITSPosition);
1532   const Int_t kssdlayladdernumber[fgklayernumber] =
1533                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1534   for(Int_t i=0; i<fgklayernumber; i++){
1535     locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1536     locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1537         locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1538         flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1539   }
1540   Double_t layerladderangleposition[fgklayernumber] =
1541                 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1542   Double_t layerradius = 0.;
1543   for(Int_t i=0; i<fgklayernumber; i++){
1544         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1545                 switch(i){
1546                         case 0: //Ladder of Layer5
1547                         layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1548                         break;
1549                         case 1: //Ladder of Layer6
1550                         layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1551                 break;
1552                 }
1553                 locallayerrot[i][j] = new TGeoRotation();
1554                 locallayertrans[i][j] = new TGeoTranslation();
1555                 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1556                 locallayertrans[i][j]->SetTranslation(layerradius
1557                                                           *     CosD(90.0+j*layerladderangleposition[i]),
1558                                                             layerradius
1559                                                           * SinD(90.0+j*layerladderangleposition[i]),0.);
1560                 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1561                                                                          *locallayerrot[i][j]);
1562                 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1563                 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1564                 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1565         }
1566   }
1567   /////////////////////////////////////////////////////////////
1568   // Deallocating memory
1569   /////////////////////////////////////////////////////////////
1570   for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1571         delete carbonfiberot[i];
1572         delete localcarbonfibersupportmatrix[i];
1573   }
1574   for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1575      for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1576        delete localcarbonfiberjunctionmatrix[i][j];
1577            delete localcarbonfiberjunctionrot[i][j];
1578            delete localcarbonfiberjunctiontrans[i][j];
1579            }
1580        delete [] localcarbonfiberjunctionmatrix[i];
1581        delete [] localcarbonfiberjunctionrot[i];
1582        delete [] localcarbonfiberjunctiontrans[i];
1583   }
1584   for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1585            delete localcarbonfiberlowersupportrans[i];
1586   for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1587      for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1588        delete localssdsensorsupportmatrix[i][j];
1589            delete localssdsensorsupportrot[i][j];
1590            delete localssdsensorsupportrans[i][j];
1591            }
1592        delete [] localssdsensorsupportmatrix[i];
1593        delete [] localssdsensorsupportrot[i];
1594        delete [] localssdsensorsupportrans[i];
1595   }
1596   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1597         delete localcoolingtubesupportmatrix[i];
1598         delete localcoolingtubesupportrot[i];
1599         delete localcoolingtubesupportrans[i];
1600   }
1601   for(Int_t j=0; j<2; j++){
1602     delete localcoolingtubevect[j];
1603     delete localcoolingtubetrans[j];
1604   }
1605  delete endladdermountingblockrot;
1606  for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
1607  for(Int_t i=0; i<fgkflexnumber; i++){
1608       for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1609             delete localflexmatrix[i][j];
1610       delete [] localflexmatrix[i];
1611  }
1612  delete localendlladdercoolingtuberot;
1613  for(Int_t i=0; i<2; i++){
1614         for(Int_t j=0; j<2; j++)
1615           delete localendlladdercoolingtubetrans[i][j];
1616         delete [] localendlladdercoolingtubetrans[i];
1617   }
1618
1619  delete localflexrot;
1620  delete localendflexrot;
1621  delete localendflexmatrix;
1622  for(Int_t i=0; i<fgkladdernumber; i++){
1623         delete localladdermothertrans[i];
1624         delete localladdermothercombitrans[i];
1625   }
1626  delete localladdermotherrot;
1627  for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1628       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1629             delete localendladdercarbonfiberjunctionmatrix[i][j];
1630             delete localendladdercarbonfiberjunctionrot[i][j];
1631             delete localendladdercarbonfiberjunctiontrans[i][j];
1632       }
1633       delete [] localendladdercarbonfiberjunctionmatrix[i];
1634       delete [] localendladdercarbonfiberjunctionrot[i];
1635       delete [] localendladdercarbonfiberjunctiontrans[i];
1636       delete localendladdercarbonfiberjunctionglobalrot[i];
1637       delete localendladdercarbonfiberjunctionglobaltrans[i];
1638       delete localendladdercarbonfiberjunctionglobalmatrix[i];
1639  }
1640   for(Int_t i=0; i<2; i++){
1641         for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1642         delete [] localendladdercooltubetrans[i];
1643   }
1644   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1645       delete localendladdercarbonfibertrans[i];
1646   for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1647   for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1648         for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1649                 delete localladdercablecombitransmatrix[i][j];
1650                 delete []localladdercablecombitransmatrix[i];
1651   }
1652   delete localendladdercliprot;
1653   delete localendladdercliptrans;
1654   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1655         for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1656                 delete localladdercablehmatrix[i][j];
1657         delete []localladdercablehmatrix[i];
1658   }
1659   delete laddercablerot;
1660   delete laddercabletrans;
1661   delete laddercablecombitrans;
1662   delete localladdercablessdmodulematrix;
1663   delete localssdsensorrot;
1664   for(Int_t i=0; i<2; i++){
1665         delete localssdsensortrans[i];
1666         delete localssdsensorcombitrans[i];
1667   }
1668   for(Int_t i=0; i<fgklayernumber; i++){
1669         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1670                 delete locallayerrot[i][j];
1671                 delete locallayertrans[i][j];
1672                 delete locallayercombitrans[i][j];
1673     }
1674         delete [] locallayerrot[i];
1675         delete [] locallayertrans[i];
1676         delete [] locallayercombitrans[i];
1677         delete localbeamaxistrans[i];
1678   }
1679   for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1680   for(Int_t i=0; i<fgkladdernumber; i++){
1681         for(Int_t j=0; j<fgkladdernumber; j++)
1682                 delete ladderglobalmatrix[i][j];
1683         delete [] ladderglobalmatrix[i];
1684   }
1685   /////////////////////////////////////////////////////////////
1686   fTransformationMatrices = kTRUE;
1687 }
1688 ///////////////////////////////////////////////////////////////////////////////
1689 void AliITSv11GeometrySSD::CreateBasicObjects(){
1690   /////////////////////////////////////////////////////////////
1691   // Method generating the Objects of SSD Geometry
1692   /////////////////////////////////////////////////////////////
1693   // SSD Sensor
1694   ///////////////////////////////////
1695   SetSSDSensor();
1696   /////////////////////////////////////////////////////////////
1697   // Carbon Fiber Support
1698   /////////////////////////////////////////////////////////////
1699   TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1700   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1701       fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
1702   /////////////////////////////////////////////////////////////
1703   // Carbon Fiber Junction
1704   /////////////////////////////////////////////////////////////
1705   fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth-fgkSSDTolerance);
1706   /////////////////////////////////////////////////////////////
1707   // Carbon Fiber Lower Support
1708   /////////////////////////////////////////////////////////////
1709   TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1710   for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1711         fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1712   /////////////////////////////
1713   // SSD Sensor Support
1714   /////////////////////////////
1715   for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1716                                                                                 new TGeoVolume*[fgkssdsensorsupportnumber];
1717   Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
1718                                                                          fgkSSDSensorSideSupportThickness[1]};
1719   for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1720         fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1721                                                                                            fgkSSDSensorSideSupportHeight[i],
1722                                                                                            fgkSSDSensorSideSupportWidth,
1723                                                                                            sidesupporthickness);
1724         fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1725                                                                                            fgkSSDSensorCenterSupportHeight[i],
1726                                                                                            fgkSSDSensorCenterSupportWidth,
1727                                                                                            sidesupporthickness);
1728   }
1729   /////////////////////////////////////////////////////////////
1730   // SSD Cooling Tube Support
1731   /////////////////////////////////////////////////////////////
1732   Int_t edgesnumber = 3;
1733   fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1734   /////////////////////////////////////////////////////////////
1735   // SSD Hybrid
1736   /////////////////////////////////////////////////////////////
1737   TList* ssdhybridcomponentslist = GetSSDHybridParts();
1738   for(Int_t i=0; i<fgkhybridcompnumber; i++)
1739         fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1740   /////////////////////////////////////////////////////////////
1741   // SSD Cooling Block System
1742   /////////////////////////////////////////////////////////////
1743   fssdcoolingblocksystem = GetCoolingBlockSystem();
1744    /////////////////////////////////////////////////////////////
1745   // SSD Cooling Tube
1746   /////////////////////////////////////////////////////////////
1747   CreateCoolingTubes();
1748   /////////////////////////////////////////////////////////////
1749   // SSD Flex
1750   /////////////////////////////////////////////////////////////
1751   fssdstiffenerflex = GetSSDStiffenerFlex();
1752   fssdendflex = GetSSDEndFlex();
1753   ///////////////////////////////////
1754   // End Ladder Carbon Fiber Junction
1755   ///////////////////////////////////
1756   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1757                                                    fendladdercarbonfiberjunction[i] =
1758                                                    new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1759   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1760     fendladdercarbonfiberjunction[i][0] =
1761                   GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]-fgkSSDTolerance);
1762     fendladdercarbonfiberjunction[i][1] =
1763                   GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]-fgkSSDTolerance);
1764   }
1765   ///////////////////////////////////
1766   // End Ladder Mounting Block
1767   ///////////////////////////////////
1768   fendladdermountingblock = GetSSDMountingBlock();
1769   ///////////////////////////////////
1770   // End Ladder Mounting Block
1771   ///////////////////////////////////
1772   fendladdermountingblockclip = GetMountingBlockClip();
1773   ///////////////////////////////////
1774   // Ladder Support
1775   ///////////////////////////////////
1776   TList* laddersupportlist = GetMountingBlockSupport(20);
1777   fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1778   fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1779   fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1780   fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
1781   /////////////////////////////////////////////////////////////
1782   // Deallocating memory
1783   /////////////////////////////////////////////////////////////
1784   delete carbonfibersupportlist;
1785   delete carbonfiberlowersupportlist;
1786   delete ssdhybridcomponentslist;
1787   delete laddersupportlist;
1788   /////////////////////////////////////////////////////////////
1789   fBasicObjects = kTRUE;
1790 }
1791 /////////////////////////////////////////////////////////////////////////////////
1792 void AliITSv11GeometrySSD::SetSSDSensor(){
1793   ////////////////////////////////////////////////////////////////
1794   // Method generating SSD Sensors: it sets the private variables
1795   // fSSDSensor5, fSSDSensor6
1796   ////////////////////////////////////////////////////////////////
1797   Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1798   Double_t ssdsensitivewidth  = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1799   TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
1800                                                 0.5*ssdsensitivewidth,
1801                                                 0.5*fgkSSDSensorHeight,
1802                                                 0.5*ssdsensitivelength);
1803   TGeoVolume* ssdsensorsensitiveLay5 =
1804         new TGeoVolume(fgSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
1805   TGeoVolume* ssdsensorsensitiveLay6 =
1806         new TGeoVolume(fgSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
1807   ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1808   ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
1809   TGeoBBox* ssdsensorinsensitiveshape[2];
1810   ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
1811                                                 0.5*fgkSSDSensorInsensitiveWidth,
1812                                                 0.5*fgkSSDSensorHeight,
1813                                                 0.5*fgkSSDSensorLength);
1814   ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
1815                                                 0.5*ssdsensitivewidth,
1816                                                 0.5*fgkSSDSensorHeight,
1817                                                 0.5*fgkSSDSensorInsensitiveWidth);
1818   const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
1819                                              "SSDSensorInsensitive2"};
1820   TGeoVolume* ssdsensorinsensitive[2];
1821   for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1822       new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1823                      fSSDSensorMedium);
1824       ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
1825   }
1826   /////////////////////////////////////////////////////////////
1827   // Virtual Volume containing SSD Sensor
1828   /////////////////////////////////////////////////////////////
1829   TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1830                                                                                              0.5*fgkSSDSensorWidth,
1831                                                                                              0.5*fgkSSDSensorHeight,
1832                                                                                              0.5*fgkSSDSensorLength);
1833   fSSDSensor5 = new TGeoVolume("ITSssdSensor5",virtualSSDSensorShape,
1834                                                                                  fSSDAir);
1835   fSSDSensor6 = new TGeoVolume("ITSssdSensor6",virtualSSDSensorShape,
1836                                                                                  fSSDAir);
1837   /////////////////////////////////////////////////////////////
1838   for(Int_t i=0; i<4; i++){
1839             fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1840             ssdsensorinsensitive[1],i<2?1:2,
1841                         new TGeoTranslation(
1842                          0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1843       *   (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1844                         0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1845       *   (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1846             fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1847             ssdsensorinsensitive[1],i<2?1:2,
1848                         new TGeoTranslation(
1849                          0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1850       *   (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1851                         0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1852       *   (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1853   }
1854     fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1855     fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
1856 }
1857 ///////////////////////////////////////////////////////////////////////////////
1858 TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1859   /////////////////////////////////////////////////////////////
1860   // Method generating the Carbon Fiber Support
1861   /////////////////////////////////////////////////////////////
1862   const Int_t kvertexnumber = 4;
1863   const Int_t kshapesnumber = 2;
1864   TVector3** vertexposition[kshapesnumber];
1865   for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1866   Double_t carbonfibersupportxaxisEdgeproj =
1867                 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1868         *       TMath::DegToRad());
1869   Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1870                                  /                         fgkCarbonFiberSupportXAxisLength);
1871   /////////////////////
1872   //Vertex Positioning
1873   ////////////////////
1874   vertexposition[0][0] = new TVector3();
1875   vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
1876                                                                           fgkCarbonFiberSupportYAxisLength);
1877   vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
1878                                                                           carbonfibersupportxaxisEdgeproj
1879                                            *                      TMath::Tan(theta));
1880   vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
1881                                            -                      carbonfibersupportxaxisEdgeproj,
1882                                                                           fgkCarbonFiberSupportYAxisLength
1883                                            -                      vertexposition[0][2]->Y());
1884   ////////////////////////////////////////////////////
1885   //Setting the parameters for Isometry Transformation
1886   ////////////////////////////////////////////////////
1887   Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
1888                                                                  +      fgkCarbonFiberSupportTopEdgeDist[0]
1889                                                                  +      fgkCarbonFiberSupportWidth);
1890   Double_t* param = new Double_t[4];
1891   param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
1892   for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
1893     new TVector3((GetReflection(vertexposition[0][j],param))->X(),
1894                  (GetReflection(vertexposition[0][j],param))->Y());
1895   const char* carbonfibersupportshapename[kshapesnumber] =
1896                                                 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
1897   const char* carbonfibersupportname[kshapesnumber] =
1898                                                 {"CarbonFiberSupport1","CarbonFiberSupport2"};
1899   TGeoArb8* carbonfibersupportshape[kshapesnumber];
1900   TGeoVolume* carbonfibersupport[kshapesnumber];
1901   TList* carbonfibersupportlist = new TList();
1902   Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
1903   Double_t carbonfibersupportheight =
1904           carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1905           *TMath::DegToRad());
1906   for(Int_t i = 0; i< kshapesnumber; i++){
1907    carbonfibersupportshape[i] =
1908                                         GetArbShape(vertexposition[i],width,carbonfibersupportheight,
1909                                                                 carbonfibersupportshapename[i],i==0 ? 1: -1);
1910    carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
1911                                                    carbonfibersupportshape[i],fSSDCarbonFiberMedium);
1912    carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
1913    carbonfibersupportlist->Add(carbonfibersupport[i]);
1914    }
1915   /////////////////////////////////////////////////////////////
1916   // Deallocating memory
1917   /////////////////////////////////////////////////////////////
1918   for(Int_t i=0; i< kshapesnumber; i++){
1919      for(Int_t j=0; j< kvertexnumber; j++)
1920            delete vertexposition[i][j];
1921        delete [] vertexposition[i];
1922   }
1923   delete [] param;
1924   /////////////////////////////////////////////////////////////
1925    return carbonfibersupportlist;
1926 }
1927 /////////////////////////////////////////////////////////////////////////////////
1928 TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
1929   /////////////////////////////////////////////////////////////
1930   // Method generating SSD Carbon Fiber Junction
1931   /////////////////////////////////////////////////////////////
1932   const Int_t kvertexnumber = 6;
1933   TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
1934   Double_t reflectionparam[4] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1935                                             *  TMath::DegToRad()),-1.,0.,0.};
1936   TVector3* vertex[kvertexnumber];
1937   vertex[0] = new TVector3();
1938   vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
1939                         *                         TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1940                         *                         TMath::DegToRad()),
1941                                                   fgkCarbonFiberJunctionEdge[0]
1942                         *                         TMath::Sin(fgkCarbonFiberJunctionAngle[0]
1943                         *                         TMath::DegToRad()));
1944   vertex[4] = new TVector3(fgkCarbonFiberJunctionLength,
1945                                                    fgkCarbonFiberJunctionEdge[1]);
1946   vertex[5] = new TVector3(fgkCarbonFiberJunctionLength);
1947   vertex[1] = GetReflection(vertex[5],reflectionparam);
1948   vertex[2] = GetReflection(vertex[4],reflectionparam);
1949   Double_t xvertexpoints[6], yvertexpoints[6];
1950   for(Int_t i=0; i<kvertexnumber; i++)
1951           xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
1952   carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
1953   carbonfiberjunctionshape->DefineSection(0,-0.5*width);
1954   carbonfiberjunctionshape->DefineSection(1,0.5*width);
1955   TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
1956                                                                 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
1957   carbonfiberjunction->SetLineColor(fColorCarbonFiber);
1958   /////////////////////////////////////////////////////////////
1959   // Deallocating memory
1960   /////////////////////////////////////////////////////////////
1961   for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
1962   /////////////////////////////////////////////////////////////
1963   return carbonfiberjunction;
1964 }
1965 ////////////////////////////////////////////////////////////////////////////////
1966 TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
1967   /////////////////////////////////////////////////////////////
1968   // Method generating the Carbon Fiber Lower Support
1969   /////////////////////////////////////////////////////////////
1970   const Int_t kvertexnumber = 4;
1971   const Int_t kshapesnumber = 2;
1972   Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
1973                                                                 fgkCarbonFiberLowerSupportWidth};
1974   TVector3** vertexposition[kshapesnumber];
1975   for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
1976                                                  new TVector3*[kvertexnumber];
1977   //First Shape Vertex Positioning
1978   vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
1979   vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
1980                                            -            fgkCarbonFiberLowerSupportLowerLenght);
1981   vertexposition[0][2] = new TVector3();
1982   vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
1983   //Second Shape Vertex Positioning
1984   Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
1985                                  -                              fgkCarbonFiberLowerSupportVolumePosition[0])
1986                                  /                              fgkCarbonFiberTriangleLength);
1987   vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
1988                                                                 vertexposition[0][0]->X()*TMath::Tan(theta)
1989                                  +                              fgkCarbonFiberLowerSupportVolumePosition[0]);
1990   vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
1991                                                                 vertexposition[0][1]->X()*TMath::Tan(theta)
1992                                  +                              fgkCarbonFiberLowerSupportVolumePosition[0]);
1993   vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
1994   vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
1995                                                                 fgkCarbonFiberLowerSupportVolumePosition[1]);
1996   const char* carbonfiberlowersupportshapename[kshapesnumber] =
1997                           {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
1998   const char* carbonfiberlowersupportname[kshapesnumber] =
1999                           {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
2000   TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
2001   TGeoVolume* carbonfiberlowersupport[kshapesnumber];
2002   TList* carbonfiberlowersupportlist = new TList();
2003   for(Int_t i = 0; i< kshapesnumber; i++){
2004         carbonfiberlowersupportshape[i] =
2005                                                                 GetArbShape(vertexposition[i],width,
2006                                                                                         fgkCarbonFiberLowerSupportHeight,
2007                                                                                         carbonfiberlowersupportshapename[i]);
2008     carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
2009                                                 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
2010         carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
2011     carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
2012   }
2013   /////////////////////////////////////////////////////////////
2014   // Deallocating memory
2015   /////////////////////////////////////////////////////////////
2016   for(Int_t i=0; i< kshapesnumber; i++){
2017      for(Int_t j=0; j< kvertexnumber; j++)
2018            delete vertexposition[i][j];
2019        delete [] vertexposition[i];
2020   }
2021   /////////////////////////////////////////////////////////////
2022   return carbonfiberlowersupportlist;
2023 }
2024 ///////////////////////////////////////////////////////////////////////////////
2025 TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
2026                                                                  Double_t width, Double_t* thickness)const{
2027   /////////////////////////////////////////////////////////////
2028   // Method generating the Sensor Support
2029   /////////////////////////////////////////////////////////////
2030         const Int_t kvertexnumber = 6;
2031         TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2032     TVector3* vertexposition[kvertexnumber];
2033         vertexposition[0] = new TVector3();
2034         vertexposition[1] = new TVector3(0.0,length);
2035         vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());
2036         vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);
2037         vertexposition[4] = new TVector3(height,vertexposition[3]->Y());
2038         vertexposition[5] = new TVector3(vertexposition[4]->X());
2039         Double_t xvertexpoints[6], yvertexpoints[6];
2040         for(Int_t i=0; i<kvertexnumber; i++)
2041                 xvertexpoints[i] = vertexposition[i]->X(),
2042                 yvertexpoints[i] = vertexposition[i]->Y();
2043     ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2044     ssdsensorsupportshape->DefineSection(0,-0.5*width);
2045     ssdsensorsupportshape->DefineSection(1,0.5*width);
2046     TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2047                                                                  ssdsensorsupportshape,fSSDSensorSupportMedium);
2048   /////////////////////////////////////////////////////////////
2049   // Deallocating memory
2050   /////////////////////////////////////////////////////////////
2051         for (Int_t i=0; i<kvertexnumber; i++)
2052                 delete vertexposition[i];
2053   /////////////////////////////////////////////////////////////
2054     return ssdsensorsupport;
2055 }
2056 ////////////////////////////////////////////////////////////////////////////////
2057 TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2058   /////////////////////////////////////////////////////////////
2059   // Method generating the Cooling Tube Support
2060   /////////////////////////////////////////////////////////////
2061   if(nedges%2!=0) nedges--;
2062   const Int_t kvertexnumber = nedges+5;
2063   Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2064                            /                     fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2065   Double_t angle = 90.+phi;
2066   Double_t psi = 90.-phi;
2067   ///////////////////////////////////////
2068   // Vertex Positioning for TGeoXTru
2069   ///////////////////////////////////////
2070   TVector3** vertexposition = new TVector3*[kvertexnumber];
2071
2072   Double_t Router = fgkCoolingTubeSupportRmin/CosD(phi/nedges);  //  Recalc inner radius so that tube fits inside
2073   vertexposition[0] = new TVector3(Router*CosD(angle),
2074                                                                    Router*SinD(angle));
2075   vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2076                                                                    fgkCoolingTubeSupportRmax*SinD(angle));
2077   vertexposition[2] = new TVector3(vertexposition[1]->X(),
2078                                                                    fgkCoolingTubeSupportRmax);
2079   vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2080                                                                    fgkCoolingTubeSupportRmax);
2081   vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2082                                                                     vertexposition[1]->Y());
2083
2084   for(Int_t i=0; i<nedges; i++)
2085         vertexposition[i+5] =
2086                 new TVector3(Router*CosD(psi+i*(2.*phi/nedges)),
2087                              Router*SinD(psi+i*(2.*phi/nedges)));
2088   ///////////////////////////////////////////////////////////////////////
2089   // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2090   ///////////////////////////////////////////////////////////////////////
2091   TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2092   Double_t* xvertexpoints = new Double_t[kvertexnumber];
2093   Double_t* yvertexpoints = new Double_t[kvertexnumber];
2094   for(Int_t i=0; i<kvertexnumber; i++){
2095         xvertexpoints[i] = vertexposition[i]->X();
2096         yvertexpoints[i] = vertexposition[i]->Y();
2097   }
2098   coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2099                                                                                         yvertexpoints);
2100   coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2101   coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2102   TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2103                                                                           coolingtubesupportarcshape,
2104                                                                                   fSSDTubeHolderMedium);
2105   coolingtubesupportarc->SetLineColor(fColorG10);
2106   //////////////////////////////////////////////////////////////////////////
2107   // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2108   //////////////////////////////////////////////////////////////////////////
2109   TGeoTubeSeg* coolingtubesupportsegshape =
2110                                                         new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2111                                                                                         fgkCoolingTubeSupportRmax,
2112                                                                                         0.5*fgkCoolingTubeSupportWidth,
2113                                                                                         phi,360-phi);
2114   TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2115                                                                                         coolingtubesupportsegshape,
2116                                                                                         fSSDTubeHolderMedium);
2117   coolingtubesupportseg->SetLineColor(fColorG10);
2118   //////////////////////////////////////////////////////////////////////////
2119   // TGeoBBox Volume definition for Cooling Tube Support Box Part
2120   //////////////////////////////////////////////////////////////////////////
2121   Double_t* boxorigin = new Double_t[3];
2122   Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2123   boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2124   TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2125                                                                                  0.5*fgkCoolingTubeSupportHeight,
2126                                                                                  0.5*fgkCoolingTubeSupportWidth,boxorigin);
2127   TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2128                                coolingtubesupportboxshape,fSSDTubeHolderMedium);
2129   coolingtubesupportbox->SetLineColor(fColorG10);
2130   //////////////////////////////////////////////////////////////////////////
2131   // Cooling Tube for Cooling Tube Support
2132   //////////////////////////////////////////////////////////////////////////
2133   TGeoXtru* coolingtubearcshape[2];
2134   coolingtubearcshape[0] = new TGeoXtru(2);
2135   Double_t* xvert = new Double_t[nedges+2];
2136   Double_t* yvert = new Double_t[nedges+2];
2137   Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2138   ////////////////////////////////////////
2139   // Positioning the vertices for TGeoXTru
2140   ////////////////////////////////////////
2141   xvert[0] = 0., yvert[0] = 0.;
2142   xvert[1] = vertexposition[0]->X()*ratio,  yvert[1] = vertexposition[0]->Y()*ratio;
2143   for(Int_t i=0; i< nedges; i++)
2144                 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2145                 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2146   ////////////////////////////////////////
2147   // Defining TGeoXTru PolyGone
2148   ////////////////////////////////////////
2149   coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2150   coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2151   coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2152   coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2153                 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2154   TGeoVolume* coolingtubearc[2];
2155   coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2156                                                                   coolingtubearcshape[0],fSSDCoolingTubeWater);
2157   coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2158                                                                   coolingtubearcshape[1],fSSDCoolingTubePhynox);
2159   coolingtubearc[0]->SetLineColor(fColorWater);
2160   coolingtubearc[1]->SetLineColor(fColorPhynox);
2161   ////////////////////////////////////////////
2162   // Defining TGeoTubeSeg Part of Cooling Tube
2163   ////////////////////////////////////////////
2164   TGeoTubeSeg* coolingtubesegshape[2];
2165   coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2166                                                         0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2167   coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2168                                                         0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2169   TGeoVolume* coolingtubeseg[2];
2170   coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2171                                                                  coolingtubesegshape[0],fSSDCoolingTubePhynox);
2172   coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2173                                                                  coolingtubesegshape[1],fSSDCoolingTubeWater);
2174   coolingtubeseg[0]->SetLineColor(fColorPhynox);
2175   coolingtubeseg[1]->SetLineColor(fColorWater);
2176   /////////////////////////////////////////////////////////////
2177   // Virtual Volume containing Cooling Tube Support
2178   /////////////////////////////////////////////////////////////
2179   TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2180   const Int_t kvirtualvertexnumber = 8;
2181   TVector3* virtualvertex[kvirtualvertexnumber];
2182    ////////////////////////////////////////
2183   // Positioning the vertices for TGeoXTru
2184   ////////////////////////////////////////
2185   virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax);
2186   virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
2187   virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
2188   virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
2189   virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
2190   virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
2191   virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
2192   virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
2193   Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2194   for(Int_t i=0; i< kvirtualvertexnumber; i++)
2195         xmothervertex[i] = virtualvertex[i]->X(),
2196         ymothervertex[i] = virtualvertex[i]->Y();
2197   ////////////////////////////////////////
2198   // Defining TGeoXTru PolyGone
2199   ////////////////////////////////////////
2200   virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2201                                                                                                                                          ymothervertex);
2202   virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2203   virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2204   /*TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2205     virtualCoolingTubeSupportShape,fSSDAir); */
2206   TGeoVolume* virtualcoolingtubesupport = new TGeoVolumeAssembly("CoolingTubeSupport");
2207
2208   ////////////////////////////////////////
2209   // Positioning Volumes in Virtual Volume
2210   ////////////////////////////////////////
2211   TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2212   coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2213   virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2214   virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2215   virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
2216   //virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2217   //virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2218   //virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2219   //virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
2220   /////////////////////////////////////////////////////////////
2221   // Deallocating memory
2222   /////////////////////////////////////////////////////////////
2223   delete [] vertexposition;
2224   delete [] xvertexpoints;
2225   delete [] yvertexpoints;
2226   delete [] xvert;
2227   delete [] yvert;
2228   for(Int_t i=0; i< kvirtualvertexnumber; i++)
2229         delete virtualvertex[i];
2230   /////////////////////////////////////////////////////////////
2231         return virtualcoolingtubesupport;
2232 }
2233 /////////////////////////////////////////////////////////////////////////////////
2234 TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2235   /////////////////////////////////////////////////////////////
2236   // Method generating List containing SSD Hybrid Components
2237   /////////////////////////////////////////////////////////////
2238   TList* ssdhybridlist = new TList();
2239   const Int_t kssdstiffenernumber = 2;
2240   Double_t ssdstiffenerseparation = fgkSSDSensorLength
2241                                                                   - 2.*fgkSSDModuleStiffenerPosition[1]
2242                                                                   -    fgkSSDStiffenerWidth;
2243   Double_t ssdchipcablesradius[kssdstiffenernumber];
2244   for(Int_t i=0; i<kssdstiffenernumber; i++)
2245           ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2246                                -  fgkSSDChipCablesHeight[0]
2247                                -  fgkSSDChipCablesHeight[1]);
2248   /////////////////////////////////////////////////////////////
2249   // Mother Volumes Containers
2250   /////////////////////////////////////////////////////////////
2251   const Int_t kmothernumber = 2;
2252   const Int_t kmothervertexnumber = 8;
2253   Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2254   Double_t ymothervertex[kmothernumber][kmothervertexnumber];
2255
2256   TGeoVolumeAssembly* ssdhybridassembly[kmothernumber];
2257   TGeoVolume* ssdhybridmother[kmothernumber][2];
2258
2259   TGeoRotation hybridmotherrotR(TGeoRotation("",-90.0,0.0,0.0)*TGeoRotation("",0.0,90.0,0.0)*TGeoRotation("",90.,180.,-90));
2260   TGeoRotation hybridmotherrotL(TGeoRotation("",180.,0.0,0.0)*hybridmotherrotR);
2261   TGeoRotation *hybridmotherrotInv = new TGeoRotation(hybridmotherrotR.Inverse());
2262
2263   const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2264   for(Int_t i=0; i<kmothernumber; i++){
2265     xmothervertex[i][0] = -0.5*fgkSSDStiffenerWidth;
2266     ymothervertex[i][0] = 0.5*fgkSSDStiffenerHeight;
2267     xmothervertex[i][1] = -0.5*fgkSSDStiffenerWidth;
2268     ymothervertex[i][1] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2269       -fgkSSDChipCablesHeight[i+2];
2270
2271     xmothervertex[i][2] = 0.5*(fgkSSDSensorLength-ssdstiffenerseparation); //0.5*fgkSSDStiffenerWidth;
2272     ymothervertex[i][2] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight -fgkSSDChipCablesHeight[i+2];
2273     xmothervertex[i][3] = xmothervertex[i][2];
2274     ymothervertex[i][3] = ymothervertex[i][2]+fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1];
2275
2276     xmothervertex[i][4] = xmothervertex[i][2]-0.4;
2277     ymothervertex[i][4] = ymothervertex[i][3];
2278     xmothervertex[i][5] = xmothervertex[i][4];
2279     ymothervertex[i][5] = ymothervertex[i][4]+2*ssdchipcablesradius[i];
2280
2281     xmothervertex[i][6] = 0.5*fgkSSDStiffenerWidth+ssdchipcablesradius[i]+0.3*fgkmm;
2282     ymothervertex[i][6] = ymothervertex[i][5];
2283
2284     xmothervertex[i][7] = xmothervertex[i][6];
2285     ymothervertex[i][7] = 0.5*fgkSSDStiffenerHeight;
2286     TGeoXtru *shape = new TGeoXtru(2);
2287     shape->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
2288     shape->DefineSection(0,-0.5*fgkSSDStiffenerLength);
2289     shape->DefineSection(1,0.5*fgkSSDStiffenerLength);
2290     ssdhybridmother[i][0] = new TGeoVolume(TString(ssdhybridmothername[i])+"L",shape,fSSDAir);
2291     ssdhybridmother[i][1] = new TGeoVolume(TString(ssdhybridmothername[i])+"R",shape,fSSDAir);
2292     ssdhybridassembly[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]);
2293    }
2294   /////////////////////////////////////////////////////////////
2295   // SSD Stiffener
2296   /////////////////////////////////////////////////////////////
2297   TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2298                                              0.5*fgkSSDStiffenerLength,
2299                                              0.5*(fgkSSDStiffenerWidth-fgkSSDTolerance),
2300                                              0.5*fgkSSDStiffenerHeight);
2301   TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2302                                             fSSDStiffenerMedium);
2303   ssdstiffener->SetLineColor(fColorStiffener);
2304
2305 ////////////////////////////
2306 // Capacitor 0603-2200 nF
2307 ///////////////////////////
2308   const Int_t knapacitor0603number = 5;
2309   TGeoBBox* capacitor0603mothershape =  new TGeoBBox("Capacitor0603MotherShape",
2310                                                0.5*fgkSSDCapacitor0603Length + fgkSSDCapacitor0603CapLength,
2311                                                0.5*fgkSSDCapacitor0603Width,
2312                                                0.5*fgkSSDCapacitor0603Height);
2313   TGeoVolume* capacitor0603mother = new TGeoVolume("Capacitor0603Mother",capacitor0603mothershape,
2314                                              fSSDAir);
2315
2316   TGeoBBox* capacitor0603shape =  new TGeoBBox("Capacitor0603Shape",
2317                                                0.5*fgkSSDCapacitor0603Length,
2318                                                0.5*fgkSSDCapacitor0603Width,
2319                                                0.5*fgkSSDCapacitor0603Height);
2320   TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
2321                                              fSSDStiffener0603CapacitorMedium);
2322   capacitor0603->SetLineColor(fColorAl);
2323   TGeoTranslation *cap0603trans = new TGeoTranslation(0.,0.,0.);
2324   capacitor0603mother->AddNode(capacitor0603,1,cap0603trans);
2325
2326   TGeoBBox* capacitor0603capshape =  new TGeoBBox("Capacitor0603CapShape",
2327                                                0.5*fgkSSDCapacitor0603CapLength,
2328                                                0.5*fgkSSDCapacitor0603Width,
2329                                                0.5*fgkSSDCapacitor0603Height);
2330   TGeoVolume* capacitor0603cap = new TGeoVolume("Capacitor0603Cap",capacitor0603capshape,
2331                                              fSSDStiffenerCapacitorCapMedium);
2332   capacitor0603cap->SetLineColor(fColorNiSn);
2333   TGeoTranslation *cap0603captrans1 = new TGeoTranslation(- capacitor0603shape->GetDX() - capacitor0603capshape->GetDX(),0.,0.);
2334   capacitor0603mother->AddNode(capacitor0603cap,1,cap0603captrans1);
2335   TGeoTranslation *cap0603captrans2 = new TGeoTranslation(capacitor0603shape->GetDX() + capacitor0603capshape->GetDX(),0.,0.);
2336   capacitor0603mother->AddNode(capacitor0603cap,2,cap0603captrans2);
2337
2338
2339   TGeoVolume* ssdchip = GetSSDChip();
2340
2341   const Int_t knedges = 5;
2342   TGeoVolume *ssdchipcables[2];
2343
2344   for(Int_t i=0; i<kmothernumber; i++){
2345     for(Int_t j=0; j<kssdstiffenernumber; j++){
2346       ssdhybridmother[i][j]->AddNode(ssdstiffener,1,hybridmotherrotInv);
2347       for(Int_t k=1; k<knapacitor0603number+1; k++){
2348         ssdhybridmother[i][j]->AddNode(capacitor0603mother,k,
2349                                        new TGeoCombiTrans("",
2350                                                           -0.5*(fgkSSDStiffenerWidth - fgkSSDCapacitor0603Width),
2351                                                           -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height),
2352                                                           (k-3.)/6*fgkSSDStiffenerLength,
2353                                                           hybridmotherrotInv));
2354       }
2355     }
2356
2357     GetSSDChipCables(ssdchipcables[0],ssdchipcables[1],fgkSSDChipCablesHeight[i+2],knedges);
2358     for(Int_t k=0; k<fgkSSDChipNumber; k++){
2359       TGeoTranslation *chipcabletrans = new TGeoTranslation("",0.5*fgkSSDStiffenerWidth-fgkSSDChipWidth,
2360                                                             - 0.5*fgkSSDStiffenerHeight - fgkSSDChipHeight
2361                                                             - fgkSSDChipCablesHeight[i+2],
2362                                                             (k+0.5-fgkSSDChipNumber/2)*
2363                                                             (fgkSSDChipLength + fgkSSDChipSeparationLength));
2364       TGeoCombiTrans *chiptrans = new TGeoCombiTrans("",0.5*(fgkSSDStiffenerWidth-fgkSSDChipWidth),
2365                                                      - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight),
2366                                                      (k+0.5-fgkSSDChipNumber/2)*(fgkSSDChipLength + fgkSSDChipSeparationLength),
2367                                                      hybridmotherrotInv);
2368       for(Int_t j=0; j<kssdstiffenernumber; j++){
2369         ssdhybridmother[i][j]->AddNode(ssdchipcables[j],k+1,chipcabletrans);
2370         ssdhybridmother[i][j]->AddNode(ssdchip,k+1,chiptrans);
2371       }
2372     }
2373     // Final placement by assembly
2374     ssdhybridassembly[i]->AddNode(ssdhybridmother[i][0],1,new TGeoCombiTrans(TGeoTranslation("",0,0,0),hybridmotherrotL));
2375     ssdhybridassembly[i]->AddNode(ssdhybridmother[i][1],1,new TGeoCombiTrans(TGeoTranslation("",0,ssdstiffenerseparation,0),hybridmotherrotR));
2376     ssdhybridlist->Add(ssdhybridassembly[i]);
2377   }
2378   /////////////////////////////////////////////////////////////
2379   // Mother Volume Containing Capacitor Part
2380   /////////////////////////////////////////////////////////////
2381   const Int_t kcapacitormothernumber = 8;
2382   Double_t xcapacitorvertex[kcapacitormothernumber];
2383   Double_t ycapacitorvertex[kcapacitormothernumber];
2384   ///////////////////////
2385   // Setting the vertices
2386   ///////////////////////
2387   xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2388   xcapacitorvertex[1] = xcapacitorvertex[0];
2389   xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2390   xcapacitorvertex[3] = xcapacitorvertex[2];
2391   xcapacitorvertex[4] = xcapacitorvertex[0];
2392   xcapacitorvertex[5] = xcapacitorvertex[0];
2393   xcapacitorvertex[6] = -xcapacitorvertex[0];
2394   xcapacitorvertex[7] = xcapacitorvertex[6];
2395   ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2396   ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2397   ycapacitorvertex[2] = ycapacitorvertex[1];
2398   ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2399   ycapacitorvertex[4] = ycapacitorvertex[3];
2400   ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2401   ycapacitorvertex[6] = ycapacitorvertex[5];
2402   ycapacitorvertex[7] = ycapacitorvertex[0];
2403   TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2404   ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2405                                               ycapacitorvertex);
2406   ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2407   ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
2408 //  TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2409 //                                          fSSDAir);
2410   TGeoVolumeAssembly* ssdhybridcapacitormother = new TGeoVolumeAssembly("SSDHybridCapacitorMother");
2411 ////////////////////////////
2412 // Connector
2413 ///////////////////////////
2414   const Int_t kssdconnectorlayernumber = 3;
2415   TGeoBBox* ssdconnectorshape[kssdconnectorlayernumber];
2416   Double_t ssdConnectorThickness[kssdconnectorlayernumber]={fgkSSDConnectorAlHeight,fgkSSDConnectorNiHeight,fgkSSDConnectorSnHeight};
2417   /*
2418   Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2419   Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2420                                    +  fgkSSDConnectorAlHeight};
2421   */
2422   Double_t ssdconnectororigin[3] = {0,0,0.5*fgkSSDStiffenerHeight};
2423   const char* ssdconnectorname[kssdconnectorlayernumber] = {"SSDConnectorAl","SSDConnectorNi","SSDConnectorSn"};
2424   TGeoMedium *ssdConnectorMedium[kssdconnectorlayernumber]={fSSDAlTraceFlexMedium,fSSDStiffenerConnectorMedium,fSSDSn};
2425   TGeoVolume* ssdconnector[kssdconnectorlayernumber];
2426   for(Int_t i=0; i<kssdconnectorlayernumber; i++){
2427     ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
2428       ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2429                                           0.5*fgkSSDConnectorWidth,
2430                                           0.5*ssdConnectorThickness[i],
2431                                           ssdconnectororigin);
2432       ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
2433       ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
2434                                        ssdConnectorMedium[i]);
2435       ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorNiSn);
2436   }
2437   const Int_t kssdconnectornumber = 4;
2438   TGeoTranslation* ssdconnectortrans[kssdconnectornumber];
2439   ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2440                        +  fgkSSDConnectorPosition[0]
2441                        -  fgkSSDConnectorSeparation
2442                        -  1.5*fgkSSDConnectorLength,
2443                           ssdstiffenerseparation+ssdstiffenershape->GetDY()
2444                        -  fgkSSDConnectorPosition[1]
2445                        -  ssdconnectorshape[0]->GetDY(),0.0);
2446   ssdconnectortrans[1] = new TGeoTranslation(
2447                        -  ssdstiffenershape->GetDX()
2448                        +  fgkSSDConnectorPosition[0]
2449                        -  0.5*fgkSSDConnectorLength,
2450                           ssdstiffenerseparation+ssdstiffenershape->GetDY()
2451                        -  fgkSSDConnectorPosition[1]
2452                        -  ssdconnectorshape[0]->GetDY(),0.0);
2453   ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2454                        -  fgkSSDConnectorPosition[0]
2455                        +  fgkSSDConnectorSeparation
2456                        +  1.5*fgkSSDConnectorLength,
2457                           -(ssdstiffenershape->GetDY()
2458                        -  fgkSSDConnectorPosition[1]
2459                        -  ssdconnectorshape[0]->GetDY()),0.0);
2460   ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2461                        -  fgkSSDConnectorPosition[0]
2462                        +  0.5*fgkSSDConnectorLength,
2463                           -(ssdstiffenershape->GetDY()
2464                        -  fgkSSDConnectorPosition[1]
2465                        -  ssdconnectorshape[0]->GetDY()),0.0);
2466   for(Int_t i=0; i<kssdconnectornumber; i++) {
2467     Int_t nlay = kssdconnectorlayernumber - 1;
2468     if (i == 1 || i == 2)
2469       nlay++;
2470     for(Int_t j=0; j<nlay; j++)
2471       ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2472   }
2473 ////////////////////////////
2474 // Capacitor 1812-330 nF
2475 ///////////////////////////
2476 //  Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
2477   TGeoBBox* capacitor1812shape =  new TGeoBBox("Capacitor1812Shape",
2478                                                                                          0.5*fgkSSDCapacitor1812Length,
2479                                                                                          0.5*fgkSSDCapacitor1812Width,
2480                                                0.5*fgkSSDCapacitor1812Height);
2481   //            ssdcapacitor1812origin);
2482   TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2483                                              fSSDStiffener1812CapacitorMedium);
2484   capacitor1812->SetLineColor(fColorAl);
2485   TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2486                                         0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2487                                       - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2488   ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
2489
2490   TGeoBBox* capacitor1812capshape =  new TGeoBBox("Capacitor1812CapShape",
2491     0.5*fgkSSDCapacitor1812CapLength, 0.5*fgkSSDCapacitor1812Width,
2492     0.5*fgkSSDCapacitor1812Height);
2493   TGeoVolume* capacitor1812cap = new TGeoVolume("Capacitor1812Cap",capacitor1812capshape,
2494                                              fSSDStiffenerCapacitorCapMedium);
2495   capacitor1812cap->SetLineColor(fColorNiSn);
2496   TGeoTranslation* capacitor1812captrans1 = new TGeoTranslation(
2497         - capacitor1812shape->GetDX() - capacitor1812capshape->GetDX(),
2498         0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2499         - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2500         0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2501   ssdhybridcapacitormother->AddNode(capacitor1812cap,1,capacitor1812captrans1);
2502   TGeoTranslation* capacitor1812captrans2 = new TGeoTranslation(
2503         capacitor1812shape->GetDX() + capacitor1812capshape->GetDX(),
2504         0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2505         - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2506         0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2507   ssdhybridcapacitormother->AddNode(capacitor1812cap,2,capacitor1812captrans2);
2508
2509 ////////////////////////////
2510 //Hybrid Wire
2511 ////////////////////////////
2512   Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
2513                                  - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2514                                  - fgkSSDConnectorSeparation;
2515   Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
2516                                  - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
2517   Double_t ssdwireradius = TMath::Sqrt(wirex*wirex+wirey*wirey);
2518
2519   Double_t wireangle = TMath::ATan(wirex/wirey);
2520   TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2521                                                 fgkSSDWireRadius, 0.5*ssdwireradius);
2522   TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2523                                              fSSDStiffenerHybridWireMedium);
2524   hybridwire->SetLineColor(fColorPhynox);
2525   TGeoCombiTrans* hybridwirecombitrans[2];
2526   hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
2527                    0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2528                                  + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
2529                    0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
2530                                  + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
2531                                    ssdstiffenershape->GetDZ()
2532                                  + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight+fgkSSDConnectorSnHeight,
2533                    new TGeoRotation("HybridWireRot1",0.,90.,0.));
2534   hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
2535                             0.0,
2536                           - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2537                             0.0,
2538                             new TGeoRotation("HybridWireRot2",
2539                           - wireangle*TMath::RadToDeg(),0.,0.));
2540   TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2541   hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2542   hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
2543   ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2544   ssdhybridlist->Add(ssdhybridcapacitormother);
2545   /////////////////////////////////////////////////////////////
2546   // Deallocating memory
2547   /////////////////////////////////////////////////////////////
2548   delete hybridwirecombitrans[0];
2549   delete hybridwirecombitrans[1];
2550   return ssdhybridlist;
2551   /////////////////////////////////////////////////////////////
2552 }
2553 ///////////////////////////////////////////////////////////////////////////////
2554 TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2555   /////////////////////////////////////////////////////////////
2556   // SSD Cooling Block System
2557   /////////////////////////////////////////////////////////////
2558   // SSD Cooling Block and Cooling Tube Transformations
2559   /////////////////////////////////////////////////////////////
2560   TGeoRotation* localcoolingblockrot = new TGeoRotation();
2561   localcoolingblockrot->SetAngles(0.,90.,0.);
2562   TGeoCombiTrans localcoolingblockmatrix(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
2563   TVector3* coolingblocktransvector;
2564   coolingblocktransvector = new TVector3(fgkCoolingTubeSeparation,
2565                                                                   fgkSSDSensorLength
2566                                                                 - 2.*fgkSSDModuleStiffenerPosition[1]
2567                                                                 - fgkSSDCoolingBlockWidth);
2568   const Int_t kcoolingblocktransnumber = 2;
2569   const Int_t kcoolingblocknumber = 4;
2570   TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
2571   TGeoRotation* localcoolingtuberot = new TGeoRotation();
2572   localcoolingtuberot->SetAngles(0.0,90.0,0.0);
2573   for(Int_t i=0; i<kcoolingblocktransnumber; i++){
2574     for(Int_t j=0; j<kcoolingblocktransnumber; j++){
2575       TGeoTranslation localcoolingblocktrans(i*coolingblocktransvector->X(),//+2*coolingtubedistance,
2576                                              j*coolingblocktransvector->Y(),
2577                                              - 0.5*(fgkSSDCoolingBlockHoleCenter
2578                                                     + fgkCoolingTubeRmax));
2579       coolingblockmatrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingblockmatrix);
2580     }
2581   }
2582   TGeoVolume* coolingsystemother = new TGeoVolumeAssembly("CoolingBlockSystem");
2583   TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2584   /////////////////////////////////////////////////////////////
2585   // Adding Cooling block to mother volume
2586   /////////////////////////////////////////////////////////////
2587   for(Int_t i=0; i<kcoolingblocknumber; i++){
2588     coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
2589   }
2590   /////////////////////////////////////////////////////////////
2591   // Deallocating memory
2592   /////////////////////////////////////////////////////////////
2593   delete coolingblocktransvector;
2594   delete localcoolingblockrot;
2595
2596   return coolingsystemother;
2597 }
2598 /////////////////////////////////////////////////////////////////////////////////
2599 TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
2600   /////////////////////////////////////////////////////////////
2601   // SSD Flex
2602   /////////////////////////////////////////////////////////////
2603   const Int_t kssdflexlayernumber = 2;
2604   TGeoXtru* ssdflexshape[kssdflexlayernumber];
2605   for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2606   const Int_t kmothervertexnumber = 17;
2607   Double_t xmothervertex[kmothervertexnumber];
2608   Double_t ymothervertex[kmothervertexnumber];
2609   /////////////////////////////////////////////
2610   // Auxiliary variables for vertex positioning
2611   /////////////////////////////////////////////
2612   const Int_t kssdflexboxnumber = 5;
2613   Double_t ssdflexboxlength[kssdflexboxnumber];
2614   ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
2615                                           *     fgkSSDChipLength+(fgkSSDChipNumber-1)
2616                                           *     fgkSSDChipSeparationLength
2617                                           - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2618                                           - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
2619   ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2620   ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
2621                                           -     fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
2622   ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2623   ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2624                                           -     ssdflexboxlength[1];
2625   Double_t ssdflexboxwidth[kssdflexboxnumber];
2626   ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2627   ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2628   ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2629   ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2630   ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
2631   ///////////////////////
2632   // Setting the vertices
2633   ///////////////////////
2634   xmothervertex[0]  = 0.0;
2635   xmothervertex[1]  = xmothervertex[0];
2636   xmothervertex[2]  = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2637   xmothervertex[3]  = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2638                                         + ssdflexboxlength[4];
2639   xmothervertex[4]  = xmothervertex[3];
2640   xmothervertex[5]  = xmothervertex[4]-ssdflexboxlength[4];
2641   xmothervertex[6]  = xmothervertex[5];
2642   xmothervertex[7]  = xmothervertex[6]-fgkSSDFlexHoleLength;
2643   xmothervertex[8]  = xmothervertex[7];
2644   xmothervertex[9]  = xmothervertex[8]-ssdflexboxlength[2];
2645   xmothervertex[10] = xmothervertex[9];
2646   xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2647   xmothervertex[12] = xmothervertex[11];
2648   xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2649   xmothervertex[14] = xmothervertex[13];
2650   xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2651   xmothervertex[16] = xmothervertex[15];
2652   ymothervertex[0]  = 0.0;
2653   ymothervertex[1]  = fgkSSDFlexWidth[1];
2654   ymothervertex[2]  = fgkSSDFlexWidth[0];
2655   ymothervertex[3]  = ymothervertex[2];
2656   ymothervertex[4]  = ymothervertex[0];
2657   ymothervertex[5]  = ymothervertex[4];
2658   ymothervertex[6]  = ssdflexboxwidth[2];
2659   ymothervertex[7]  = ymothervertex[6];
2660   ymothervertex[8]  = ymothervertex[0];
2661   ymothervertex[9]  = ymothervertex[8];
2662   ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2663   ymothervertex[11] = ymothervertex[10];
2664   ymothervertex[12] = ymothervertex[0];
2665   ymothervertex[13] = ymothervertex[12];
2666   ymothervertex[14] = ymothervertex[7];
2667   ymothervertex[15] = ymothervertex[14];
2668   ymothervertex[16] = ymothervertex[0];
2669   /////////////////////////////////////////////////////////////
2670   // First Mother Volume containing SSDFlex
2671   /////////////////////////////////////////////////////////////
2672   TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2673   ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2674                                                                     ymothervertex);
2675   ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2676   ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
2677   TGeoVolumeAssembly* ssdflexmother = new TGeoVolumeAssembly("SSDFlexMother");
2678 //  TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2679 //                                                                                       fSSDAir);
2680   /////////////////////////////////////////////////////////////
2681   // SSDFlex Layer Shapes
2682   /////////////////////////////////////////////////////////////
2683   for(Int_t i=0; i<kssdflexlayernumber; i++){
2684         ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2685                                                                    ymothervertex);
2686     ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2687         ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2688   }
2689   /////////////////////////////////////
2690   // Setting Layers into Mother Volume
2691   /////////////////////////////////////
2692   Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2693   TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2694                                                                                                  fSSDKaptonFlexMedium};
2695   const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2696                                                                                                         "AlFlexLay2","KaptonFlexLay2"};
2697   TGeoVolume* ssdflex[2*kssdflexlayernumber];
2698   TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2699   for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2700         ssdflex[i] = new TGeoVolume(ssdflexname[i],
2701                                                                 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2702                                                                 i%2==0 ? ssdflexmed[0]   : ssdflexmed[1]);
2703         ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2704     ssdflextrans[i]  = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2705                                          +                                         fgkSSDFlexHeight[1]));
2706     ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2707   }
2708   return ssdflexmother;
2709 }
2710 /////////////////////////////////////////////////////////////////////////////////
2711 TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
2712   /////////////////////////////////////////////////////////////
2713   // Method generating SSD End Flex
2714   /////////////////////////////////////////
2715   Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2716                                                         /  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2717   Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2718                                                 * TMath::DegToRad()*ssdflexradiusmax
2719                                                 - fgkSSDFlexLength[2]-TMath::Pi()
2720                                                 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
2721                                                         - 0.1*fgkSSDFlexFullLength;
2722   const Int_t knedges = 20;
2723   const Int_t karcnumber = 2;
2724   TVector3* vertexposition[karcnumber*(knedges+1)];
2725   Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2726   Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2727   Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2728   Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2729                                                                                  - 90.0*TMath::DegToRad()};
2730   TVector3* referencetrans[karcnumber];
2731   referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2732                                         +                          radius[0]*SinD(2.*fgkSSDFlexAngle),
2733                                                                    radius[0]);
2734   referencetrans[1] = new TVector3(referencetrans[0]->X()
2735                                         +              fgkSSDFlexLength[2],
2736      -              fgkSSDStiffenerHeight);
2737 for(Int_t i=0; i<karcnumber; i++){
2738         for(Int_t j=0; j<knedges+1; j++){
2739                 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2740                                                                                                radius[i]*SinD(angle[i]));
2741                 angle[i] +=  deltangle[i]*(1.0-2.0*i);
2742         }
2743   }
2744   ///////////////////////
2745   // Setting the vertices
2746   ///////////////////////
2747   const Int_t kendflexlayernumber = 4;
2748   const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2749   TVector3** vertex[kendflexlayernumber];
2750   for(Int_t i=0; i<kendflexlayernumber; i++)
2751                                         vertex[i] = new TVector3*[kendflexvertexnumber];
2752   TVector3* transvector[kendflexlayernumber+1];
2753   TVector3* deltatransvector = new TVector3();
2754   for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2755   transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2756                                 +                radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2757   for(Int_t i=1; i<kendflexlayernumber+1; i++){
2758         deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2759                                         *                 CosD(fgkSSDFlexAngle),
2760                                                           (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2761                                         *         SinD(fgkSSDFlexAngle),0.0);
2762         *transvector[i] = *transvector[i-1]+*deltatransvector;
2763   }
2764   Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2765   ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2766   for(Int_t i=0; i<karcnumber; i++){
2767         for(Int_t j=1; j<kendflexlayernumber+1; j++){
2768                 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2769                                                   * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2770                                               /radius[i];
2771         }
2772   }
2773   for(Int_t i=0; i<kendflexlayernumber; i++){
2774         vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
2775         vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
2776         for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2777                 if(j<(knedges+1)){
2778                         vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2779                                                                                   vertexposition[j]->Y()*ratioradius[0][i+1]);
2780                         vertex[i][j+2]->RotateZ(referenceangle[0]);
2781                         *vertex[i][j+2] += *referencetrans[0];
2782                         vertex[i][4*(knedges+1)-j+1] =
2783                                                          new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2784                                                                                   vertexposition[j]->Y()*ratioradius[0][i]);
2785                         vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2786                         *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2787                 }
2788                 else{
2789
2790                         vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2791                                                                                   vertexposition[j]->Y()*ratioradius[1][i+1]);
2792                         vertex[i][j+2]->RotateZ(referenceangle[1]);
2793                         *vertex[i][j+2] += *referencetrans[1];
2794                         vertex[i][4*(knedges+1)-j+1] =
2795                                                          new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2796                                                                                   vertexposition[j]->Y()*ratioradius[1][i]);
2797                         vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2798                         *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2799            }
2800         }
2801   }
2802   /////////////////////////////////////////////////////////////
2803   // First Mother Volume containing SSDEndFlex
2804   /////////////////////////////////////////////////////////////
2805   TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2806   Double_t xmothervertex[kendflexvertexnumber];
2807   Double_t ymothervertex[kendflexvertexnumber];
2808   xmothervertex[0] = vertex[0][0]->X();
2809   ymothervertex[0] = vertex[0][0]->Y();
2810   for(Int_t i=1; i<kendflexvertexnumber; i++){
2811         if(i<2*(knedges+1)+2){
2812                 xmothervertex[i] = vertex[3][i]->X();
2813                 ymothervertex[i] = vertex[3][i]->Y();
2814         }
2815         else{
2816                 xmothervertex[i] = vertex[0][i]->X();
2817                 ymothervertex[i] = vertex[0][i]->Y();
2818         }
2819   }
2820   ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2821                                                                            xmothervertex,ymothervertex);
2822   ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2823   ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2824 //  TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2825 //                                                               ssdendflexmothershape,fSSDAir);
2826   TGeoVolumeAssembly* ssdendflexmother = new TGeoVolumeAssembly("SSDEndFlexMother");
2827   //////////////////////////////////////
2828   // End Flex TGeoXtru Layer Definition
2829   //////////////////////////////////////
2830   TGeoXtru* ssdendflexshape[kendflexlayernumber];
2831   TGeoVolume* ssdendflex[kendflexlayernumber];
2832   for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2833   Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2834   Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2835   Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2836   TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2837                                                                                                         fSSDKaptonFlexMedium};
2838   const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2839                                                                                                          "AlEndFlexLay2","KaptonEndFlexLay2"};
2840   for(Int_t i=0; i<kendflexlayernumber; i++){
2841         for(Int_t j=0; j<4*(knedges+1)+2; j++){
2842                 xvertex[i][j] = vertex[i][j]->X();
2843                 yvertex[i][j] = vertex[i][j]->Y();
2844         }
2845   ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2846   ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2847   ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2848   ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2849                                                                  i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2850   ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2851   ssdendflexmother->AddNode(ssdendflex[i],1);
2852   }
2853   /////////////////////////////////////////////////////////////
2854   // Deallocating memory
2855   /////////////////////////////////////////////////////////////
2856   for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2857   for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2858   for(Int_t i=0; i<kendflexlayernumber; i++){
2859         for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2860         delete [] vertex[i];
2861   }
2862   for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2863   delete deltatransvector;
2864   /////////////////////////////////////////////////////////////
2865   //ssdendflexmother->CheckOverlaps(0.01);
2866   return ssdendflexmother;
2867 }
2868 ///////////////////////////////////////////////////////////////////////////////
2869 TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
2870   /////////////////////////////////////////////////////////////
2871   // Method generating the Mounting Block
2872   /////////////////////////////////////////////////////////////
2873   const Int_t kvertexnumber = 8;
2874   Double_t xvertex[kvertexnumber];
2875   Double_t yvertex[kvertexnumber];
2876   xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2877   xvertex[1] = xvertex[0];
2878   xvertex[2] = -xvertex[0];
2879   xvertex[3] = xvertex[2];
2880   xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2881                          -                                 fgkSSDMountingBlockLength[2]);
2882   xvertex[5] = xvertex[4];
2883   xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2884                          - 0.5*fgkSSDMountingBlockScrewHoleEdge
2885                          -     fgkSSDMountingBlockScrewHoleRadius[0];
2886   xvertex[7] = xvertex[6];
2887   yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
2888                          +      fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
2889   yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2890   yvertex[2] = yvertex[1];
2891   yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2892   yvertex[4] = yvertex[3];
2893   yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2894                          - fgkSSDMountingBlockHeight[0];
2895   yvertex[6] = yvertex[5];
2896   yvertex[7] = yvertex[0];
2897
2898   ///////////////////////////////////////////////////////////////////////
2899   // TGeoXTru Volume definition for Mounting Block Part
2900   ///////////////////////////////////////////////////////////////////////
2901   TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2902   ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2903   ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2904   ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
2905   TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
2906                                                                           ssdmountingblockshape,
2907                                                                                   fSSDMountingBlockMedium);
2908   ssdmountingblock->SetLineColor(fColorG10);
2909   TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
2910   mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
2911   TGeoRotation* mountingblockrot = new TGeoRotation();
2912   mountingblockrot->SetAngles(90.,180.,-90.);
2913   mountingblockcombitrans->SetRotation(*mountingblockrot);
2914   /////////////////////////////////////////////////////////////
2915   // Generating the Mounting Block Screw Vertices
2916   /////////////////////////////////////////////////////////////
2917   const Int_t kscrewvertexnumber = 15;
2918   Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
2919                                  -                                      fgkSSDMountingBlockScrewHoleEdge)
2920                                  /                              fgkSSDMountingBlockScrewHoleRadius[0])
2921                                  * TMath::RadToDeg();
2922   Double_t phi0 = 90.+alpha;
2923   Double_t phi = 270.-2*alpha;
2924   Double_t deltaphi = phi/kscrewvertexnumber;
2925   TVector3* screwvertex[kscrewvertexnumber+1];
2926   for(Int_t i=0; i<kscrewvertexnumber+1; i++)
2927         screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
2928                                    *CosD(phi0+i*deltaphi),
2929                                    fgkSSDMountingBlockScrewHoleRadius[0]
2930                                    *SinD(phi0+i*deltaphi));
2931   Double_t xscrewvertex[kscrewvertexnumber+6];
2932   Double_t yscrewvertex[kscrewvertexnumber+6];
2933   xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
2934   yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
2935                                   -               fgkSSDMountingBlockScrewHoleEdge);
2936   xscrewvertex[1] = xscrewvertex[0];
2937   yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2938   xscrewvertex[2] = screwvertex[0]->X();
2939   yscrewvertex[2] = yscrewvertex[1];
2940   for(Int_t i=0; i<kscrewvertexnumber+1; i++){
2941         xscrewvertex[i+3] = screwvertex[i]->X();
2942         yscrewvertex[i+3] = screwvertex[i]->Y();
2943   }
2944   xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2945   yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
2946   xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
2947   yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
2948   TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
2949   ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
2950   ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
2951   ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
2952                                                         +                                  fgkSSDMountingBlockHeight[2]);
2953   TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
2954                                                                                 ssdmountingblockscrewshape,
2955                                                                                             fSSDMountingBlockMedium);
2956   ssdmountingblockscrew->SetLineColor(fColorG10);
2957   TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
2958   for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
2959   ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2960                                                                         -                                yscrewvertex[1],
2961                                                                                                          0.5*fgkSSDMountingBlockHeight[0]
2962                                                                         -                                fgkSSDMountingBlockHeight[2]
2963                                                                         +                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2964                                                                         +                                fgkSSDMountingBlockHeight[2]
2965                                                                         -                                yvertex[0]));
2966   ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2967                                                                                                         -0.5*fgkSSDMountingBlockScrewHoleEdge,
2968                                                                                                                  yscrewvertex[1]
2969                                                                                                         -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2970                                                                                                          +fgkSSDMountingBlockHeight[2]
2971                                                                                                          -yvertex[0]));
2972   ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2973                                                                                                           yscrewvertex[1],
2974                                                                         -                                 0.5*fgkSSDMountingBlockHeight[0]
2975                                                                         +                                 fgkSSDMountingBlockHeight[2]
2976                                                                         -                                 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2977                                                                         +                                 fgkSSDMountingBlockHeight[2]
2978                                                                         -                                 yvertex[0]));
2979   ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2980                                                                                                          yscrewvertex[1],
2981                                                                         -                                yscrewvertex[1]
2982                                                                         +                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2983                                                                         +                                fgkSSDMountingBlockHeight[2]
2984                                                                         -                                yvertex[0]));
2985   TGeoRotation* ssdmountingblockscrewrot[4];
2986   for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
2987         ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
2988     ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
2989     ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
2990   for(Int_t i=1; i<4; i++)
2991         ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
2992   TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
2993   ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
2994   TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
2995   ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
2996                                                          +                                xvertex[0],yscrewvertex[1]
2997                                                          -                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2998                                                          +                                fgkSSDMountingBlockHeight[2]
2999                                                          -                                yvertex[0]),0.);
3000   TGeoHMatrix* ssdmountingblockscrewmatrix[4];
3001   for(Int_t i=0; i<4; i++){
3002         ssdmountingblockscrewmatrix[i] =
3003                 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
3004         ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
3005   }
3006   ///////////////////////////////////////////////////////////////////////
3007   // TGeoXtru for Mother Volume
3008   ///////////////////////////////////////////////////////////////////////
3009   const Int_t kvertexmothernumber = 12;
3010   Double_t xmothervertex[kvertexmothernumber];
3011   Double_t ymothervertex[kvertexmothernumber];
3012   for(Int_t i=0; i<6; i++){
3013         xmothervertex[i] = xvertex[i];
3014         ymothervertex[i] = yvertex[i];
3015   }
3016   xmothervertex[6]  = xvertex[5]+fgkSSDMountingBlockLength[2];
3017   ymothervertex[6]  = ymothervertex[5];
3018   xmothervertex[7]  = xmothervertex[6];
3019   ymothervertex[7]  = ymothervertex[4];
3020   xmothervertex[8]  = xmothervertex[7]
3021                                         + 0.5*(fgkSSDMountingBlockLength[1]
3022                                         -          fgkSSDMountingBlockLength[2]);
3023   ymothervertex[8]  = ymothervertex[4];
3024   xmothervertex[9]  = xmothervertex[8];
3025   ymothervertex[9]  = ymothervertex[2];
3026   xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
3027   ymothervertex[10] = ymothervertex[1];
3028   xmothervertex[11] = xmothervertex[10];
3029   ymothervertex[11] = ymothervertex[0];
3030   TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3031   ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3032   ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3033   ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3034   TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3035                                                                           ssdmountingblockmothershape,
3036                                                                                   fSSDAir);
3037   /////////////////////////////////////////////////////////////
3038   // Placing the Volumes into Mother Volume
3039   /////////////////////////////////////////////////////////////
3040   ssdmountingblockmother->AddNode(ssdmountingblock,1);
3041   ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3042   for(Int_t i=0; i<4; i++)
3043         ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3044                                                                         ssdmountingblockscrewmatrix[i]);
3045   /////////////////////////////////////////////////////////////
3046   // Deallocating memory
3047   /////////////////////////////////////////////////////////////
3048   delete mountingblockrot;
3049   for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3050   delete ssdmountingblockglobalrot;
3051   delete ssdmountingblockglobaltrans;
3052   /////////////////////////////////////////////////////////////
3053   return ssdmountingblockmother;
3054 }
3055 ///////////////////////////////////////////////////////////////////////////////
3056  TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3057   /////////////////////////////////////////////////////////////
3058   // Method generating the Mounting Block Clip
3059   /////////////////////////////////////////////////////////////
3060   const Int_t kmothervertexnumber = 10;
3061   Double_t xmothervertex[kmothervertexnumber];
3062   Double_t ymothervertex[kmothervertexnumber];
3063   xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3064                                    - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3065   xmothervertex[1] = xmothervertex[0];
3066   xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3067                                    - fgkMountingBlockClibScrewRadius);
3068   xmothervertex[3] = xmothervertex[2];
3069   xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3070   xmothervertex[5] = xmothervertex[4];
3071   xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3072   xmothervertex[7] = xmothervertex[6];
3073   xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3074   xmothervertex[9] = xmothervertex[8];
3075   ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
3076                                + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
3077   ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3078   ymothervertex[2] = ymothervertex[1];
3079   ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3080                                    - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3081                                    - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3082   ymothervertex[4] = ymothervertex[3];
3083   ymothervertex[5] = ymothervertex[2];
3084   ymothervertex[6] = ymothervertex[5];
3085   ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3086   ymothervertex[8] = ymothervertex[7];
3087   ymothervertex[9] = ymothervertex[0];
3088
3089   ///////////////////////////////////////////////////////////////////////
3090   // TGeoXTru Volume definition for Mounting Block Clip Part
3091   ///////////////////////////////////////////////////////////////////////
3092   TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3093   ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3094   ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3095   ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3096   TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3097                                                                           ssdmountingblockclipshape,fSSDAir);
3098   ssdmountingblockclip->SetLineColor(4);
3099   ///////////////////////////////////////////////////////////////////////
3100   // TGeoXTru Volume definition for Clip
3101   ///////////////////////////////////////////////////////////////////////
3102   const Int_t kclipvertexnumber = 6;
3103   Double_t xclipvertex[kclipvertexnumber];
3104   Double_t yclipvertex[kclipvertexnumber];
3105   xclipvertex[0] = xmothervertex[0];
3106   xclipvertex[1] = xclipvertex[0];
3107   xclipvertex[2] = xmothervertex[6];
3108   xclipvertex[3] = xclipvertex[2];
3109   xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3110   xclipvertex[5] = xclipvertex[4];
3111   yclipvertex[0] = ymothervertex[0];
3112   yclipvertex[1] = ymothervertex[1];
3113   yclipvertex[2] = yclipvertex[1];
3114   yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3115   yclipvertex[4] = yclipvertex[3];
3116   yclipvertex[5] = yclipvertex[0];
3117   TGeoXtru* clipshape = new TGeoXtru(2);
3118   clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3119   clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3120   clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3121                                                          +   fgkMountingBlockClibWidth);
3122   TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3123   clip->SetLineColor(18);
3124   ///////////////////////////////////////////////////////////////////////
3125   // Ladder Support Piece
3126   ///////////////////////////////////////////////////////////////////////
3127   const Int_t ksupportvertexnumber = 4;
3128   Double_t xsupportvertex[ksupportvertexnumber];
3129   Double_t ysupportvertex[ksupportvertexnumber];
3130   xsupportvertex[0] = xclipvertex[5];
3131   xsupportvertex[1] = xsupportvertex[0];
3132   xsupportvertex[2] = xmothervertex[9];
3133   xsupportvertex[3] = xsupportvertex[2];
3134   ysupportvertex[0] = yclipvertex[0];
3135   ysupportvertex[1] = yclipvertex[3];
3136   ysupportvertex[2] = ysupportvertex[1];
3137   ysupportvertex[3] = ysupportvertex[0];
3138   TGeoXtru* supportshape = new TGeoXtru(2);
3139   supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3140   supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3141   supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3142   TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3143   support->SetLineColor(9);
3144   ///////////////////////////////////////////////////////////////////////
3145   // TGeoXTru Volume definition for Screw
3146   ///////////////////////////////////////////////////////////////////////
3147   Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3148                                                 0.5*fgkMountingBlockClibScrewRadius};
3149   Int_t edgesnumber[2] = {50,6};
3150   Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3151                                                  +0.5*(ymothervertex[3]-ymothervertex[2])};
3152   TGeoShape* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
3153   TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3154   clipscrew->SetLineColor(12);
3155   TGeoRotation* screwrot = new TGeoRotation();
3156   screwrot->SetAngles(0.,90.,0.);
3157   TGeoTranslation* screwtrans = new TGeoTranslation();
3158   screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3159                                                          0.5*(ymothervertex[3]+ymothervertex[2]),
3160                                                          0.5*fgkSSDMountingBlockWidth+
3161                                                         -0.5*fgkMountingBlockSupportWidth[0]);
3162   TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3163   ///////////////////////////////////////////////////////////////////////
3164   // Placing the Volumes
3165   ///////////////////////////////////////////////////////////////////////
3166   ssdmountingblockclip->AddNode(clip,1);
3167   ssdmountingblockclip->AddNode(support,1);
3168   ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3169   /////////////////////////////////////////////////////////////
3170   // Deallocating memory
3171   /////////////////////////////////////////////////////////////
3172   delete screwtrans;
3173   delete screwrot;
3174   /////////////////////////////////////////////////////////////
3175   return ssdmountingblockclip;
3176 }
3177 ///////////////////////////////////////////////////////////////////////////////
3178 void AliITSv11GeometrySSD::CreateCoolingTubes() {
3179   /////////////////////////////////////////////////////////////
3180   // Method generating the Cooling Tube
3181   // sets fcoolingtube and returns list for endladdercoolingtube
3182   /////////////////////////////////////////////////////////////
3183   TGeoTube *coolingtubeshape[2];
3184   // Ladder Cooling Tubes
3185
3186   // MvL: Simplified cooling tubes
3187   coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,0.5*fgkCoolingTubeLength);
3188   coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,coolingtubeshape[0]->GetDz());
3189
3190   // End Ladder Cooling Tubes
3191   TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3192   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3193     endladdercoolingtubeshape[i] = new  TGeoTube*[2];
3194
3195   Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
3196   endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3197                                                  0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0] - sensZshift));
3198   endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3199                                                  endladdercoolingtubeshape[0][0]->GetDz());
3200   endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3201                                                  0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1] + sensZshift));
3202   endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3203                                                  endladdercoolingtubeshape[1][0]->GetDz()-0.5*fgkSSDTolerance);
3204   // Ladder Cooling Tubes
3205   TGeoVolume* coolingtube[2];
3206   coolingtube[0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0], fSSDCoolingTubePhynox);
3207   coolingtube[1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[1], fSSDCoolingTubeWater);
3208   coolingtube[0]->SetLineColor(fColorPhynox);
3209   coolingtube[1]->SetLineColor(fColorWater);
3210
3211   // End Ladder Cooling Tubes
3212   TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3213   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3214     endladdercoolingtube[i] = new TGeoVolume*[2];
3215   endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3216                                               endladdercoolingtubeshape[0][0],
3217                                               fSSDCoolingTubePhynox);
3218   endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3219                                               endladdercoolingtubeshape[0][1],
3220                                               fSSDCoolingTubeWater);
3221   endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3222                                               endladdercoolingtubeshape[1][0],
3223                                               fSSDCoolingTubePhynox);
3224   endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3225                                               endladdercoolingtubeshape[1][1],
3226                                               fSSDCoolingTubeWater);
3227   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3228     endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3229     endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3230   }
3231
3232   /////////////////////////////////////////////////////////////
3233   // Virtual Volume containing Cooling Tubes
3234   /////////////////////////////////////////////////////////////
3235   // Ladder Cooling Tubes
3236   TGeoTube* virtualcoolingtubeshape = new TGeoTube(coolingtubeshape[1]->GetRmin(),
3237                                                    coolingtubeshape[0]->GetRmax(),
3238                                                    coolingtubeshape[0]->GetDz());
3239   fcoolingtube = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape, fSSDAir);
3240   fcoolingtube->AddNode(coolingtube[0],1);
3241   fcoolingtube->AddNode(coolingtube[1],1);
3242
3243   // End Ladder Cooling Tubes
3244   TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3245   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3246     endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3247                                                        endladdercoolingtubeshape[i][0]->GetRmax(),
3248                                                        endladdercoolingtubeshape[i][0]->GetDz());
3249   fendladdercoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3250                                             endladdervirtualcoolingtubeshape[0],
3251                                             fSSDAir);
3252   fendladdercoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3253                                             endladdervirtualcoolingtubeshape[1],
3254                                             fSSDAir);
3255   fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3256   fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3257   fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3258   fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
3259 }
3260 ///////////////////////////////////////////////////////////////////////////////
3261 TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
3262   /////////////////////////////////////////////////////////////
3263   // Method generating SSD Cooling Block
3264   /////////////////////////////////////////////////////////////
3265   const Int_t kvertexnumber = 8;
3266   ///////////////////////////////////////
3267   // Vertex Positioning for TGeoXTru
3268   ///////////////////////////////////////
3269   TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3270   vertexposition[0] = new TVector3(0.0,0.0);
3271   vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]);
3272   vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3273                                           vertexposition[1]->Y());
3274   vertexposition[3] = new TVector3(vertexposition[2]->X(),
3275                                           vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]);
3276   vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y());
3277   vertexposition[5] = new TVector3(vertexposition[4]->X(),
3278                                         + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]);
3279   vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3280                                           vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3281                                         - fgkSSDCoolingBlockHoleLength[0]
3282                                         - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3283                                           fgkSSDCoolingBlockHeight[0]
3284                                         - fgkSSDCoolingBlockHoleRadius[1],
3285                                           fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]);
3286   vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3287                                         - fgkSSDCoolingBlockHoleLength[0]),
3288                                           vertexposition[6]->Y());
3289   Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3290                            / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3291   Double_t phi = 180.-alpha;
3292   Double_t psi = 180.+2.*alpha;
3293   Double_t deltapsi = psi/nedges;
3294   Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3295   TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3296                                                   fgkSSDCoolingBlockHoleCenter);
3297   for(Int_t i=0; i<nedges+1; i++){
3298         vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3299                                                                                                radius*SinD(phi+i*deltapsi));
3300    *vertexposition[kvertexnumber+i] += (*transvector);
3301   }
3302   Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3303   for(Int_t i=0; i<kvertexnumber; i++)
3304     vertexposition[kvertexnumber+nedges+1+i] =
3305                                                 GetReflection(vertexposition[kvertexnumber-1-i],param);
3306   ///////////////////////////////////////////////////////////////////////
3307   // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3308   ///////////////////////////////////////////////////////////////////////
3309   TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3310   Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3311   Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3312   for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3313         xvertexpoints[i] = vertexposition[i]->X();
3314         yvertexpoints[i] = vertexposition[i]->Y();
3315   }
3316   ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3317                                                                                         yvertexpoints);
3318   ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3319   ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3320   TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3321                                                                           ssdcoolingblockshape,
3322                                                                                   fSSDAlCoolBlockMedium);
3323   ssdcoolingblock->SetLineColor(fColorAl);
3324   /////////////////////////////////////////////////////////////
3325   // Deallocating memory
3326   /////////////////////////////////////////////////////////////
3327   delete [] vertexposition;
3328   delete [] xvertexpoints;
3329   delete [] yvertexpoints;
3330   /////////////////////////////////////////////////////////////
3331   return ssdcoolingblock;
3332 }
3333 /////////////////////////////////////////////////////////////////////////////////
3334 void AliITSv11GeometrySSD::GetSSDChipCables(TGeoVolume *&cableL, TGeoVolume *&cableR, Double_t SSDChipCablesHeight, Int_t nedges){
3335   ///////////////////////////////////////////////////////
3336   static const Int_t kssdchipcablesnumber    = 2;  // Number of cables: left and right
3337   static const Int_t kssdchipcableslaynumber = 2;  // Number of layers: Al and Kapton
3338   static const Int_t kvertexnumber                        = 4*(nedges+1)+4;
3339   Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3340   Double_t ssdchipcablesradius[kssdchipcableslaynumber];
3341   ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeight
3342                                                  -  fgkSSDChipCablesHeight[0]
3343                                                  -  fgkSSDChipCablesHeight[1]);
3344   ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3345   Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3346   ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3347                                                           - 2.*TMath::Pi()*ssdchipcablesradius[0]
3348                                                           - ssdchipcablesradius[0]
3349                                                           - fgkSSDChipCablesWidth[1]
3350                                                           - fgkSSDChipCablesWidth[2]);
3351   ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3352                                                           - 0.5*(fgkSSDModuleStiffenerPosition[1]
3353                                                           +      fgkSSDChipCablesHeight[1]
3354                                                           +      fgkSSDSensorHeight);
3355   ///////////////////////////////////////////////////////
3356   // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3357   ///////////////////////////////////////////////////////
3358   TVector3** vertexposition[kssdchipcableslaynumber];
3359   for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3360                                                                                                   new TVector3*[4*(nedges+1)+4];
3361   Double_t ratio[4];
3362   ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3363   ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3364                    /  ssdchipcablesradius[0];
3365   ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3366                    /  ssdchipcablesradius[0];
3367   ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3368                    +  fgkSSDChipCablesHeight[1])
3369                    /  ssdchipcablesradius[0];
3370   Double_t phi = 180.;
3371   Double_t deltaphi = 180./nedges;
3372   Double_t angle = 0.0;
3373   Double_t **xvertexpoints = new Double_t*[kssdchipcableslaynumber];
3374   Double_t **yvertexpoints = new Double_t*[kssdchipcableslaynumber];
3375   for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3376         xvertexpoints[i] = new Double_t[kvertexnumber];
3377         yvertexpoints[i] = new Double_t[kvertexnumber];
3378   }
3379   TVector3* vertex = new TVector3();
3380   TVector3* transvector[kssdchipcableslaynumber];
3381   transvector[0] = new TVector3(fgkSSDChipWidth,
3382                                                                 SSDChipCablesHeight-ssdchipcablesradius[0]);
3383   transvector[1] = new TVector3();
3384   TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcablesnumber];
3385   TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcablesnumber];
3386   const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcablesnumber] =
3387                 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3388                  "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3389   for(Int_t k=0; k<kssdchipcablesnumber; k++){
3390         transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3391         transvector[1]->SetY(ssdchipcablesradius[0]
3392                                  +               fgkSSDChipCablesHeight[0]
3393                                  +               fgkSSDChipCablesHeight[1]);
3394         for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3395                 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeight
3396                                                          - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
3397                 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeight
3398                                                          - i*fgkSSDChipCablesHeight[0]);
3399                 vertexposition[i][2*(nedges+1)+2] =
3400                                         new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3401                                 +                                fgkSSDChipCablesWidth[1]
3402                                 +                                fgkSSDChipCablesWidth[2],
3403                                                                 ((1.-i)*fgkSSDChipCablesHeight[i]
3404                                 +                                fgkSSDChipCablesHeight[1]));
3405         vertexposition[i][2*(nedges+1)+3] =
3406                                         new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3407                                                                  vertexposition[i][2*(nedges+1)+2]->Y()
3408                                 -                                fgkSSDChipCablesHeight[i]);
3409             for(Int_t j=0; j<nedges+1; j++){
3410                     angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3411                         vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3412                         vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3413                         vertexposition[0][(nedges+1)*i+j+2] =
3414                                                 new TVector3(*vertex+*transvector[i]);
3415                         vertexposition[1][(nedges+1)*i+j+2] =
3416                                                 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3417                                                                          vertex->Y()*ratio[2*i]+transvector[i]->Y());
3418                         vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3419                                                 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3420                         vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3421                                                 new TVector3(vertex->X()*ratio[2*i+1]
3422                                                         +                        transvector[i]->X(),
3423                                                                                  vertex->Y()*ratio[2*i+1]
3424                                                         +                transvector[i]->Y());
3425                 }
3426         }
3427         for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3428                 for(Int_t j=0; j<kvertexnumber; j++){
3429                         xvertexpoints[i][j] = vertexposition[i][j]->X();
3430                         yvertexpoints[i][j] = vertexposition[i][j]->Y();
3431                 }
3432                 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3433                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3434                                                                                 xvertexpoints[i],yvertexpoints[i]);
3435                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3436                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3437                 ssdchipcable[kssdchipcablesnumber*k+i] =
3438                                 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3439                                                            ssdchipcableshape[kssdchipcablesnumber*k+i],
3440                                                           (kssdchipcablesnumber*k+i)%2==0?
3441                                                            fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3442                 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3443         }
3444         for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3445                 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3446   }
3447   /////////////////////////////////////////////////////////////
3448   // Mother Volume definition
3449   /////////////////////////////////////////////////////////////
3450   static const Int_t kmothervertexnumber = 8;
3451   Double_t xmothervertex[kmothervertexnumber];
3452   Double_t ymothervertex[kmothervertexnumber];
3453   xmothervertex[0] = xvertexpoints[0][1];
3454   ymothervertex[0] = yvertexpoints[0][1];
3455   xmothervertex[1] = xvertexpoints[0][2+nedges/2];
3456   ymothervertex[1] = yvertexpoints[0][1];
3457   xmothervertex[2] = xvertexpoints[0][2+nedges/2];
3458   ymothervertex[2] = yvertexpoints[0][2+nedges];
3459   xmothervertex[3] = xvertexpoints[0][3+nedges];
3460   ymothervertex[3] = yvertexpoints[0][3+nedges];
3461   xmothervertex[4] = xvertexpoints[0][3+2*nedges];
3462   ymothervertex[4] = yvertexpoints[0][3+2*nedges];
3463   xmothervertex[5] = xvertexpoints[0][4+2*nedges];
3464   ymothervertex[5] = yvertexpoints[0][4+2*nedges];
3465   xmothervertex[6] = xvertexpoints[1][5+2*nedges];
3466   ymothervertex[6] = yvertexpoints[1][5+2*nedges];
3467   xmothervertex[7] = xvertexpoints[0][1];
3468   ymothervertex[7] = yvertexpoints[1][5+2*nedges];
3469   TGeoXtru *ssdchipcablemothershape = new TGeoXtru(2);
3470   ssdchipcablemothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3471   ssdchipcablemothershape->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3472   ssdchipcablemothershape->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3473
3474   cableL = new TGeoVolume("SSDChipCableMotherLeft",ssdchipcablemothershape,fSSDAir);
3475   cableR = new TGeoVolume("SSDChipCableMotherRight",ssdchipcablemothershape,fSSDAir);
3476
3477   cableL->AddNode(ssdchipcable[0],1);
3478   cableL->AddNode(ssdchipcable[1],1);
3479   cableR->AddNode(ssdchipcable[2],1);
3480   cableR->AddNode(ssdchipcable[3],1);
3481
3482   /////////////////////////////////////////////////////////////
3483   // Deallocating memory
3484   /////////////////////////////////////////////////////////////
3485   for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3486         delete [] xvertexpoints[i];
3487         delete [] yvertexpoints[i];
3488   }
3489   for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3490   for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3491   delete vertex;
3492   /////////////////////////////////////////////////////////////
3493 }
3494 //_____________________________________________________________________________
3495 TGeoVolume* AliITSv11GeometrySSD::GetSSDChip() const{
3496   /////////////////////////////////////////////////////////////
3497   // SSD Chip Assembly Generation
3498   /////////////////////////////////////////////////////////////
3499   TGeoBBox* ssdchipcompshape[2];
3500   ssdchipcompshape[0] =  new TGeoBBox("SSDChipCompShape",
3501                                                                                 0.5*fgkSSDChipLength,
3502                                                                                 0.5*fgkSSDChipWidth,
3503                                                                                 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3504   ssdchipcompshape[1] =  new TGeoBBox("SSDChipGlueCompShape",
3505                                                                                 0.5*fgkSSDChipLength,
3506                                                                                 0.5*fgkSSDChipWidth,
3507                                                                                 0.5*fgkSSDChipGlueHeight);
3508   TGeoVolume* ssdchipcomp[2];
3509   ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3510   ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3511                                                                   fSSDChipGlueMedium);
3512   ssdchipcomp[0]->SetLineColor(fColorSilicon);
3513   ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3514   TGeoTranslation* ssdchipcomptrans[2];
3515   ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3516   ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3517   /////////////////////////////////////////////////////////////
3518   // Virtual Volume containing SSDChip
3519   /////////////////////////////////////////////////////////////
3520   TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3521                                                                                                                  0.5*fgkSSDChipWidth,
3522                                                                                                                  0.5*fgkSSDChipHeight);
3523   TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
3524   /////////////////////////////////////////////////////////////
3525   for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3526   return ssdchip;
3527 }
3528 /////////////////////////////////////////////////////////////////////////////////
3529 TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
3530   /////////////////////////////////////////////////////////////
3531   // Method returning a List containing pointers to Ladder Cable Volumes
3532   //
3533   // Return list contains 3 assemblies: cable box, cable arb shape and the end part of the cable
3534   //                                    each contains 2 volumes, one for polyamide and one for aluminium
3535   /////////////////////////////////////////////////////////////
3536   const Int_t kladdercablesegmentnumber = 2;
3537   /////////////////////////////////////////
3538   // LadderSegmentBBox Volume
3539   /////////////////////////////////////////
3540   static TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber] = {0,0};
3541   const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3542                                 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
3543
3544
3545   const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3546                                                   {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3547   static TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3548
3549   static TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber] = {
3550                                                    new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3551                                                                                            0.5*fgkSSDFlexWidth[0],
3552                                                                                            0.5*fgkSSDLadderCableWidth,
3553                                                                        0.5*fgkSSDLadderCableHeight[0]),
3554                                                    new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3555                                                                                            0.5*fgkSSDFlexWidth[0],
3556                                                                                            0.5*fgkSSDLadderCableWidth,
3557                                                                                            fgkSSDLadderCableHeight[0]
3558                                                                                            +0.5*fgkSSDLadderCableHeight[1])
3559                                                                                    };
3560   static TGeoVolume* laddercablesegmentbboxassembly =                                              new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly") ;
3561   static TGeoVolume* laddercablesegmentarbassembly =
3562                                                    new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3563
3564   static TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3565   static TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3566
3567   if (laddercablesegmentbboxshape[0] == 0) {
3568     // Initialise static shapes and volumes
3569   for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3570                                                   new TGeoBBox(laddercablesegmentbboxshapename[i],
3571                                                                            0.5*fgkSSDFlexWidth[0],
3572                                                                            0.5*fgkSSDLadderCableWidth,
3573                                                                            0.5*fgkSSDLadderCableHeight[i]);
3574
3575   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3576                         laddercablesegmentbbox[i] =
3577                                                   new TGeoVolume(laddercablesegmentbboxname[i],
3578                                                                                  laddercablesegmentbboxshape[i],
3579                                                                                  (i==0?fSSDAlTraceLadderCableMedium:
3580             fSSDKaptonLadderCableMedium));
3581                         laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3582                                                                                                                    fColorPolyhamide);
3583   }
3584
3585   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3586                 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3587                                                                                             laddercablesegmentbboxtrans[i]);
3588 /////////////////////////////////////////
3589 // LadderSegmentArb8 Volume
3590 /////////////////////////////////////////
3591   const Int_t kvertexnumber = 4;
3592   TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3593   for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3594                                                                                                   new TVector3*[kvertexnumber];
3595 //Shape Vertex Positioning
3596   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3597         laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
3598         laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3599                                                                                                                   i*fgkSSDFlexHeight[0]);
3600         laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3601                                                                                    +                         fgkSSDFlexHeight[1]
3602                                                                                    +                      i*fgkSSDFlexHeight[0]);
3603         laddercablesegmentvertexposition[i][3] =
3604                                                    new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3605                                                                                 laddercablesegmentvertexposition[i][2]->Y());
3606   }
3607   Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3608                                                                             {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
3609   const char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
3610                                         {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
3611
3612   for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3613                                         GetArbShape(laddercablesegmentvertexposition[i],
3614                                                                 laddercablesegmentwidth[i],
3615                                                                 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3616                                                                 laddercablesegmentarbshapename[i]);
3617   const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3618                                                   {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
3619
3620   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3621                          laddercablesegmentarb[i] =
3622                                                    new TGeoVolume(laddercablesegmentarbname[i],
3623                                                                                   laddercablesegmentarbshape[i],
3624                                                                                   (i==0?fSSDAlTraceLadderCableMedium:
3625             fSSDKaptonLadderCableMedium));
3626                          laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3627                                                                                                                    fColorPolyhamide);
3628 }
3629   TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3630   laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3631                                                                                                  90.,90,-90.);
3632   laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3633                                                                                                   0.,90.,0.);
3634   TGeoCombiTrans* laddercablesegmentarbcombitrans =
3635                                                    new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3636                                                            0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3637                                                          + fgkSSDFlexWidth[0],0.,0.,
3638                                                    new TGeoRotation((*laddercablesegmentarbrot[1])
3639                                                      *(*laddercablesegmentarbrot[0])));
3640   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3641   laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3642                                                                                    laddercablesegmentarbcombitrans);
3643   }  // End of static initialisations
3644 /////////////////////////////////////////
3645 // End Ladder Cable Volume
3646 // Note: this part depends explicitly on the length passed as an argument to the function
3647 /////////////////////////////////////////
3648   TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3649   const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3650                                 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3651   for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3652                                                   new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3653                                                                            0.5*ssdendladdercablelength,
3654                                                                            0.5*fgkSSDLadderCableWidth,
3655                                                                            0.5*fgkSSDLadderCableHeight[i]);
3656   const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3657                                                   {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
3658   TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
3659   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3660                         ladderendcablesegmentbbox[i] =
3661                                                   new TGeoVolume(ladderendcablesegmentbboxname[i],
3662                                                                                  ladderendcablesegmentbboxshape[i],
3663                                                                                  (i==0?fSSDAlTraceLadderCableMedium:
3664             fSSDKaptonLadderCableMedium));
3665                         ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3666                                                                                                                    fColorPolyhamide);
3667   }
3668   TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
3669   ladderendcablesegmentbboxtrans[0] =
3670                                                    new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
3671                                                                                            0.5*ssdendladdercablelength,
3672                                                                                            0.5*fgkSSDLadderCableWidth,
3673                                                                                            0.5*fgkSSDLadderCableHeight[0]);
3674   ladderendcablesegmentbboxtrans[1] =
3675                                                    new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
3676                                                                                            0.5*ssdendladdercablelength,
3677                                                                                            0.5*fgkSSDLadderCableWidth,
3678                                                                                            fgkSSDLadderCableHeight[0]
3679                                                                                            +0.5*fgkSSDLadderCableHeight[1]);
3680   TGeoVolume* ladderendcablesegmentbboxassembly =
3681                                                    new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
3682   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3683                 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
3684                                                                                             ladderendcablesegmentbboxtrans[i]);
3685 /////////////////////////////////////////
3686   TList* laddercablesegmentlist = new TList();
3687   laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
3688   laddercablesegmentlist->Add(laddercablesegmentarbassembly);
3689   laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
3690   return laddercablesegmentlist;
3691 }
3692
3693 /////////////////////////////////////////////////////////////////////////////////
3694 TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
3695   /////////////////////////////////////////////////////////////
3696   // Method generating Ladder Cable of given length (n modules + end)
3697   // Called by GetLadderCableAssembly
3698   /////////////////////////////////////////////////////////////
3699   TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
3700   TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
3701   for(Int_t i=0; i<n; i++){
3702          TGeoTranslation* laddercabletrans = new TGeoTranslation(
3703                                                         i*(fgkCarbonFiberJunctionWidth),
3704                                                         fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
3705                                                         i*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
3706     laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
3707     if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
3708
3709   }
3710   TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
3711                                           (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
3712                                                              fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
3713                                                              (n-1)*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
3714   laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
3715   return laddercable;
3716 }
3717 /////////////////////////////////////////////////////////////////////////////////
3718 TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
3719   ///////////////////////////////////////////////////////////////////
3720   // Main method generating Ladder Cable bundles containing n cables
3721   ///////////////////////////////////////////////////////////////////
3722   Double_t totalLength = ssdendladdercablelength+(n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0];
3723   Double_t cableOrig[3] = {0.5*totalLength,1.5*fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1])};
3724   TGeoBBox *laddercableshape = new TGeoBBox(0.5*totalLength,0.5*fgkSSDLadderCableWidth,0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]),cableOrig);
3725   TGeoVolume* laddercable = new TGeoVolume("LadderCableMother", laddercableshape, fSSDAir);
3726   char laddercabletransname[100];
3727   for(Int_t i=0; i<n; i++){
3728         sprintf(laddercabletransname,"LadderCableTrans%i",i+1);
3729         laddercable->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
3730                              new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0,0));
3731   }
3732   return laddercable;
3733 }
3734 /////////////////////////////////////////////////////////////////////////////////
3735 TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
3736   /////////////////////////////////////////////////////////////
3737   // Method generating Ladder Cable List Assemblies
3738   // containing two cables bundles, i.e. P+N readout for one endcap
3739   /////////////////////////////////////////////////////////////
3740   const Int_t kladdercableassemblynumber = 2;
3741   TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
3742   TGeoVolume* ladderCable[kladdercableassemblynumber];
3743   char laddercableassemblyname[100];
3744   TList* laddercableassemblylist = new TList();
3745   for(Int_t i=0; i<kladdercableassemblynumber; i++){
3746         sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
3747         ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
3748         ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
3749                                          new TGeoCombiTrans((n-1)
3750                                          *       fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
3751                                              2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
3752                                                                                         0.,new TGeoRotation("",180,0.,0.)));
3753         laddercableassemblylist->Add(ladderCable[i]);
3754 }
3755   return laddercableassemblylist;
3756 }
3757 ///////////////////////////////////////////////////////////////////////////////
3758 void AliITSv11GeometrySSD::SetLadderSegment(){
3759   /////////////////////////////////////////////////////////////
3760   // Method Generating Ladder Segment Array
3761   /////////////////////////////////////////////////////////////
3762   fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
3763   fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
3764
3765   /* MvL: tried to create mother volume. Requires changes in all rotations, bc xtru is always along z-axis
3766   TGeoXtru *laddersegmentshape = new TGeoXtru(2);
3767   static const Int_t ntrianglevtx = 3;
3768   Double_t xtrianglevtx[ntrianglevtx]={-0.5*fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength, 0};
3769   Double_t ytrianglevtx[ntrianglevtx]={0, 0, fgkCarbonFiberTriangleLength * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
3770   laddersegmentshape->DefinePolygon(ntrianglevtx,xtrianglevtx,ytrianglevtx);
3771   laddersegmentshape->DefineSection(0,0);
3772   laddersegmentshape->DefineSection(1,fgkCarbonFiberJunctionWidth);  // MVL
3773   fladdersegment[0] = new TGeoVolume("LadderSegment1",laddersegmentshape,fSSDAir);
3774   fladdersegment[1] = new TGeoVolume("LadderSegment2",laddersegmentshape,fSSDAir);
3775   */
3776
3777   if(!fCreateMaterials) CreateMaterials();
3778   if(!fTransformationMatrices) CreateTransformationMatrices();
3779   if(!fBasicObjects) CreateBasicObjects();
3780   for(Int_t i=0; i<fgkladdersegmentnumber; i++){
3781   // Placing Carbon Fiber Support
3782         for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
3783                 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3784                                                                                         fcarbonfibersupportmatrix[j]);
3785                 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3786                                                                                         fcarbonfibersupportmatrix[j]);
3787   }
3788   // Placing Carbon Fiber Junction
3789         for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++) {
3790         fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
3791                                                                    fcarbonfiberjunctionmatrix[j]);
3792   }
3793   // Placing Carbon Fiber Lower Support
3794     for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++) {
3795                 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
3796                                                            fcarbonfiberlowersupportrans[j]);
3797     }
3798   // Placing SSD Sensor Support
3799     for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
3800         fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
3801                                                                      fssdsensorsupport[1][i],
3802                                                            j+1,fssdsensorsupportmatrix[j]);
3803   // Placing SSD Cooling Tube Support
3804         for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
3805                 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3806                                                                    fcoolingtubesupportmatrix[j]);
3807   // Placing SSD Cooling Tube
3808         fladdersegment[i]->AddNode(fcoolingtube,1,fcoolingtubematrix[0]);
3809         fladdersegment[i]->AddNode(fcoolingtube,2,fcoolingtubematrix[1]);
3810   // Placing SSD Hybrid
3811     switch(i){
3812         case 0:
3813                 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
3814                 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3815                 break;
3816     case 1:
3817                 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
3818                 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3819                 break;
3820         }
3821         // Placing Cooling Block System
3822       fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
3823         // Placing SSD Flex
3824       for(Int_t j=0; j<fgkflexnumber; j++){
3825         fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
3826         fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
3827       }
3828    }
3829 }
3830 ///////////////////////////////////////////////////////////////////////////////
3831 void AliITSv11GeometrySSD::SetEndLadderSegment(){
3832   /////////////////////////////////////////////////////////////
3833   // Method Generating End Ladder
3834   /////////////////////////////////////////////////////////////
3835   // End Ladder Carbon Fiber Junction
3836   /////////////////////////////////////////////////////////////
3837   fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
3838   fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
3839   if(!fCreateMaterials) CreateMaterials();
3840   if(!fTransformationMatrices) CreateTransformationMatrices();
3841   if(!fBasicObjects) CreateBasicObjects();
3842   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
3843         for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
3844                 fendladdersegment[i]->AddNode(j==2 ?
3845                                                         fendladdercarbonfiberjunction[i][1] :
3846                                                         fendladdercarbonfiberjunction[i][0],
3847                                                         j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
3848   }
3849   /////////////////////////////////////////////////////////////
3850   // End Ladder Carbon Fiber Support
3851   /////////////////////////////////////////////////////////////
3852   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
3853       for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
3854                   fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3855                   fendladdercarbonfibermatrix[i][j]);
3856           fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3857                   fendladdercarbonfibermatrix[i][j]);
3858       }
3859   /////////////////////////////////////////////////////////////
3860   // End Ladder Mounting Block
3861   /////////////////////////////////////////////////////////////
3862   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3863        fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
3864                                      fendladdermountingblockcombitrans[i]);
3865   /////////////////////////////////////////////////////////////
3866   // End Ladder Mounting Block Clip
3867   /////////////////////////////////////////////////////////////
3868   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3869         for(Int_t j=0; j<2; j++)
3870                 fendladdersegment[i]->AddNode(fendladdermountingblockclip,j+1,
3871                                               fendladdermountingblockclipmatrix[i][j]);
3872   /////////////////////////////////////////////////////////////
3873   // End Ladder Lower Supports
3874   /////////////////////////////////////////////////////////////
3875   fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
3876                                 fendladderlowersupptrans[0]);
3877   fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
3878                                 fendladderlowersupptrans[1]);
3879   fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
3880                                 fendladderlowersupptrans[2]);
3881   /////////////////////////////////////////////////////////////
3882   // End Ladder Cooling Tube Support
3883   /////////////////////////////////////////////////////////////
3884   for(Int_t i=0; i<2; i++)
3885         for(Int_t j=0; j<(i==0?4:2); j++)
3886                 fendladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3887                                               fendladdercoolingtubesupportmatrix[i][j]);
3888   /////////////////////////////////////////////////////////////
3889   // End Ladder Cooling Tube Support
3890   /////////////////////////////////////////////////////////////
3891   fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
3892   fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
3893   fendladdersegment[1]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[1][0]);
3894   fendladdersegment[1]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[1][1]);
3895 }
3896 ///////////////////////////////////////////////////////////////////////////////
3897 void AliITSv11GeometrySSD::SetLadder(){
3898   /////////////////////////////////////////////////////////////
3899   // Method Generating Ladder of Layer 5 and 6
3900   /////////////////////////////////////////////////////////////
3901   Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
3902                                                                                                 fgkSSDLay6SensorsNumber};
3903   /////////////////////////////////////////////////////////////////////////////
3904   /// Generating Ladder Mother Volume Containing Ladder
3905   /////////////////////////////////////////////////////////////////////////////
3906   TGeoXtru* laddershape[fgkladdernumber];
3907   for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
3908   const Int_t kmothervertexnumber = 8;
3909   Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
3910   Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
3911   ///////////////////////
3912   // Setting the vertices
3913   ///////////////////////
3914   Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
3915                                                                 * (fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]);
3916   xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
3917   ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
3918   xmothervertex[0][1] = xmothervertex[0][0];
3919   ymothervertex[0][1] = -0.5*fgkCoolingTubeSupportHeight; // 0.0; MvL 20-apr-2010
3920   xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
3921                                                 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
3922   ymothervertex[0][2] = ymothervertex[0][1];
3923   ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
3924   xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
3925   xmothervertex[0][4] = -xmothervertex[0][3];
3926   ymothervertex[0][4] = ymothervertex[0][3];
3927   xmothervertex[0][5] = -xmothervertex[0][2];
3928   ymothervertex[0][5] = ymothervertex[0][2];
3929   xmothervertex[0][6] = -xmothervertex[0][1];
3930   ymothervertex[0][6] = ymothervertex[0][1];
3931   xmothervertex[0][7] = -xmothervertex[0][0];
3932   ymothervertex[0][7] = ymothervertex[0][0];
3933   for(Int_t i=0; i<kmothervertexnumber; i++){
3934         xmothervertex[1][i] = xmothervertex[0][i];
3935         ymothervertex[1][i] = ymothervertex[0][i];
3936   }
3937 ///////////////////////////////////////////////////////////////////////////
3938 // Disalignement Mother Volume corrections 25/08/08
3939 ///////////////////////////////////////////////////////////////////////////
3940   TGeoXtru* leftladdershape1[fgkladdernumber];
3941   TGeoXtru* leftladdershape2[fgkladdernumber];
3942   TGeoXtru* centersensorladdershape[fgkladdernumber];
3943   TGeoXtru* rightladdershape1[fgkladdernumber];
3944   TGeoXtru* rightladdershape2[fgkladdernumber];
3945   for(Int_t i=0; i<fgkladdernumber; i++){
3946     leftladdershape1[i] = new TGeoXtru(2);
3947     leftladdershape2[i] = new TGeoXtru(2);
3948     centersensorladdershape[i] = new TGeoXtru(2);
3949     rightladdershape1[i] = new TGeoXtru(2);
3950     rightladdershape2[i] = new TGeoXtru(2);
3951   }
3952   //////////////////////////////////////
3953   // Setting the names for shapes
3954   //////////////////////////////////////
3955   leftladdershape1[0]->SetName("Lay5Left1LadderSegmentContainer");
3956   leftladdershape2[0]->SetName("Lay5Left2LadderSegmentContainer");
3957   leftladdershape1[1]->SetName("Lay6Left1LadderSegmentContainer");
3958   leftladdershape2[1]->SetName("Lay6Left2LadderSegmentContainer");
3959   centersensorladdershape[0]->SetName("Lay5CenterSensorContainer");
3960   centersensorladdershape[1]->SetName("Lay6CenterSensorContainer");
3961   rightladdershape1[0]->SetName("Lay5Right1LadderSegmentContainer");
3962   rightladdershape2[0]->SetName("Lay5Right2LadderSegmentContainer");
3963   rightladdershape1[1]->SetName("Lay6Right1LadderSegmentContainer");
3964   rightladdershape2[1]->SetName("Lay6Right2LadderSegmentContainer");
3965   //////////////////////////////////////
3966   Double_t xend1laddervertex[fgkladdernumber][kmothervertexnumber];
3967   Double_t yend1laddervertex[fgkladdernumber][kmothervertexnumber];
3968   Double_t xcentersensorvertex[fgkladdernumber][kmothervertexnumber];
3969   Double_t ycentersensorvertex[fgkladdernumber][kmothervertexnumber];
3970   Double_t xend2laddervertex[fgkladdernumber][kmothervertexnumber];
3971   Double_t yend2laddervertex[fgkladdernumber][kmothervertexnumber];
3972   for(Int_t i=0; i<fgkladdernumber; i++) {
3973     for(Int_t j=0; j<kmothervertexnumber; j++){
3974       xcentersensorvertex[i][j] = xmothervertex[i][j];
3975       ycentersensorvertex[i][j] = ymothervertex[i][j];
3976       xend1laddervertex[i][j] = xmothervertex[i][j];
3977       yend1laddervertex[i][j] = ymothervertex[i][j];
3978       xend2laddervertex[i][j] = xmothervertex[i][j];
3979       yend2laddervertex[i][j] = ymothervertex[i][j];
3980     }
3981     // Add some space around sensors to accommodate misalignments
3982     xcentersensorvertex[i][0] -= fgkSSDModuleSideDisalignment;
3983     xcentersensorvertex[i][1] =  xcentersensorvertex[0][0];
3984     xcentersensorvertex[i][6] = -xcentersensorvertex[0][1];
3985     xcentersensorvertex[i][7] = -xcentersensorvertex[0][0];
3986
3987     ycentersensorvertex[i][0] -= fgkSSDModuleVerticalDisalignment;
3988     ycentersensorvertex[i][7] = ycentersensorvertex[0][0];
3989
3990     // Center Ladder Piece
3991     centersensorladdershape[i]->DefinePolygon(kmothervertexnumber,xcentersensorvertex[i],
3992                                               ycentersensorvertex[i]);
3993     centersensorladdershape[i]->DefineSection(0, - fgkEndLadderCarbonFiberLowerJunctionLength[1]
3994                                                  + 1.45*fgkSSDMountingBlockWidth);
3995     centersensorladdershape[i]->DefineSection(1,   ssdlaysensorsnumber[i] * fgkCarbonFiberJunctionWidth
3996                                                  + fgkEndLadderCarbonFiberLowerJunctionLength[0]
3997                                                  - 2.4*fgkSSDMountingBlockWidth);
3998
3999     // Left and Right Ladder Pieces: Mother volumes around ladder mounting areas
4000
4001     // Cuts off first corner (neg x)
4002     xend1laddervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4003     xend1laddervertex[i][1] = -0.5*fgkSSDMountingBlockLength[0];
4004     // Cuts off last part (pos x)
4005     xend2laddervertex[i][6] = 0.5*fgkSSDMountingBlockLength[0];
4006     xend2laddervertex[i][7] = 0.5*fgkSSDMountingBlockLength[0];
4007
4008     leftladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
4009                                        yend1laddervertex[i]);
4010     leftladdershape1[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
4011     leftladdershape1[i]->DefineSection(1,  fendladdersegmentmatrix[0][i]->GetTranslation()[2]
4012                                          - fgkEndLadderMountingBlockPosition[0]);
4013
4014     leftladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
4015                                        yend2laddervertex[i]);
4016     leftladdershape2[i]->DefineSection(0,  fendladdersegmentmatrix[0][i]->GetTranslation()[2]
4017                                          - fgkEndLadderMountingBlockPosition[0]);
4018     leftladdershape2[i]->DefineSection(1,- fgkEndLadderCarbonFiberLowerJunctionLength[1]
4019                                        + 1.45*fgkSSDMountingBlockWidth);  // connect to main volume at -1.6725 cm
4020
4021     rightladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
4022                                         yend1laddervertex[i]);
4023     rightladdershape1[i]->DefineSection(0,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4024                                         +fgkEndLadderCarbonFiberLowerJunctionLength[0]
4025                                         -2.4*fgkSSDMountingBlockWidth);
4026     rightladdershape1[i]->DefineSection(1,fendladdersegmentmatrix[1][i]->GetTranslation()[2]
4027                                         + fgkEndLadderMountingBlockPosition[1]);
4028
4029     rightladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
4030                                         yend2laddervertex[i]);
4031     rightladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[1][i]->GetTranslation()[2]
4032                                            + fgkEndLadderMountingBlockPosition[1]);
4033     rightladdershape2[i]->DefineSection(1,  ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4034                                           + fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4035   }
4036   TGeoCompositeShape* laddershapecontainer[2];
4037   laddershapecontainer[0] = new TGeoCompositeShape("Lay5LadderCompositeShape",
4038                                                    "Lay5Left1LadderSegmentContainer+Lay5Left2LadderSegmentContainer"
4039                                                    "+Lay5CenterSensorContainer"
4040                                                    "+Lay5Right1LadderSegmentContainer+Lay5Right2LadderSegmentContainer");
4041   laddershapecontainer[1] = new TGeoCompositeShape("Lay6LadderCompositeShape",
4042                                                    "Lay6Left1LadderSegmentContainer+Lay6Left2LadderSegmentContainer"
4043                                                    "+Lay6CenterSensorContainer"
4044                                                    "+Lay6Right1LadderSegmentContainer+Lay6Right2LadderSegmentContainer");
4045   const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4046   for(Int_t i=0; i<fgkladdernumber; i++){
4047     fladder[i] = new TGeoVolume(laddername[i],laddershapecontainer[i],fSSDAir);
4048     fladder[i]->SetLineColor(4);
4049   }
4050 ///////////////////////////////////////////////////////////////////////////
4051  if(!fCreateMaterials) CreateMaterials();
4052  if(!fTransformationMatrices) CreateTransformationMatrices();
4053  if(!fBasicObjects) CreateBasicObjects();
4054  SetLadderSegment();
4055  SetEndLadderSegment();
4056   for(Int_t i=0; i<fgkladdernumber; i++){
4057         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4058         //////////////////////////
4059         /// Placing Ladder Segment
4060         //////////////////////////
4061                 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4062                                                                      fladdersegment[i==0 ? 1 : 0],
4063                                                                          ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4064         //////////////////////////
4065         /// Placing SSD Sensor
4066         //////////////////////////
4067         if(i==0&&ssdlaysensorsnumber[i]-j-1==13) fSSDSensor5->SetLineColor(kRed);
4068                 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4069                                                         fssdsensormatrix[i][j]);
4070         }
4071         ///////////////////////////////
4072         /// Placing End Ladder Segment
4073         ///////////////////////////////
4074         fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
4075         fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4076    }
4077 /////////////////////////////////////////////////////////////////////////////
4078 /// Placing Ladder Cables
4079 /////////////////////////////////////////////////////////////////////////////
4080   Int_t sidecablenumber[2][2];
4081   sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4082   sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4083   sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4084   sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4085   Double_t carbonfibertomoduleposition[3];
4086   carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4087   carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4088                          fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4089          +               0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4090          -               0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4091          -            fgkSSDSensorCenterSupportThickness[0]);
4092   carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4093                                                                  +   0.5*fgkCoolingTubeSupportHeight
4094          -         fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4095   const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
4096   Double_t ssdendladdercablelength[4];
4097   ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
4098                                                          + fgkSSDSensorLength
4099                                                          - fgkSSDModuleStiffenerPosition[1]
4100                                                          - fgkSSDStiffenerWidth
4101                                                          - fgkSSDFlexWidth[0]
4102                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
4103   ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
4104                                                          + fgkSSDModuleStiffenerPosition[1]
4105                                                          + fgkSSDStiffenerWidth
4106                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
4107   ssdendladdercablelength[2] = ssdendladdercablelength[1]
4108                                                          - fgkEndLadderCarbonFiberLowerJunctionLength[1]
4109                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4110                                                          - kendladdercablecorrection;
4111   ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4112                                                          + carbonfibertomoduleposition[1]
4113                                                          - fgkSSDModuleStiffenerPosition[1]
4114                                                          - fgkSSDStiffenerWidth)
4115                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
4116
4117   TList* laddercableassemblylist[4];
4118   const Int_t kendladdercablesnumber = 4;
4119   TGeoRotation *laddercablerot = new TGeoRotation();
4120   laddercablerot->SetAngles(90.,60.,-90.);
4121   for(Int_t i=0; i<fgkladdercablesnumber; i++)
4122         for(Int_t j=0; j<kendladdercablesnumber; j++){
4123                 laddercableassemblylist[j] =
4124                 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4125                                                                    ssdendladdercablelength[j]);
4126                         fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4127                                                                         j<2?1:2,fladdercablematrix[i][j]);
4128   }
4129 }
4130 ////////////////////////////////////////////////////////////////////////////////
4131 void AliITSv11GeometrySSD::SetLayer(){
4132 ////////////////////////////////////////////////////////////////////////////////
4133   // Creating Ladder of Layer 5 and Layer 6
4134   /////////////////////////////////////////////////////////////
4135   if(!fCreateMaterials) CreateMaterials();
4136   if(!fTransformationMatrices) CreateTransformationMatrices();
4137   if(!fBasicObjects) CreateBasicObjects();
4138   SetLadder(); // Generating the ladder of Layer5 and Layer6
4139   const Int_t kssdlayladdernumber[fgklayernumber] =
4140                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4141   /////////////////////////////////////////////////////////////
4142   // Generating mother volumes for Layer5 and Layer6
4143   /////////////////////////////////////////////////////////////
4144   fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
4145   fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
4146   Int_t *ladderindex[fgklayernumber];
4147   Int_t index[fgklayernumber] = {8,9};
4148   for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4149   for(Int_t i=0; i<fgklayernumber; i++)
4150         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4151                 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4152                                                           j+index[i] : j+index[i]-kssdlayladdernumber[i];
4153                 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4154                         fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4155         }
4156   /////////////////////////////////////////////////////////////
4157   // Deallocating memory
4158   /////////////////////////////////////////////////////////////
4159   for(Int_t i=0; i<fgklayernumber; i++) delete [] ladderindex[i];
4160 }
4161 ////////////////////////////////////////////////////////////////////////////////
4162 void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
4163   /////////////////////////////////////////////////////////////
4164   // Insert the layer 5 in the mother volume.
4165   /////////////////////////////////////////////////////////////
4166   if (! moth) {
4167     AliError("Can't insert layer5, mother is null!\n");
4168     return;
4169   };
4170   if(!fSSDLayer5) SetLayer();
4171   fMotherVol = moth;
4172   TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4173                                                                                 + fgkLay5CenterITSPosition);
4174   moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
4175  }
4176 ////////////////////////////////////////////////////////////////////////////////
4177 void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
4178   /////////////////////////////////////////////////////////////
4179   // Insert the layer 6 in the mother volume.
4180   /////////////////////////////////////////////////////////////
4181   if (! moth) {
4182     AliError("AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
4183     return;
4184   };
4185   if(!fSSDLayer6) SetLayer();
4186   fMotherVol = moth;
4187   TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4188                                                                                 + fgkLay6CenterITSPosition);
4189   moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
4190  }
4191  ////////////////////////////////////////////////////////////////////////////////
4192  TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4193   /////////////////////////////////////////////////////////////
4194   // Method generating the Arc structure of Ladder Support
4195   /////////////////////////////////////////////////////////////
4196   const Int_t kssdlayladdernumber[fgklayernumber] =
4197                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4198   Double_t mountingsupportedge[fgklayernumber];
4199   Double_t mountingblockratio[fgklayernumber];
4200   Double_t theta[fgklayernumber];
4201   Double_t phi[fgklayernumber];
4202   Double_t psi0[fgklayernumber];
4203   Double_t deltapsi[fgklayernumber];
4204   TVector3* mountingsupportedgevector[fgklayernumber];
4205   for(Int_t i=0; i<fgklayernumber; i++){
4206         mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4207     mountingsupportedge[i]    = 0.5*fgkMountingBlockSupportRadius[i]
4208                                                           * (TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
4209                                                           * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4210                                                           - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4211                                                           / kssdlayladdernumber[i])));
4212     theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4213     phi[i]   = TMath::ASin(0.5*mountingblockratio[i]);
4214         mountingsupportedgevector[i] = new TVector3();
4215         mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4216         mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(
4217                                                         (1.-mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])*
4218                                                         (1.+mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])));
4219     psi0[i] = 0.5*TMath::Pi()-phi[i];
4220     deltapsi[i] = (theta[i]+phi[i])/nedges;
4221   }
4222   TVector3** vertex[fgklayernumber];
4223   TList* vertexlist[fgklayernumber];
4224   Int_t indexedge[fgklayernumber] = {0,0};
4225   for(Int_t i=0; i<fgklayernumber; i++){
4226         vertex[i] = new TVector3*[nedges+1];
4227         vertexlist[i] = new TList();
4228   }
4229   for(Int_t i=0; i<fgklayernumber; i++){
4230         for(Int_t j=0; j<nedges+1; j++){
4231                 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
4232                                                                     fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]));
4233                 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4234                 vertexlist[i]->Add(vertex[i][j]);
4235         }
4236         vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4237   }
4238   Double_t** xsidevertex = new Double_t*[fgklayernumber];
4239   Double_t** ysidevertex = new Double_t*[fgklayernumber];
4240   Double_t** xcentervertex = new Double_t*[fgklayernumber];
4241   Double_t** ycentervertex = new Double_t*[fgklayernumber];
4242   Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4243   Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4244   Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4245   Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4246   for(Int_t i=0; i<fgklayernumber; i++){
4247     xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4248     ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4249     xcentervertex[i] = new Double_t[indexedge[i]+3];
4250     ycentervertex[i] = new Double_t[indexedge[i]+3];
4251         xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4252         ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4253         xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4254         ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4255         for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4256                 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4257                                                                                 ((TVector3*)vertexlist[i]->At(j))->X();
4258                 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4259                                                                                 ((TVector3*)vertexlist[i]->At(j))->Y();
4260                 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4261                 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4262                 if(j<indexedge[i]+1){
4263                         xcentervertex[i][j!=indexedge[i]?j+3:0] =
4264                                                                                 ((TVector3*)vertexlist[i]->At(j))->X();
4265                         ycentervertex[i][j!=indexedge[i]?j+3:0] =
4266                                                                                 ((TVector3*)vertexlist[i]->At(j))->Y();
4267                         xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4268                         ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4269                 }
4270         }
4271         xsidevertex[i][1] = xsidevertex[i][0];
4272         ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4273         xsidevertex[i][2] = xsidevertex[i][3];
4274         ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4275         xcentervertex[i][1] = xcentervertex[i][0];
4276         ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4277         xcentervertex[i][2] = xcentervertex[i][3];
4278         ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4279         xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4280         ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4281         xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4282         ycenterlowervertex[i][0] = ysidevertex[i][0];
4283         xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4284         ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4285   }
4286   /////////////////////////////////////////////////////////////
4287   // Building the Arc Structure of Ladder Supports
4288   /////////////////////////////////////////////////////////////
4289   TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4290   TGeoXtru* centermountingsupportshape[fgklayernumber];
4291   TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4292   TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4293   TGeoVolume* sidemountingblocksupport[fgklayernumber];
4294   TGeoVolume* centermountingblocksupport[fgklayernumber];
4295   TGeoVolume* sideladdersupportpiece[fgklayernumber];
4296   TGeoVolume* centerladdersupportpiece[fgklayernumber];
4297   char sidemountingblockname[100];
4298   char centermountingblockname[100];
4299   char sideladdersupportpiecename[100];
4300   char centerladdersupportpiecename[100];
4301   for(Int_t i=0; i<fgklayernumber; i++){
4302         sprintf(sidemountingblockname,"MountingBlockSupportSideLay%dArc",i+5);
4303         sprintf(centermountingblockname,"MountingBlockSupportCenterLay%dArc",i+5);
4304         sprintf(sideladdersupportpiecename,"SideLadderSupportPieceLay%d",i+5);
4305         sprintf(centerladdersupportpiecename,"CenterLadderSupportPieceLay%d",i+5);
4306         sidemountingblocksupportshape[i] = new TGeoXtru(2);
4307     sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4308                                                                                                 xsidevertex[i],ysidevertex[i]);
4309     sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4310                                                                                                          -fgkMountingBlockSupportWidth[0]);
4311     sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4312     sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4313                                                                           sidemountingblocksupportshape[i],
4314                                                                                   fSSDAlCoolBlockMedium);
4315         sidemountingblocksupport[i]->SetLineColor(9);
4316         centermountingsupportshape[i] = new TGeoXtru(2);
4317     centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4318                                                                                                 xcentervertex[i],ycentervertex[i]);
4319         centermountingsupportshape[i]->DefineSection(0,0.);
4320     centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4321                                                                                                   -fgkMountingBlockSupportWidth[0]);
4322
4323     centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4324                                                                           centermountingsupportshape[i],
4325                                                                                   fSSDAlCoolBlockMedium);
4326         centermountingblocksupport[i]->SetLineColor(9);
4327         sideladdersupportpieceshape[i] = new TGeoXtru(2);
4328     sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4329                                                                                                 xsidelowervertex[i],ysidelowervertex[i]);
4330         sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4331                                                                                                          -fgkMountingBlockSupportWidth[0]);
4332     sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4333     sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4334                                                                           sideladdersupportpieceshape[i],
4335                                                                                   fSSDCarbonFiberMedium);
4336         sideladdersupportpiece[i]->SetLineColor(fColorAl);
4337         centerladdersupportpieceshape[i] = new TGeoXtru(2);
4338     centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4339                                                                                                 xcenterlowervertex[i],ycenterlowervertex[i]);
4340         centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4341     centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4342                                                                                                   -fgkMountingBlockSupportWidth[0]);
4343     centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4344                                                                           centerladdersupportpieceshape[i],
4345                                                                                   fSSDCarbonFiberMedium);
4346         centerladdersupportpiece[i]->SetLineColor(fColorAl);
4347   }
4348   /////////////////////////////////////////////////////////////
4349   // Building the Up Structure of Ladder Supports
4350   /////////////////////////////////////////////////////////////
4351   TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4352   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4353   TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4354   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4355   TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4356   //////////////////////////////////////////////////////////
4357   // Setting the volume for TGeoXtru Mounting Block Piece
4358   //////////////////////////////////////////////////////////
4359   TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4360   TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4361   TGeoVolume* mountingblockpiecedown[fgklayernumber];
4362   TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4363   TGeoVolume* mountingblockpieceup[fgklayernumber];
4364   Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4365   Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4366   Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4367   Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
4368   char mountingblockpiecedownname[100];
4369   char mountingblockpieceupname[100];
4370   for(Int_t i=0; i<fgklayernumber; i++){
4371     ///////////////////////////
4372     // Mounting Block Down Vertex
4373     ///////////////////////////
4374         mountingblockpiecedownshape[i] = new TGeoXtru(2);
4375     sprintf(mountingblockpiecedownname,"MountingBlockPieceDownLay%d",i+5);
4376         mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4377         mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4378                                               + fgkMountingBlockSupportDownHeight
4379                                               - fgkSSDLadderVerticalDisalignment;
4380         mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4381         mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4382                                                                                 + fgkSSDMountingBlockHeight[1]
4383                                                                                 - 0.5*fgkCoolingTubeSupportHeight
4384                                                                                 - fgkSSDModuleCoolingBlockToSensor;
4385         mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4386         mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4387         mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4388         mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4389         mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4390         mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4391         mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4392         mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4393                                                                                 + fgkSSDMountingBlockHeight[2]
4394                                                                                 - fgkSSDMountingBlockHeight[0];
4395         mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4396         mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4397         mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4398         mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4399         mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4400                                                                                                          mountingblockpiecedownyvertex[i]);
4401         mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4402         mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4403         mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
4404                                                                  mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
4405         mountingblockpiecedown[i]->SetLineColor(fColorG10);
4406
4407     ///////////////////////////
4408     // Mounting Block Up Vertex
4409     ///////////////////////////
4410         mountingblockpieceupshape[i] = new TGeoXtru(2);
4411         sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5);
4412         mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4413         mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4414                                                                                 + fgkMountingBlockSupportUpHeight[i]
4415                                               - fgkSSDLadderVerticalDisalignment;
4416         mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4417         mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4418                                                                                 + fgkSSDMountingBlockHeight[1]
4419                                                                                 - 0.5*fgkCoolingTubeSupportHeight
4420                                                                                 - fgkSSDModuleCoolingBlockToSensor;
4421         mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4422         mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4423         mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4424         mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4425         mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4426         mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4427         mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4428         mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4429                                                                                 + fgkSSDMountingBlockHeight[2]
4430                                                                                 - fgkSSDMountingBlockHeight[0];
4431         mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4432         mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4433         mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4434         mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
4435
4436         mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4437                                                                                                          mountingblockpieceupyvertex[i]);
4438         mountingblockpieceupshape[i]->DefineSection(0,0.0);
4439         mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4440         mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
4441                                                                 mountingblockpieceupshape[i],fSSDMountingBlockMedium);
4442         mountingblockpieceup[i]->SetLineColor(fColorG10);
4443  }
4444   ///////////////////////////////////////////////////////////////////
4445   // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4446   ///////////////////////////////////////////////////////////////////
4447   TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4448   TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4449   TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4450   TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4451   Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4452   Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4453   Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4454   Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
4455   char mountingblocksupportrapezoidowname[100];
4456   char mountingblocksupportrapezoidupname[100];
4457   Double_t scalefactor = 3./4.;
4458   for(Int_t i=0; i<fgklayernumber; i++){
4459   ////////////////////////////////////////////
4460   // Mounting Block Support Down Trapezoid Vertex
4461   ////////////////////////////////////////////
4462         mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4463         mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4464                                                                                                  - mountingsupportedge[i];
4465         mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4466         mountingblocksupportrapezoidownxvertex[i][1] =
4467                                                                                 mountingblocksupportrapezoidownxvertex[i][0];
4468         mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4469                                                                                                  + scalefactor*(mountingblockpiecedownyvertex[i][1]
4470                                                                                              - mountingblockpiecedownyvertex[i][0]);
4471         mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4472         mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4473         mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4474         mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4475         mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4476         mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
4477
4478         mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4479                                                                                                                mountingblocksupportrapezoidownyvertex[i]);
4480         mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4481                                                                                                                         -fgkMountingBlockSupportWidth[0]);
4482         mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4483         sprintf(mountingblocksupportrapezoidowname,"MountingBlockSuppTrapezoidDownLay%d",i+5);
4484         mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
4485                                                                 mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
4486         mountingblocksupportrapezoidown[i]->SetLineColor(9);
4487   ////////////////////////////////////////////
4488   // Mounting Block Support Up Trapezoid Vertex
4489   ////////////////////////////////////////////
4490         mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4491         mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4492                                                                                                  - mountingsupportedge[i];
4493         mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4494         mountingblocksupportrapezoidupxvertex[i][1] =
4495                                                                                 mountingblocksupportrapezoidupxvertex[i][0];
4496         mountingblocksupportrapezoidupyvertex[i][1] =
4497                                                                                                mountingblockpieceupyvertex[i][0]
4498                                                                                                  + scalefactor*(mountingblockpieceupyvertex[i][1]
4499                                                                                              - mountingblockpieceupyvertex[i][0]);
4500         mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4501         mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4502         mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4503         mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4504         mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4505         mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
4506
4507         mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4508                                                                                                                mountingblocksupportrapezoidupyvertex[i]);
4509         mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4510                                                                                                                         -fgkMountingBlockSupportWidth[0]);
4511         mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4512         sprintf(mountingblocksupportrapezoidupname,"MountingBlockSuppTrapezoidUpLay%d",i+5);
4513         mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
4514                                                                 mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
4515         mountingblocksupportrapezoidup[i]->SetLineColor(9);
4516   }
4517   ///////////////////////////////////////////////////////////////////
4518   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4519   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4520   Double_t boxoriginup[fgklayernumber][2][3];
4521   Double_t boxorigindown[fgklayernumber][2][3];
4522   char mountingblocksupportboxdownname[100];
4523   char mountingblocksupportboxupname[100];
4524   TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4525   mountingblocksupportrot->SetAngles(90.,180.,-90);
4526   TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4527   globalrefladdersupportrot->SetAngles(0.,90.,0.);
4528   TGeoHMatrix* laddersupportmatrix[2];
4529   laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4530   laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4531   /////////////////////////////////////////////////////////////
4532   // Creating Mother Volume for Containment
4533   /////////////////////////////////////////////////////////////
4534   Double_t *xmothervertex[fgklayernumber];
4535   Double_t *ymothervertex[fgklayernumber];
4536   for(Int_t i=0; i<fgklayernumber; i++){
4537         xmothervertex[i] = new Double_t[8];
4538         ymothervertex[i] = new Double_t[8];
4539   }
4540   TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4541   TGeoVolume* downmotherladdersupport[fgklayernumber];
4542   TGeoXtru* upmotherladdersupportshape[fgklayernumber];
4543   TGeoVolume* upmotherladdersupport[fgklayernumber];
4544   char upmotheladdersupportname[100];
4545   char downmotheladdersupportname[100];
4546   for(Int_t i=0; i<fgklayernumber; i++){
4547         xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4548                                                     -  mountingsupportedge[i];
4549         ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4550         xmothervertex[i][1] = xmothervertex[i][0];
4551         ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4552                                                         + fgkMountingBlockSupportWidth[0];
4553         xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4554         ymothervertex[i][2] = ymothervertex[i][1];
4555         xmothervertex[i][3] = xmothervertex[i][2];
4556         ymothervertex[i][3] = -ymothervertex[i][0];
4557         xmothervertex[i][4] = -xmothervertex[i][0];
4558         ymothervertex[i][4] = ymothervertex[i][3];
4559         xmothervertex[i][5] = xmothervertex[i][4];
4560         ymothervertex[i][5] = -ymothervertex[i][1];
4561         xmothervertex[i][6] = -xmothervertex[i][2];
4562         ymothervertex[i][6] = ymothervertex[i][5];
4563         xmothervertex[i][7] = xmothervertex[i][6];
4564         ymothervertex[i][7] = ymothervertex[i][0];
4565
4566         sprintf(downmotheladdersupportname,"LadderSupportDownLay%d",i+5);
4567         sprintf(upmotheladdersupportname,"LadderSupportUpLay%d",i+5);
4568
4569         downmotherladdersupportshape[i] = new TGeoXtru(2);
4570         downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4571         downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4572         downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4573                                                                    +                       fgkMountingBlockSupportDownHeight
4574                                                                    +                       fgkSSDMountingBlockHeight[1]
4575                                                                    -                       0.5*fgkCoolingTubeSupportHeight
4576                                                                    -                       fgkSSDModuleCoolingBlockToSensor
4577                                                        - fgkSSDLadderVerticalDisalignment);
4578
4579 //                                                 - fgkSSDModuleVerticalDisalignment);
4580         //downmotherladdersupport[i] = new TGeoVolumeAssembly(downmotheladdersupportname);
4581
4582         downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4583                                                                           downmotherladdersupportshape[i],fSSDAir);
4584     upmotherladdersupportshape[i] = new TGeoXtru(2);
4585         upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4586         upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4587     upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4588                                                                    +                       fgkMountingBlockSupportUpHeight[i]
4589                                                                    +                       fgkSSDMountingBlockHeight[1]
4590                                                                    -                       0.5*fgkCoolingTubeSupportHeight
4591                                                                    -                       fgkSSDModuleCoolingBlockToSensor
4592                                                  - fgkSSDLadderVerticalDisalignment);
4593
4594      upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4595                                                                                           upmotherladdersupportshape[i],fSSDAir);
4596   }
4597   for(Int_t i=0; i<fgklayernumber; i++){
4598         /////////////////////////
4599         // Setting the box origin
4600         /////////////////////////
4601         boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4602         boxorigindown[i][0][1] =  fgkMountingBlockSupportRadius[i]
4603                                                    +  0.5*fgkMountingBlockSupportDownHeight
4604                                   - 0.5*fgkSSDLadderVerticalDisalignment;
4605         boxorigindown[i][0][2] =  fgkMountingBlockSupportWidth[1]
4606                                                    -  0.5*fgkMountingBlockSupportWidth[0];
4607
4608         boxorigindown[i][1][0] = 0.0;
4609         boxorigindown[i][1][1] = boxorigindown[i][0][1];
4610         boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4611                                                    -      fgkMountingBlockSupportWidth[0]);
4612
4613         boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4614         boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
4615                                + 0.5*fgkMountingBlockSupportUpHeight[i]
4616                                - 0.5*fgkSSDLadderVerticalDisalignment;
4617         boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4618                                                  - 0.5*fgkMountingBlockSupportWidth[0];
4619
4620         boxoriginup[i][1][0] = 0.0;
4621         boxoriginup[i][1][1] = boxoriginup[i][0][1];
4622         boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4623                                                  - fgkMountingBlockSupportWidth[0]);
4624
4625         /////////////////////////
4626     // Setting the boxes
4627         /////////////////////////
4628         mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4629                                                                                  +  fgkSSDMountingBlockLength[0]),
4630                                                                                         0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
4631                                                                                         0.5*fgkMountingBlockSupportWidth[0],
4632                                                                                         boxorigindown[i][0]);
4633         mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4634                                                                                         0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
4635                                                                                         0.5*(fgkMountingBlockSupportWidth[1]
4636                                                                                  -  fgkMountingBlockSupportWidth[0]),
4637                                                                                         boxorigindown[i][1]);
4638
4639         mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4640                                                                                  +  fgkSSDMountingBlockLength[0]),
4641                                                                                         0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
4642                                                                                         0.5*fgkMountingBlockSupportWidth[0],
4643                                                                                         boxoriginup[i][0]);
4644
4645         mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4646                                                                                         0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
4647                                                                                         0.5*(fgkMountingBlockSupportWidth[1]
4648                                                                      -  fgkMountingBlockSupportWidth[0]),
4649                                                                                         boxoriginup[i][1]);
4650         ///////////////////////////////////////
4651         // Adding the Volumes to Mother Volume
4652         ///////////////////////////////////////
4653         for(Int_t j=0; j<2; j++){
4654                 sprintf(mountingblocksupportboxdownname,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4655                 sprintf(mountingblocksupportboxupname,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4656                 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4657                                                                                   mountingblocksupportboxdownshape[i][j],
4658                                                                                   fSSDCarbonFiberMedium);
4659                 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4660                                                                                   mountingblocksupportboxupshape[i][j],
4661                                                                                   fSSDCarbonFiberMedium);
4662                 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4663                 mountingblocksupportboxup[i][j]->SetLineColor(9);
4664                 for(Int_t k=0; k<2; k++){
4665                         downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
4666                         upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
4667                 }
4668         }
4669         for(Int_t k=0; k<2; k++){
4670                 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4671                 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4672                 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4673                 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4674                 downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
4675                 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4676                 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4677                 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4678                 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4679                 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4680                 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4681                 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
4682         }
4683   }
4684   TList* laddersupportlist = new TList();
4685   laddersupportlist->Add(downmotherladdersupport[0]);
4686   laddersupportlist->Add(upmotherladdersupport[0]);
4687   laddersupportlist->Add(downmotherladdersupport[1]);
4688   laddersupportlist->Add(upmotherladdersupport[1]);
4689   /////////////////////////////////////////////////////////////
4690   // Deallocating memory
4691   /////////////////////////////////////////////////////////////
4692   for(Int_t i=0; i<fgklayernumber; i++){
4693         for(Int_t j=0; j<nedges+1; j++)
4694                 delete vertex[i][j];
4695         delete mountingsupportedgevector[i];
4696         delete [] vertex[i];
4697         delete vertexlist[i];
4698         delete [] xsidevertex[i];
4699         delete [] ysidevertex[i];
4700         delete [] xcentervertex[i];
4701         delete [] ycentervertex[i];
4702         delete [] xsidelowervertex[i];
4703         delete [] ysidelowervertex[i];
4704         delete [] xcenterlowervertex[i];
4705         delete [] ycenterlowervertex[i];
4706         delete [] xmothervertex[i];
4707         delete [] ymothervertex[i];
4708   }
4709   delete [] xsidevertex;
4710   delete [] ysidevertex;
4711   delete [] xcentervertex;
4712   delete [] ycentervertex;
4713   delete [] xsidelowervertex;
4714   delete [] ysidelowervertex;
4715   delete [] xcenterlowervertex;
4716   delete [] ycenterlowervertex;
4717   delete globalrefladdersupportrot;
4718   delete mountingblocksupportrot;
4719   /////////////////////
4720   return laddersupportlist;
4721 }
4722  ////////////////////////////////////////////////////////////////////////////////
4723 void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4724 //////////////////////////////////////////
4725 // Method Generating Ladder Support Ring
4726 //////////////////////////////////////////
4727   if(!fCreateMaterials) CreateMaterials();
4728   if(!fTransformationMatrices) CreateTransformationMatrices();
4729   if(!fBasicObjects) CreateBasicObjects();
4730   fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4731   fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4732     const Int_t kssdlayladdernumber[fgklayernumber] =
4733                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4734   Double_t mountingsupportedge[fgklayernumber];
4735   Double_t mountingblockratio[fgklayernumber];
4736   Double_t theta[fgklayernumber];
4737   Double_t phi[fgklayernumber];
4738   for(Int_t i=0; i<fgklayernumber; i++){
4739         mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4740     mountingsupportedge[i]    = 0.5*fgkMountingBlockSupportRadius[i]
4741                                                           *(TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
4742                                                           * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4743                                                           - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4744                                                           / kssdlayladdernumber[i])));
4745     theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4746                          / fgkMountingBlockSupportRadius[i]);
4747     phi[i]   = TMath::ASin(0.5*mountingblockratio[i]);
4748   }
4749   TGeoRotation* globalrot = new TGeoRotation();
4750   globalrot->SetAngles(0.,-90.,0.);
4751   TGeoRotation** laddersupportrot[fgklayernumber];
4752   TGeoHMatrix**  laddersupportmatrix[fgklayernumber];
4753   for(Int_t i=0; i<fgklayernumber; i++){
4754         laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
4755         laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
4756         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4757                 laddersupportrot[i][j] = new TGeoRotation();
4758                 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
4759                 switch(i){
4760                         case 0: //Ladder of Layer5
4761                                 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4762                                 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
4763                                                                             laddersupportmatrix[i][j]);
4764                         break;
4765                         case 1: //Ladder of Layer6
4766                                 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4767                                 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
4768                                                                               laddersupportmatrix[i][j]);
4769                         break;
4770                 }
4771     }
4772   }
4773   /////////////////////////////////////////////////////////////
4774   // Creating Lower Ladder Support
4775   /////////////////////////////////////////////////////////////
4776   TVector3** ringsupportvertex[fgklayernumber];
4777   Double_t angle = 360./nedges;
4778   for(Int_t i=0; i<fgklayernumber; i++){
4779     ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
4780         ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
4781                                                         *                          TMath::Cos(theta[i]));
4782         ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
4783                                                         -                          mountingsupportedge[i],
4784                                                                                    ringsupportvertex[i][0]->Y());
4785         ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
4786                                                                                    ringsupportvertex[i][1]->Y());
4787     ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
4788         for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4789            ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
4790            ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
4791            ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
4792            ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
4793         }
4794         ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
4795     for(Int_t j=0; j<nedges+1; j++){
4796                 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
4797                         new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*CosD(90.0-j*angle),
4798                                                  (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*SinD(90.0-j*angle));
4799         }
4800   }
4801   Double_t **xmothervertex = new Double_t*[fgklayernumber];
4802   Double_t **ymothervertex = new Double_t*[fgklayernumber];
4803   for(Int_t i=0; i<fgklayernumber; i++){
4804         xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4805         ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4806         for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
4807                 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
4808                 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
4809         }
4810   }
4811 ////////////////////////////////////////////////////////////////////////////////
4812 // Start Corrections 13/06/08
4813 ////////////////////////////////////////////////////////////////////////////////
4814   char lowerladderpconsupportname[100];
4815   TGeoPcon* lowerladderpconsupportshape[fgklayernumber];
4816   TGeoVolume* lowerladderpconsupport[fgklayernumber];
4817   Double_t lowerladderpconezsection[2] = {0.,fgkMountingBlockSupportWidth[1]};
4818   Double_t lowerladderpconradiusmax[fgklayernumber];
4819   Double_t lowerladderpconradiusmin[fgklayernumber];
4820   TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4821   lowerladdersupportrot->SetAngles(90.,180.,-90);
4822   for(Int_t i=0; i<fgklayernumber; i++){
4823         lowerladderpconradiusmax[i] = fgkMountingBlockSupportRadius[i]
4824                                                                 *                          TMath::Cos(theta[i]);
4825     lowerladderpconradiusmin[i] = lowerladderpconradiusmax[i]-fgkLadderSupportHeight;
4826   }
4827   for(Int_t i=0; i<fgklayernumber; i++){
4828 ///////////////////////////  Modified Version ?///////////////////
4829     lowerladderpconsupportshape[i] = new TGeoPcon(0.,360.,2);
4830         for(Int_t j=0; j<2; j++) lowerladderpconsupportshape[i]->DefineSection(j,
4831                                                          lowerladderpconezsection[j],lowerladderpconradiusmin[i],
4832                                                          lowerladderpconradiusmax[i]);
4833         sprintf(lowerladderpconsupportname,"LowerLadderPConSupportNameLay%d",i+5);
4834         lowerladderpconsupport[i] = new TGeoVolume(lowerladderpconsupportname,lowerladderpconsupportshape[i],fSSDSupportRingAl);
4835     lowerladderpconsupport[i]->SetLineColor(fColorAl);
4836         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],1);
4837         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],2,lowerladdersupportrot);
4838  }
4839 ////////////////////////////////////////////////////////////////////////////////
4840 // End Corrections 13/06/08
4841 ////////////////////////////////////////////////////////////////////////////////
4842   /*char lowerladdersupportname[30];
4843   TGeoXtru* lowerladdersupportshape[fgklayernumber];
4844   TGeoVolume* lowerladdersupport[fgklayernumber];
4845   TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4846   lowerladdersupportrot->SetAngles(90.,180.,-90);
4847   for(Int_t i=0; i<fgklayernumber; i++){
4848         lowerladdersupportshape[i] = new TGeoXtru(2);
4849         lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
4850                                                                                           xmothervertex[i],ymothervertex[i]);
4851         lowerladdersupportshape[i]->DefineSection(0,0.);
4852     lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4853         sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
4854     lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
4855                                                         lowerladdersupportshape[i],fSSDSupportRingAl);
4856         lowerladdersupport[i]->SetLineColor(fColorAl);
4857         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
4858         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
4859   }*/
4860   /////////////////////////////////////////////////////////////
4861   // Deallocating memory
4862   /////////////////////////////////////////////////////////////
4863   for(Int_t i=0; i<fgklayernumber; i++){
4864         for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
4865                 delete ringsupportvertex[i][j];
4866         delete [] ringsupportvertex[i];
4867   }
4868   for(Int_t i=0; i<fgklayernumber; i++){
4869         delete [] xmothervertex[i];
4870         delete [] ymothervertex[i];
4871   }
4872   delete [] xmothervertex;
4873   delete [] ymothervertex;
4874   delete globalrot;
4875   for(Int_t i=0; i<fgklayernumber; i++){
4876         for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
4877                 delete laddersupportrot[i][j];
4878         delete [] laddersupportrot[i];
4879   }
4880  }
4881  ////////////////////////////////////////////////////////////////////////////////
4882  TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
4883   /////////////////////////////////////////////////////////////
4884   // Method generating Endcap CoverPlate
4885   /////////////////////////////////////////////////////////////
4886   // Holes Definition
4887   ///////////////////
4888   Int_t nendcapcoverplateholedges = 30;
4889   const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
4890   Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
4891                                                           0.5*fgkEndCapCoverPlateThickness};
4892   TGeoShape* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
4893                                                                                                               nendcapcoverplateholedges,holesection);
4894   TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
4895                                                                                   endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
4896   endcapcoverplatesmallhole->SetLineColor(6);
4897   TGeoShape* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
4898                                                                                                               nendcapcoverplateholedges,holesection);
4899   TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
4900                                                                                   endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
4901   endcapcoverplatebighole->SetLineColor(6);
4902   //////////////////////////
4903   // Screw Piece Definition
4904   //////////////////////////
4905   Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
4906   TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
4907                                                                                                       CosD(0.5*smallscrewangle),
4908                                                                                                       0.5*fgkEndCapCoverPlateThickness);
4909   TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
4910                                                                                                 endcapsmallscrewpieceshape,
4911                                                                                                 fSSDCoolingTubePhynox);
4912   endcapsmallscrewpiece->SetLineColor(fColorPhynox);
4913   ///////////////////
4914   // Box Definition
4915   ///////////////////
4916   TGeoBBox* endcapcoverplateboxshape[4];
4917   TGeoVolume* endcapcoverplatebox[4];
4918   Double_t boxorigin[5][3];
4919   boxorigin[0][0] = 0.;
4920   boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
4921   boxorigin[0][2] = 0.;
4922
4923   boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
4924   boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
4925   boxorigin[1][2] = 0.;
4926
4927   boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
4928                                   + fgkEndCapCoverPlateSmallHoleSeparation[1];
4929   boxorigin[2][1] = boxorigin[1][1];
4930   boxorigin[2][2] = 0.;
4931
4932   boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
4933                                   + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
4934   boxorigin[3][1] = boxorigin[1][1];
4935   boxorigin[3][2] = 0.;
4936
4937   endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4938                                                                                 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
4939                                                  -              2.*fgkEndCapCoverPlateSmallHoleRadius),
4940                                                                             0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
4941
4942   endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4943                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
4944                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4945                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
4946                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
4947
4948   endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4949                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
4950                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4951                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
4952                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
4953
4954   endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
4955                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
4956                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4957                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
4958                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
4959
4960   endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
4961                                                                            fSSDAlCoolBlockMedium);
4962   endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
4963                                                                            fSSDAlCoolBlockMedium);
4964   endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
4965                                                                            fSSDAlCoolBlockMedium);
4966   endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
4967                                                                            fSSDAlCoolBlockMedium);
4968   endcapcoverplatebox[0]->SetLineColor(6);
4969   endcapcoverplatebox[1]->SetLineColor(6);
4970   endcapcoverplatebox[2]->SetLineColor(6);
4971   endcapcoverplatebox[3]->SetLineColor(6);
4972   Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
4973   TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4974                                                                                         fgkEndCapCoverPlateSmallHoleRadius,
4975                                                                                         0.5*fgkEndCapCoverPlateThickness,
4976                                                                                         endcapfillingboxorigin);
4977   TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
4978                                                                            fSSDAlCoolBlockMedium);
4979   endcapfillingbox->SetLineColor(6);
4980   ////////////////////////////
4981   // Contour shape Definition
4982   ////////////////////////////
4983   const Int_t kcontourvertexnumber = 10;
4984   Double_t xcontourvertex[kcontourvertexnumber];
4985   Double_t ycontourvertex[kcontourvertexnumber];
4986   xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
4987   xcontourvertex[1] = xcontourvertex[0];
4988   xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
4989   xcontourvertex[3] = xcontourvertex[2];
4990   xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
4991   xcontourvertex[5] = xcontourvertex[4];
4992   xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
4993   xcontourvertex[7] = xcontourvertex[6];
4994   xcontourvertex[8] = xcontourvertex[4];
4995   xcontourvertex[9] = xcontourvertex[8];
4996   ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
4997                                         - (kendcapcoverplatesmallholenumber[1]-1)
4998                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]);
4999   ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
5000                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5001   ycontourvertex[2] = ycontourvertex[1];
5002   ycontourvertex[3] = ycontourvertex[0];
5003   ycontourvertex[4] = ycontourvertex[3];
5004   ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
5005   ycontourvertex[6] = ycontourvertex[5];
5006   ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
5007                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]
5008                                         + fgkEndCapCoverPlateSmallHoleRadius;
5009   ycontourvertex[8] = ycontourvertex[7];
5010   ycontourvertex[9] = ycontourvertex[0];
5011
5012   Double_t xboxin, dxboxin, yboxin, dyboxin;
5013   Double_t xboxout, dxboxout, yboxout, dyboxout;
5014   Double_t coordmin, coordmax;
5015   coordmin = -fgkEndCapCoverPlateLength[0];
5016   coordmax = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5017   xboxout = 0.5*(coordmin+coordmax);
5018   dxboxout = 0.5*(coordmax-coordmin);
5019   coordmin = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5020                                         - (kendcapcoverplatesmallholenumber[1]-1)
5021                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5022   coordmax = (kendcapcoverplatesmallholenumber[1]-1)
5023                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5024   yboxout = 0.5*(coordmin+coordmax);
5025   dyboxout = 0.5*(coordmax-coordmin);
5026   coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
5027   coordmax = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5028   xboxin = 0.5*(coordmin+coordmax);
5029   dxboxin = 0.5*(coordmax-coordmin);
5030   coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
5031   coordmax = (kendcapcoverplatesmallholenumber[1]-1)
5032                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]
5033                                         + fgkEndCapCoverPlateSmallHoleRadius;
5034   yboxin = 0.5*(coordmin+coordmax);
5035   dyboxin = 0.5*(coordmax-coordmin);
5036   new TGeoBBox("EndCapCoverPlateContourBoxOut", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5037   TGeoTranslation *trendCapCoverPlateContourboxout = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut",
5038                                                          xboxout, yboxout, 0.);
5039   trendCapCoverPlateContourboxout->RegisterYourself();
5040   new TGeoBBox("EndCapCoverPlateContourBoxIn",  dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5041   TGeoTranslation *trendCapCoverPlateContourboxin = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn",
5042                                                          xboxin, yboxin, 0.);
5043   trendCapCoverPlateContourboxin->RegisterYourself();
5044   TGeoCompositeShape *contourshape = new TGeoCompositeShape("contourShape",
5045         "EndCapCoverPlateContourBoxOut:SSD_trEndCapCoverPlateContourBoxOut-EndCapCoverPlateContourBoxIn:SSD_trEndCapCoverPlateContourBoxIn");
5046
5047   TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5048                                                                            fSSDAlCoolBlockMedium);
5049   contour->SetLineColor(6);
5050   /////////////////////////////
5051   // Hole Contour Shape Definition
5052   ////////////////////////////
5053   coordmin = xcontourvertex[0];
5054   coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5055   xboxout = 0.5*(coordmin+coordmax);
5056   dxboxout = 0.5*(coordmax-coordmin);
5057   coordmin = ycontourvertex[1];
5058   coordmax = ycontourvertex[1]+fgkEndCapCoverPlateWidth[2];
5059   yboxout = 0.5*(coordmin+coordmax);
5060   dyboxout = 0.5*(coordmax-coordmin);
5061   coordmin = xcontourvertex[0]+ 0.5*(fgkEndCapCoverPlateLength[2]
5062                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5063   coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5064   xboxin = 0.5*(coordmin+coordmax);
5065   dxboxin = 0.5*(coordmax-coordmin);
5066   coordmin = ycontourvertex[1]+0.5*(fgkEndCapCoverPlateWidth[2]
5067                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);;
5068   coordmax = coordmin +2.*fgkEndCapCoverPlateBigHoleRadius;
5069   yboxin = 0.5*(coordmin+coordmax);
5070   dyboxin = 0.5*(coordmax-coordmin);
5071   new TGeoBBox("EndCapCoverPlateContourBoxOut1", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5072   TGeoTranslation *trendCapCoverPlateContourboxout1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut1",
5073                                                          xboxout, yboxout, 0.);
5074   trendCapCoverPlateContourboxout1->RegisterYourself();
5075   new TGeoBBox("EndCapCoverPlateContourBoxIn1",  dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5076   TGeoTranslation *trendCapCoverPlateContourboxin1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn1",
5077                                                          xboxin, yboxin, 0.);
5078   trendCapCoverPlateContourboxin1->RegisterYourself();
5079   TGeoCompositeShape *contourshape1 = new TGeoCompositeShape("contourShape1",
5080         "EndCapCoverPlateContourBoxOut1:SSD_trEndCapCoverPlateContourBoxOut1-EndCapCoverPlateContourBoxIn1:SSD_trEndCapCoverPlateContourBoxIn1");
5081
5082
5083   coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5084   coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5085   xboxout = 0.5*(coordmin+coordmax);
5086   dxboxout = 0.5*(coordmax-coordmin);
5087   coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5088                                                    - fgkEndCapCoverPlateWidth[0]);
5089   coordmax = ycontourvertex[0];
5090   yboxout = 0.5*(coordmin+coordmax);
5091   dyboxout = 0.5*(coordmax-coordmin);
5092   coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5]+ 0.5*(fgkEndCapCoverPlateLength[2]
5093                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5094   coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5095   xboxin = 0.5*(coordmin+coordmax);
5096   dxboxin = 0.5*(coordmax-coordmin);
5097   coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5098                                                    - fgkEndCapCoverPlateWidth[0])+0.5*(fgkEndCapCoverPlateWidth[1]
5099                                                    - fgkEndCapCoverPlateWidth[0]
5100                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5101   coordmax = coordmin+2.*fgkEndCapCoverPlateBigHoleRadius;
5102   yboxin = 0.5*(coordmin+coordmax);
5103   dyboxin = 0.5*(coordmax-coordmin);
5104   new TGeoBBox("EndCapCoverPlateContourBoxOut2", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5105   TGeoTranslation *trendCapCoverPlateContourboxout2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut2",
5106                                                          xboxout, yboxout, 0.);
5107   trendCapCoverPlateContourboxout2->RegisterYourself();
5108   new TGeoBBox("EndCapCoverPlateContourBoxIn2",  dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5109   TGeoTranslation *trendCapCoverPlateContourboxin2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn2",
5110                                                          xboxin, yboxin, 0.);
5111   trendCapCoverPlateContourboxin2->RegisterYourself();
5112   TGeoCompositeShape *contourshape2 = new TGeoCompositeShape("contourShape2",
5113         "EndCapCoverPlateContourBoxOut2:SSD_trEndCapCoverPlateContourBoxOut2-EndCapCoverPlateContourBoxIn2:SSD_trEndCapCoverPlateContourBoxIn2");
5114
5115 //  const Int_t kholecontourvertexnumber = 10;
5116
5117   Double_t xholecontourvertex[2][kcontourvertexnumber];
5118   Double_t yholecontourvertex[2][kcontourvertexnumber];
5119   xholecontourvertex[0][0] = xcontourvertex[0];
5120   xholecontourvertex[0][1] = xholecontourvertex[0][0];
5121   xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5122   xholecontourvertex[0][3] = xholecontourvertex[0][2];
5123   xholecontourvertex[0][4] = xholecontourvertex[0][0]
5124                                                    + 0.5*(fgkEndCapCoverPlateLength[2]
5125                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5126   xholecontourvertex[0][5] = xholecontourvertex[0][4];
5127   xholecontourvertex[0][6] = xholecontourvertex[0][5]
5128                                                    + 2.*fgkEndCapCoverPlateBigHoleRadius;
5129   xholecontourvertex[0][7] = xholecontourvertex[0][6];
5130   xholecontourvertex[0][8] = xholecontourvertex[0][4];
5131   xholecontourvertex[0][9] = xholecontourvertex[0][8];
5132
5133   yholecontourvertex[0][0] = ycontourvertex[1];
5134   yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5135   yholecontourvertex[0][2] = yholecontourvertex[0][1];
5136   yholecontourvertex[0][3] = yholecontourvertex[0][0];
5137   yholecontourvertex[0][4] = yholecontourvertex[0][3];
5138   yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5139                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5140   yholecontourvertex[0][6] = yholecontourvertex[0][5];
5141   yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5142   yholecontourvertex[0][8] = yholecontourvertex[0][7];
5143   yholecontourvertex[0][9] = yholecontourvertex[0][0];
5144
5145   xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5146   xholecontourvertex[1][1] = xholecontourvertex[1][0];
5147   xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5148   xholecontourvertex[1][3] = xholecontourvertex[1][2];
5149   xholecontourvertex[1][4] = xholecontourvertex[1][0]
5150                                                    + 0.5*(fgkEndCapCoverPlateLength[2]
5151                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5152   xholecontourvertex[1][5] = xholecontourvertex[1][4];
5153   xholecontourvertex[1][6] = xholecontourvertex[1][5]
5154                                                    + 2.*fgkEndCapCoverPlateBigHoleRadius;
5155   xholecontourvertex[1][7] = xholecontourvertex[1][6];
5156   xholecontourvertex[1][8] = xholecontourvertex[1][4];
5157   xholecontourvertex[1][9] = xholecontourvertex[1][8];
5158
5159   yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5160                                                    - fgkEndCapCoverPlateWidth[0]);
5161   yholecontourvertex[1][1] = ycontourvertex[0];
5162   yholecontourvertex[1][2] = yholecontourvertex[1][1];
5163   yholecontourvertex[1][3] = yholecontourvertex[1][0];
5164   yholecontourvertex[1][4] = yholecontourvertex[1][3];
5165   yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5166                                                    - fgkEndCapCoverPlateWidth[0]
5167                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5168   yholecontourvertex[1][6] = yholecontourvertex[1][5];
5169   yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5170   yholecontourvertex[1][8] = yholecontourvertex[1][7];
5171   yholecontourvertex[1][9] = yholecontourvertex[1][0];
5172
5173   TGeoVolume* holecontour[2];
5174   holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",contourshape1,
5175                                                                   fSSDAlCoolBlockMedium);
5176   holecontour[0]->SetLineColor(6);
5177   holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",contourshape2,
5178                                                                   fSSDAlCoolBlockMedium);
5179   holecontour[1]->SetLineColor(6);
5180   TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5181                                                                         +     fgkEndCapCoverPlateLength[2],0.,0.);
5182   TGeoTranslation*  bigholetrans[3];
5183   bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5184                                                                                 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5185   bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5186                                   +                     fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5187                                   -                                             fgkEndCapCoverPlateBigHoleRadius,0.0);
5188   bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5189                                                                                 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5190   /////////////////////////////////
5191   // Mother Volume Xtru Definition
5192   /////////////////////////////////
5193   const Int_t kmothervertexnumber = 12;
5194   Double_t xmothervertex[kmothervertexnumber];
5195   Double_t ymothervertex[kmothervertexnumber];
5196   xmothervertex[0]  = xcontourvertex[0];
5197   xmothervertex[1]  = xmothervertex[0];
5198   xmothervertex[2]  = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5199   xmothervertex[3]  = xmothervertex[2];
5200   xmothervertex[4]  = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5201   xmothervertex[5]  = xmothervertex[4];
5202   xmothervertex[6]  = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5203   xmothervertex[7]  = xmothervertex[6];
5204   xmothervertex[8]  = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5205                                         + fgkEndCapCoverPlateLength[2];
5206   xmothervertex[9]  = xmothervertex[8];
5207   xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5208   xmothervertex[11] = xmothervertex[10];
5209
5210   ymothervertex[0]  = ycontourvertex[0];
5211   ymothervertex[1]  = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5212   ymothervertex[2]  = ymothervertex[1];
5213   ymothervertex[3]  = ycontourvertex[1];
5214   ymothervertex[4]  = ymothervertex[3];
5215   ymothervertex[5]  = ymothervertex[1];
5216   ymothervertex[6]  = ymothervertex[5];
5217   ymothervertex[7]  = ymothervertex[0];
5218   ymothervertex[8]  = ymothervertex[7];
5219   ymothervertex[9]  = ymothervertex[8]
5220                                    - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5221   ymothervertex[10] = ymothervertex[9];
5222   ymothervertex[11] = ymothervertex[8];
5223   TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5224   mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5225   mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5226   mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5227   TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5228   ////////////////////////////////////////
5229   // Adding Nodes
5230   ////////////////////////////////////////
5231 //  TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5232   TGeoTranslation*** endcapcoverplatesmallholetrans;
5233   endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5234   Double_t transx[4] = {0,
5235                                                 fgkEndCapCoverPlateSmallHoleSeparation[0],
5236                                                 fgkEndCapCoverPlateSmallHoleSeparation[0]
5237                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1],
5238                                          2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5239                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1]};
5240   Int_t index = 0;
5241   for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5242         endcapcoverplatesmallholetrans[i] =
5243                                         new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5244     for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5245                 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5246             endcapcoverplatesmallholetrans[i][j] =
5247                 new TGeoTranslation(transx[i],
5248                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5249             if(index!=10){
5250                         mothercoverplate->AddNode(endcapcoverplatesmallhole,
5251                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5252                         mothercoverplate->AddNode(endcapsmallscrewpiece,
5253                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5254                 }
5255                 if(j<kendcapcoverplatesmallholenumber[1]-1)
5256                         mothercoverplate->AddNode(endcapcoverplatebox[0],
5257                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5258     }
5259   }
5260   mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5261   mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5262   mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5263   mothercoverplate->AddNode(endcapfillingbox,1);
5264   mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5265   mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5266   mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5267   mothercoverplate->AddNode(holecontour[0],1);
5268   mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5269   mothercoverplate->AddNode(holecontour[1],1);
5270   mothercoverplate->AddNode(contour,1);
5271   /////////////////////////////////
5272   return mothercoverplate;
5273  }
5274  ////////////////////////////////////////////////////////////////////////////////
5275  TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5276   /////////////////////////////////////////////////////////////
5277   // Getting EndCap Cooling Tube
5278   /////////////////////////////////////////////////////////////
5279   TGeoTorus* endcapcoolingtubetorushape[5];
5280   TGeoVolume* endcapcoolingtubetorus[5];
5281   TGeoTube* endcapcoolingtubeshape[4];
5282   TGeoVolume* endcapcoolingtube[4];
5283   char endcapcoolingtubetorusname[100];
5284   char endcapcoolingtubename[100];
5285   TGeoTorus* endcapcoolingwatertubetorushape[5];
5286   TGeoVolume* endcapcoolingwatertubetorus[5];
5287   TGeoTube* endcapcoolingwatertubeshape[4];
5288   TGeoVolume* endcapcoolingwatertube[4];
5289   char endcapcoolingwatertubetorusname[100];
5290   char endcapcoolingwatertubename[100];
5291   for(Int_t i=0; i<5; i++){
5292         sprintf(endcapcoolingtubetorusname,"EndCapCoolingTubeTorus%d",i+1);
5293         sprintf(endcapcoolingtubename,"EndCapCoolingTube%d",i+1);
5294         sprintf(endcapcoolingwatertubetorusname,"EndCapCoolingWaterTubeTorus%d",i+1);
5295         sprintf(endcapcoolingwatertubename,"EndCapCoolingWaterTube%d",i+1);
5296         if(i==3){
5297                 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5298                                                                                 fgkEndCapCoolingTubeRadiusMin,
5299                                                                                 fgkEndCapCoolingTubeRadiusMax,
5300                                                                                 90.0,fgkEndCapCoolingTubeAngle[3]);
5301                 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5302                                                                                 0.,fgkEndCapCoolingTubeRadiusMin,
5303                                                                                 90.0,fgkEndCapCoolingTubeAngle[3]);
5304     }
5305         else{
5306                 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5307                                                                           :fgkEndCapCoolingTubeAxialRadius[1],
5308                                                                            fgkEndCapCoolingTubeRadiusMin,
5309                                                                            fgkEndCapCoolingTubeRadiusMax,
5310                                                                     0.,fgkEndCapCoolingTubeAngle[i]);
5311                 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5312                                                                                :fgkEndCapCoolingTubeAxialRadius[1],
5313                                                                                  0.,fgkEndCapCoolingTubeRadiusMin,
5314                                                                          0.,fgkEndCapCoolingTubeAngle[i]);
5315         }
5316         endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5317                                                                                            endcapcoolingtubetorushape[i],
5318                                                                                            fSSDCoolingTubePhynox);
5319         endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5320                                                                                                         endcapcoolingwatertubetorushape[i],
5321                                                                                                         fSSDCoolingTubeWater);
5322     endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5323     endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5324     if(i<4){
5325                 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5326                                                                   fgkEndCapCoolingTubeRadiusMax,
5327                                                           0.5*fgkEndCapCoolingTubeLength[i]);
5328                 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5329                                                           0.5*fgkEndCapCoolingTubeLength[i]);
5330         endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5331                                                          endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5332         endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5333                                                          endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5334                 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5335                 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5336         }
5337   }
5338   TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5339   /////////////////////////////////////////
5340   // Transformation for Volume Positioning
5341   /////////////////////////////////////////
5342   TGeoCombiTrans* coolingtubecombitrans[6];
5343   TGeoRotation* coolingtuberot[8];
5344   TGeoTranslation* coolingtubetrans[6];
5345   TGeoHMatrix* coolingtubematrix[4];
5346   TGeoCombiTrans* torustubecombitrans[4];
5347   TGeoRotation* torustuberot[7];
5348   TGeoTranslation* torustubetrans[4];
5349   TGeoHMatrix* torustubematrix[5];
5350   TGeoCombiTrans* coolingwatertubecombitrans[6];
5351   TGeoRotation* coolingwatertuberot[8];
5352   TGeoTranslation* coolingwatertubetrans[6];
5353   TGeoHMatrix* coolingwatertubematrix[4];
5354   TGeoCombiTrans* toruswatertubecombitrans[4];
5355   TGeoRotation* toruswatertuberot[7];
5356   TGeoTranslation* toruswatertubetrans[4];
5357   TGeoHMatrix* toruswatertubematrix[5];
5358   for(Int_t i=0; i<8; i++){
5359     if(i<6){
5360          coolingtubetrans[i] = new TGeoTranslation();
5361          coolingwatertubetrans[i] = new TGeoTranslation();
5362     }
5363     if(i<8){
5364          coolingtuberot[i] = new TGeoRotation();
5365          coolingwatertuberot[i] = new TGeoRotation();
5366     }
5367     if(i<4){
5368          torustubetrans[i] = new TGeoTranslation();
5369          toruswatertubetrans[i] = new TGeoTranslation();
5370     }
5371     if(i<7){
5372          torustuberot[i] = new TGeoRotation();
5373          toruswatertuberot[i] = new TGeoRotation();
5374         }
5375   }
5376   /////////////////////////////////////////
5377   // Transformation for Inox Volume Positioning
5378   /////////////////////////////////////////
5379   coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5380                                                                           -endcapcoolingtubeshape[0]->GetDz(),0.);
5381   coolingtuberot[0]->SetAngles(0.,90.,0.);
5382   coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5383                                                                                                 *coolingtuberot[0]);
5384
5385   coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5386   coolingtuberot[1]->SetAngles(0.,90.,0.);
5387   coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5388                                                                                                 *coolingtuberot[1]);
5389
5390   coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5391                                                                          *CosD(fgkEndCapCoolingTubeAngle[0]),
5392                                                                           fgkEndCapCoolingTubeAxialRadius[0]
5393                                                                          *SinD(fgkEndCapCoolingTubeAngle[0]),
5394                                                                           0.);
5395   coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5396   coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5397                                                                                                 *coolingtuberot[2]);
5398
5399   coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5400                                            *                             (*coolingtubecombitrans[1]));
5401
5402   torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5403                                                                          endcapcoolingtubeshape[1]->GetDz());
5404   torustuberot[0]->SetAngles(0.,90.,0.);
5405   torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5406
5407   torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5408
5409   coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5410                                                                           -endcapcoolingtubeshape[2]->GetDz(),0.);
5411   coolingtuberot[3]->SetAngles(0.,90.,0.);
5412   coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5413                                                                                                 *coolingtuberot[3]);
5414   coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5415   coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5416   coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5417
5418   torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5419                                                                         endcapcoolingtubeshape[2]->GetDz());
5420   torustuberot[1]->SetAngles(0.,90.,0.);
5421   torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5422   torustuberot[2]->SetAngles(180.,0.,0.);
5423   torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5424   torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5425
5426   torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5427                                                                         -fgkEndCapCoolingTubeAxialRadius[0]);
5428   torustuberot[3]->SetAngles(0.,90.,0.);
5429   torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5430   torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5431   torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5432   torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5433
5434   coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5435                                                                           fgkEndCapCoolingTubeAxialRadius[0],0.);
5436   coolingtuberot[5]->SetAngles(90.,90.,-90.);
5437   coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5438                                                                                                 *coolingtuberot[5]);
5439   coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5440   coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5441   coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5442
5443   torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5444                                                                         endcapcoolingtubeshape[0]->GetDz());
5445   torustuberot[5]->SetAngles(0.,90.,0.);
5446   torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5447   torustuberot[6]->SetAngles(-90.,0.,0.);
5448   torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5449   torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5450
5451   coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5452                                                                           endcapcoolingtubeshape[3]->GetDz(),0.);
5453   coolingtuberot[6]->SetAngles(0.,90.,0.);
5454   coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5455                                                                                                 *coolingtuberot[6]);
5456   coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5457   coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5458   coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5459     /////////////////////////////////////////
5460   // Transformation for Water Volume Positioning
5461   /////////////////////////////////////////
5462   coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5463                                                                           -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5464   coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5465   coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5466                                                                                                      *coolingwatertuberot[0]);
5467
5468   coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5469   coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5470   coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5471                                                                                                      *coolingwatertuberot[1]);
5472
5473   coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5474                                                                                   *CosD(fgkEndCapCoolingTubeAngle[0]),
5475                                                                                   fgkEndCapCoolingTubeAxialRadius[0]
5476                                                                                   *SinD(fgkEndCapCoolingTubeAngle[0]),
5477                                                                               0.);
5478   coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5479   coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5480                                                                                                     *coolingwatertuberot[2]);
5481
5482   coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5483                                            *                                 (*coolingwatertubecombitrans[1]));
5484
5485   toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5486                                                                          endcapcoolingwatertubeshape[1]->GetDz());
5487   toruswatertuberot[0]->SetAngles(0.,90.,0.);
5488   toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5489                                                                                                    *toruswatertuberot[0]);
5490
5491   toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5492                                                   *                                     (*toruswatertubecombitrans[0]));
5493
5494   coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5495                                                                           -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5496   coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5497   coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5498                                                                                                      *coolingwatertuberot[3]);
5499   coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5500   coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5501                                                         *                                 (*coolingwatertubecombitrans[3]));
5502   coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5503
5504   toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5505                                                                         endcapcoolingwatertubeshape[2]->GetDz());
5506   toruswatertuberot[1]->SetAngles(0.,90.,0.);
5507   toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5508                                                                                                    *toruswatertuberot[1]);
5509   toruswatertuberot[2]->SetAngles(180.,0.,0.);
5510   toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5511                                                   *                 (*toruswatertubecombitrans[1]));
5512   toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5513
5514   toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5515                                                                                    -fgkEndCapCoolingTubeAxialRadius[0]);
5516   toruswatertuberot[3]->SetAngles(0.,90.,0.);
5517   toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5518                                                                                                    *toruswatertuberot[3]);
5519   toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5520   toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5521                                                   *                                     (*toruswatertubecombitrans[2]));
5522   toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5523
5524   coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5525                                                                                 fgkEndCapCoolingTubeAxialRadius[0],0.);
5526   coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5527   coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5528                                                                                                      *coolingwatertuberot[5]);
5529   coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5530   coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5531                                                         *                                 (*coolingwatertubecombitrans[4]));
5532   coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5533
5534   toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5535                                                                               endcapcoolingwatertubeshape[0]->GetDz());
5536   toruswatertuberot[5]->SetAngles(0.,90.,0.);
5537   toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5538                                                                                                    *toruswatertuberot[5]);
5539   toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5540   toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5541                                                   *                 (*toruswatertubecombitrans[3]));
5542   toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5543
5544   coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5545                                                                           endcapcoolingwatertubeshape[3]->GetDz(),0.);
5546   coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5547   coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5548                                                                                                      *coolingwatertuberot[6]);
5549   coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5550   coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5551                                                         *                                 (*coolingwatertubecombitrans[5]));
5552   coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5553   /////////////////////////////////////////
5554   // Positioning Volumes
5555   /////////////////////////////////////////
5556   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5557   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5558
5559   endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5560   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5561
5562   endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5563   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5564
5565   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5566   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5567
5568   endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5569   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5570
5571   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5572   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5573
5574   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5575   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5576
5577   endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5578   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5579
5580   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5581   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5582
5583   endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5584   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5585   /////////////////////////////////////////////////////////////
5586   // Deallocating memory
5587   /////////////////////////////////////////////////////////////
5588   for(Int_t i=0; i<8; i++){
5589     if(i<6){
5590          delete coolingtubetrans[i];
5591          delete coolingwatertubetrans[i];
5592          if(i!=0){
5593           delete coolingtubecombitrans[i];
5594           delete coolingwatertubecombitrans[i];
5595          }
5596         }
5597     if(i<8){
5598           delete coolingtuberot[i];
5599           delete coolingwatertuberot[i];
5600     }
5601     if(i<4){
5602                 delete torustubetrans[i];
5603                 delete toruswatertubetrans[i];
5604                 delete torustubecombitrans[i];
5605                 delete toruswatertubecombitrans[i];
5606         }
5607     if(i<7){
5608          delete torustuberot[i];
5609          delete toruswatertuberot[i];
5610         }
5611   }
5612   /////////////////////////////////////////////////////////////
5613   return endcapcoolingtubemother;
5614  }
5615  ////////////////////////////////////////////////////////////////////////////////
5616  TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5617   /////////////////////////////////////////////////////////////
5618   // Getting EndCap Cover Side
5619   /////////////////////////////////////////////////////////////
5620   const Int_t kendcapcoverholenumber[2] = {7,5};
5621   const Int_t kvertexnumber = 15;
5622   Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5623   xvertex[0]  = 0.0;
5624   xvertex[1]  = xvertex[0];
5625   xvertex[2]  = fgkEndCapSideCoverLength[0];
5626   xvertex[3]  = fgkEndCapSideCoverLength[1];
5627   xvertex[4]  = xvertex[3];
5628   xvertex[5]  = fgkEndCapSideCoverLength[2];
5629   xvertex[6]  = xvertex[5];
5630   xvertex[7]  = xvertex[2];
5631   xvertex[8]  = xvertex[7];
5632   xvertex[9]  = xvertex[6]-fgkEndCapSideCoverLength[0];
5633   xvertex[10] = xvertex[9];
5634   xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5635                           * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5636                           * fgkEndCapSideCoverLength[4];
5637   xvertex[12] = xvertex[11];
5638   xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5639                           * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5640                           * fgkEndCapSideCoverLength[4];
5641   xvertex[14] = xvertex[13];
5642   yvertex[0]  = 0.0;
5643   yvertex[1]  = fgkEndCapSideCoverWidth[0];
5644   yvertex[2]  = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5645   yvertex[3]  = yvertex[2];
5646   yvertex[4]  = fgkEndCapSideCoverWidth[1];
5647   yvertex[5]  = yvertex[4];
5648   yvertex[6]  = yvertex[0];
5649   yvertex[7]  = yvertex[6];
5650   yvertex[8]  = fgkEndCapSideCoverWidth[6];
5651   yvertex[9]  = yvertex[8];
5652   yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5653   yvertex[11] = yvertex[10];
5654   yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5655   yvertex[13] = yvertex[12];
5656   yvertex[14] = yvertex[6];
5657   TGeoXtru* endcapsidecovershapeout = new TGeoXtru(2);
5658   endcapsidecovershapeout->SetName("endcapsidecovershapeout");
5659   endcapsidecovershapeout->DefinePolygon(7,xvertex,yvertex);
5660   endcapsidecovershapeout->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5661   endcapsidecovershapeout->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5662   TGeoXtru* endcapsidecovershapein = new TGeoXtru(2);
5663   endcapsidecovershapein->SetName("endcapsidecovershapein");
5664   endcapsidecovershapein->DefinePolygon(6,&xvertex[8],&yvertex[8]);
5665   endcapsidecovershapein->DefineSection(0,-0.5*fgkEndCapSideCoverThickness-0.01);
5666   endcapsidecovershapein->DefineSection(1,0.5*fgkEndCapSideCoverThickness+0.01);
5667
5668
5669   TGeoCompositeShape* endcapsidecovershape = new TGeoCompositeShape("endcapsidecovershape", "endcapsidecovershapeout-endcapsidecovershapein");
5670   TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5671                                                                 endcapsidecovershape,fSSDCoolingTubePhynox);
5672   endcapsidecover->SetLineColor(fColorPhynox);
5673   ////////////////////////////////////////////
5674   // Defininition of Mother Volume
5675   ////////////////////////////////////////////
5676   const Int_t kmothervertexnumber = 7;
5677   Double_t xmothervertex[kmothervertexnumber];
5678   Double_t ymothervertex[kmothervertexnumber];
5679   for(Int_t i=0; i<kmothervertexnumber; i++){
5680         xmothervertex[i] = xvertex[i];
5681         ymothervertex[i] = yvertex[i];
5682   }
5683   TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5684   endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5685   endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5686   endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5687   TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5688                                                                 endcapsidecovermothershape,fSSDAir);
5689   ////////////////////////////////////////////
5690   endcapsidecovermother->AddNode(endcapsidecover,1);
5691   TGeoBBox* endcapsidecoverboxshape[4];
5692   endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5693                                                          +     (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5694                                                                0.5*fgkEndCapSideCoverLength[4],
5695                                                                    0.5*fgkEndCapSideCoverThickness);
5696   endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5697                                                          +     (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5698                                                                0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5699                                                          -     fgkEndCapSideCoverLength[4]),
5700                                                                    0.5*fgkEndCapSideCoverThickness);
5701   endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5702                                                                0.5*fgkEndCapSideCoverLength[4],
5703                                                                    0.5*fgkEndCapSideCoverThickness);
5704   endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5705                                                                0.5*fgkEndCapSideCoverWidth[5],
5706                                                                    0.5*fgkEndCapSideCoverThickness);
5707   TGeoVolume* endcapsidecoverbox[4];
5708   endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5709   endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5710   endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5711   endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5712   for(Int_t i=0; i<4; i++)   endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5713 //  TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5714   TGeoTranslation** endcapsidecoverboxtrans;
5715   endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5716   endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5717                                                          +                                         fgkEndCapSideCoverLength[0],
5718                                                                                                    endcapsidecoverboxshape[0]->GetDY()
5719                                                          +                     yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5720   endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5721                                                          +                     xvertex[11],
5722                                                                                                    endcapsidecoverboxshape[1]->GetDY()
5723                                                          +                     yvertex[12],0.);
5724   endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5725                                                          +                     xvertex[11],
5726                                                                                                    endcapsidecoverboxshape[2]->GetDY()
5727                                                          +                     yvertex[12]
5728                                                          +                                         2.*endcapsidecoverboxshape[1]->GetDY()
5729                                                          +                     fgkEndCapSideCoverWidth[5],0.);
5730   endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5731   endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5732   endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5733   for(Int_t i=0; i<2; i++)
5734         for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5735                 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5736                         new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5737                                                                 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5738                                                                 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5739                                                                 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5740                 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5741                                                                 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5742         }
5743   for(Int_t i=0; i<2; i++)
5744         for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5745                 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5746                 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5747                                                         +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5748                                                         endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5749                                                         +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5750                                                         +fgkEndCapSideCoverLength[4]),0.0);
5751                 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5752                                                                 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5753                                                                 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5754                                                                 +i*(kendcapcoverholenumber[1]-1)+j]);
5755         }
5756         return endcapsidecovermother;
5757  }
5758  ////////////////////////////////////////////////////////////////////////////////
5759  TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5760  ////////////////////////////////////////////////////////////////////////////////
5761  // Method returning Interface Card A, Interface Card B, Supply Card
5762  ////////////////////////////////////////////////////////////////////////////////
5763  /////////////////////
5764  // Supply Card
5765  /////////////////////
5766  // Electronic Board Back Al Plane
5767  const Int_t kelectboardbackvertexnumber = 8;
5768  Double_t xelectboardback[kelectboardbackvertexnumber];
5769  Double_t yelectboardback[kelectboardbackvertexnumber];
5770  xelectboardback[0] = 0.0;
5771  xelectboardback[1] = xelectboardback[0];
5772  xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5773  xelectboardback[3] = xelectboardback[2];
5774  xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5775  xelectboardback[5] = xelectboardback[4];
5776  xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5777  xelectboardback[7] = xelectboardback[6];
5778
5779  yelectboardback[0] = 0.0;
5780  yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5781  yelectboardback[2] = yelectboardback[1];
5782  yelectboardback[3] = yelectboardback[0];
5783  yelectboardback[4] = yelectboardback[3];
5784  yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5785  yelectboardback[6] = yelectboardback[5];
5786  yelectboardback[7] = yelectboardback[4];
5787  TGeoXtru* electboardbackshape = new TGeoXtru(2);
5788  electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5789                                                                         xelectboardback,yelectboardback);
5790  electboardbackshape->DefineSection(0,0.0);
5791  electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5792  TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5793                                                                                          electboardbackshape,fSSDSupportRingAl);
5794  electboardback->SetLineColor(fColorAl);
5795  // Electronic Board Kapton Layer
5796  const Int_t kelectlayervertexnumber = 8;
5797  Double_t xelectlayer[kelectlayervertexnumber];
5798  Double_t yelectlayer[kelectlayervertexnumber];
5799  xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5800  xelectlayer[1] = xelectlayer[0];
5801  xelectlayer[2] = fgkEndCapCardElectBoardLength;
5802  xelectlayer[3] = xelectlayer[2];
5803  for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5804
5805  yelectlayer[0] = 0.0;
5806  yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5807  yelectlayer[2] = yelectlayer[1];
5808  yelectlayer[3] = yelectlayer[0];
5809  yelectlayer[4] = yelectlayer[3];
5810  yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5811  yelectlayer[6] = yelectlayer[5];
5812  yelectlayer[7] = yelectlayer[4];
5813  TGeoXtru* electlayershape = new TGeoXtru(2);
5814  electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5815  electlayershape->DefineSection(0,0.0);
5816  electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5817  TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5818                                                                                          electlayershape,fSSDKaptonFlexMedium);
5819  electlayer->SetLineColor(fColorKapton);
5820  // JMD Connector Female
5821  const Int_t kjmdconnectorvertexnumber = 6;
5822  Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5823  Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5824  xjmdconnectorvertex[0] = 0.0;
5825  xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5826  xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5827  xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5828  xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5829  xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5830
5831  yjmdconnectorvertex[0] = 0.0;
5832  yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5833  yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5834  yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5835  yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5836  yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5837  TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5838  jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5839                                                                   yjmdconnectorvertex);
5840  jmdconnectorshape->DefineSection(0,0.0);
5841  jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
5842  TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
5843                                                                                    jmdconnectorshape,fSSDMountingBlockMedium);
5844  jmdconnector->SetLineColor(fColorG10);
5845  // Top Cable Connector
5846  const Int_t kcableconnectorvertexnumber = 8;
5847  Double_t xconnectorvertex[kcableconnectorvertexnumber];
5848  Double_t yconnectorvertex[kcableconnectorvertexnumber];
5849  xconnectorvertex[0] = 0.0;
5850  xconnectorvertex[1] = xconnectorvertex[0];
5851  xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
5852  xconnectorvertex[3] = xconnectorvertex[2];
5853  xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
5854                                          - fgkEndCapCardCableConnectorLength[2];
5855  xconnectorvertex[5] = xconnectorvertex[4];
5856  xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
5857  xconnectorvertex[7] = xconnectorvertex[6];
5858
5859  yconnectorvertex[0] = 0.0;
5860  yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
5861  yconnectorvertex[2] = yconnectorvertex[1];
5862  yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
5863  yconnectorvertex[4] = yconnectorvertex[3];
5864  yconnectorvertex[5] = yconnectorvertex[1];
5865  yconnectorvertex[6] = yconnectorvertex[5];
5866  yconnectorvertex[7] = yconnectorvertex[0];
5867  TGeoXtru* cableconnectorshape = new TGeoXtru(2);
5868  cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
5869                                                                     yconnectorvertex);
5870  cableconnectorshape->DefineSection(0,0.0);
5871  cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
5872  TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
5873                                                                                    cableconnectorshape,fSSDMountingBlockMedium);
5874  cableconnector->SetLineColor(fColorG10);
5875  // Strip Connection
5876  TGeoBBox* endcapstripconnectionshape =
5877                                                                 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
5878                                                                                          0.5*fgkEndCapStripConnectionThickness,
5879                                                                                          0.5*fgkEndCapStripConnectionWidth);
5880  TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
5881                                                                                                         endcapstripconnectionshape,
5882                                                                                                         fSSDSupportRingAl);
5883  endcapstripconnection->SetLineColor(fColorAl);
5884  // Interface Card B
5885  const Int_t kcardBvertexnumber = 12;
5886  Double_t xcardBvertexnumber[kcardBvertexnumber];
5887  Double_t ycardBvertexnumber[kcardBvertexnumber];
5888
5889  xcardBvertexnumber[0]  = 0.0;
5890  xcardBvertexnumber[1]  = xcardBvertexnumber[0];
5891  xcardBvertexnumber[2]  = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
5892  xcardBvertexnumber[3]  = xcardBvertexnumber[2];
5893  xcardBvertexnumber[4]  = xcardBvertexnumber[1];
5894  xcardBvertexnumber[5]  = xcardBvertexnumber[4];
5895  xcardBvertexnumber[6]  = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
5896  xcardBvertexnumber[7]  = xcardBvertexnumber[6];
5897  xcardBvertexnumber[8]  = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
5898  xcardBvertexnumber[9]  = xcardBvertexnumber[8];
5899  xcardBvertexnumber[10] = xcardBvertexnumber[7];
5900  xcardBvertexnumber[11] = xcardBvertexnumber[10];
5901
5902  ycardBvertexnumber[0]  = 0.0;
5903  ycardBvertexnumber[1]  = fgkEndCapInterfaceCardBWidth[0];
5904  ycardBvertexnumber[2]  = ycardBvertexnumber[1];
5905  ycardBvertexnumber[3]  = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
5906  ycardBvertexnumber[4]  = ycardBvertexnumber[3];
5907  ycardBvertexnumber[5]  = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
5908  ycardBvertexnumber[6]  = ycardBvertexnumber[5];
5909  ycardBvertexnumber[7]  = ycardBvertexnumber[4];
5910  ycardBvertexnumber[8]  = ycardBvertexnumber[7];
5911  ycardBvertexnumber[9]  = ycardBvertexnumber[1];
5912  ycardBvertexnumber[10] = ycardBvertexnumber[9];
5913  ycardBvertexnumber[11] = ycardBvertexnumber[0];
5914
5915  TGeoXtru* interfacecardBshape = new TGeoXtru(2);
5916  interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
5917  interfacecardBshape->DefineSection(0,0.);
5918  interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
5919  TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
5920                                                                                          fSSDMountingBlockMedium);
5921  interfacecardB->SetLineColor(46);
5922  // Interface Card B Electronic Board
5923  const Int_t kelectboardcardBvertexnumber = 14;
5924  Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
5925  Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
5926
5927  xelectboardcardBvertex[0]  = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
5928  xelectboardcardBvertex[1]  = xelectboardcardBvertex[0];
5929  xelectboardcardBvertex[2]  = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
5930  xelectboardcardBvertex[3]  = xelectboardcardBvertex[2];
5931  xelectboardcardBvertex[4]  = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
5932  xelectboardcardBvertex[5]  = xelectboardcardBvertex[4];
5933  xelectboardcardBvertex[6]  = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
5934  xelectboardcardBvertex[7]  = xelectboardcardBvertex[6];
5935  xelectboardcardBvertex[8]  = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
5936  xelectboardcardBvertex[9]  = xelectboardcardBvertex[8];
5937  xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
5938  xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
5939  xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
5940  xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
5941
5942  yelectboardcardBvertex[0]  = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
5943  yelectboardcardBvertex[1]  = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
5944  yelectboardcardBvertex[2]  = yelectboardcardBvertex[1];
5945  yelectboardcardBvertex[3]  = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
5946  yelectboardcardBvertex[4]  = yelectboardcardBvertex[3];
5947  yelectboardcardBvertex[5]  = yelectboardcardBvertex[2];
5948  yelectboardcardBvertex[6]  = yelectboardcardBvertex[5];
5949  yelectboardcardBvertex[7]  = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
5950  yelectboardcardBvertex[8]  = yelectboardcardBvertex[7];
5951  yelectboardcardBvertex[9]  = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
5952  yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
5953  yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
5954  yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
5955  yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
5956
5957  TGeoXtru* electboardcardBshape = new TGeoXtru(2);
5958  electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
5959                                                                          xelectboardcardBvertex,yelectboardcardBvertex);
5960  electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
5961  electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
5962                                                                          + fgkEndCapInterfaceElectBoardCardBThickness);
5963  TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
5964                                                                                           fSSDSupportRingAl);
5965  electboardcardB->SetLineColor(fColorAl);
5966  // Generating Stiffener 2
5967  TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
5968                                                                                            0.5*fgkEndCapStiffenerThickness,
5969                                                                                            0.5*fgkEndCapStiffenerLength);
5970  TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
5971  endcapstiffener->SetLineColor(fColorAl);
5972  // Generating Mother Interface Card B Container
5973  const Int_t kinterfacecardBmothervertexnumber = 10;
5974  Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5975  Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5976
5977  xinterfacecardBmothervertex[0] = 0.0;
5978  xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
5979  xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
5980                                                                 + fgkEndCapInterfaceCardBThickness;
5981  xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
5982  xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
5983                                                                 + fgkEndCapInterfaceElectBoardCardBThickness;
5984  xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
5985  xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
5986  xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
5987  xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
5988                                                                 + fgkEndCapCardJMDConnectorLength[0];
5989  xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
5990
5991  yinterfacecardBmothervertex[0] = 0.0;
5992  yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
5993                                                                 + fgkEndCapInterfaceCardBWidth[1]
5994                                                                 + fgkEndCapInterfaceCardBWidth[2];
5995  yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
5996  yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
5997  yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
5998  yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
5999  yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
6000  yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
6001                                                                 + fgkEndCapCardJMDConnectorWidth[0]
6002                                                                 + fgkEndCapCardJMDConnectorWidth[1];
6003  yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
6004  yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
6005  TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
6006  interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
6007                                                                                   xinterfacecardBmothervertex,
6008                                                                                   yinterfacecardBmothervertex);
6009  interfacecardBmothershape->DefineSection(0,-1.e-15);
6010  interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
6011  TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
6012                                                                                                    interfacecardBmothershape,fSSDAir);
6013  electboardcardB->SetLineColor(fColorAl);
6014  // Positioning Volumes Mother Interface Card B Container
6015  TGeoRotation* interfacecardBrot = new TGeoRotation();
6016  TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
6017  interfacecardBrot->SetAngles(90.,-90.,-90.);
6018  interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
6019  TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
6020  TGeoRotation* electboardcardBrot = new TGeoRotation();
6021  TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
6022  electboardcardBrot->SetAngles(90.,90.,-90.);
6023  electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
6024  TGeoCombiTrans* electboardcardBcombitrans =
6025                                   new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6026  interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6027  interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6028  TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6029  jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6030  TGeoTranslation* jmdconnectorcardBtrans[3];
6031  TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6032  for(Int_t i=0; i<3; i++){
6033    jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6034                                                          + fgkEndCapCardJMDConnectorLength[0],
6035                                                            fgkEndCapCardElectBoardLayerWidth[1],
6036                                                            0.5*fgkEndCapCardJMDConnectorThickness
6037                                                          + 0.5*(fgkEndCapInterfaceCardBLength[1]
6038                                                          - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6039                                                          + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6040    jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6041                                                                                                            *jmdconnectorcardBrot);
6042    interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6043  }
6044  // Mother Supply Card Container
6045  TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6046  // Interface Card Container
6047  TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6048  // Placing Volumes in Mother Supply Card Container
6049  // JMD Connector Positioning
6050  TGeoTranslation* jmdconnectortrans[2];
6051  for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6052  jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6053                                                                                         fgkEndCapCardElectBoardBackLength[0]
6054                                           -                                             fgkEndCapCardJMDConnectorThickness
6055                                           -                                             fgkEndCapCardJMDConnectorToLayer);
6056  TGeoRotation* jmdconnectorot = new TGeoRotation();
6057  jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6058                                                                  + 2.*fgkEndCapCardJMDConnectorLength[0]
6059                                                                  + 2.*fgkEndCapCardElectBoardLayerThickness,
6060                                                                           fgkEndCapCardElectBoardLayerWidth[1],
6061                                                                       fgkEndCapCardJMDConnectorThickness
6062                                                                  +    fgkEndCapCardJMDConnectorToLayer);
6063  jmdconnectorot->SetAngles(90.,180.,-90);
6064  TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6065                                                                                 * jmdconnectorot);
6066  mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6067  mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6068  // Top Cable Connector Placing
6069  TGeoRotation* cableconnectorot[2];
6070  for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6071  TGeoTranslation* cableconnectortrans[3];
6072  for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6073  cableconnectorot[0]->SetAngles(90.,0.,0.);
6074  cableconnectorot[1]->SetAngles(0.,-90.,0.);
6075  cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6076  TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6077                                                                                                                            *cableconnectorot[0]);
6078  TGeoHMatrix* cableconnectormatrix[2];
6079  for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6080                                                         new TGeoHMatrix((*cableconnectorot[1])
6081                                                                                    *(*cableconnectorcombitrans));
6082  cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6083                                            -                               fgkEndCapCardCableConnectorThickness,
6084                                                                                 fgkEndCapCardCableConnectorLength[0]
6085                                            +                            fgkEndCapCardCableConnectorToLayer);
6086  cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6087                                            -                2.*fgkEndCapCardCableConnectorThickness
6088                                            -                            fgkEndCapCardCableConnectorDistance,
6089                                                                                 fgkEndCapCardCableConnectorLength[0]
6090                                            +                            fgkEndCapCardCableConnectorToLayer);
6091  for(Int_t i=0; i<2; i++){
6092         cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6093     mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6094  }
6095  TGeoRotation* electboardbackrot = new TGeoRotation();
6096  TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6097  electboardbackrot->SetAngles(90.,-90.,-90.);
6098  electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6099                                                         +                fgkEndCapCardJMDConnectorLength[0]
6100                                                         +                fgkEndCapCardElectBoardLayerThickness,0.,0.);
6101  TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6102                                                                                                                            *electboardbackrot);
6103  mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6104  // Electronic Board Kapton Layer Positioning
6105  TGeoRotation* electlayerrot = new TGeoRotation();
6106  TGeoTranslation* electlayertrans[2];
6107  TGeoCombiTrans* electlayercombitrans[2];
6108  for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6109  electlayerrot->SetAngles(90.,-90.,-90.);
6110  electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6111                                                                  + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6112  electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6113                                                                  + 2.*fgkEndCapCardElectBoardLayerThickness
6114                                                                  + fgkEndCapCardElectBoardBackThickness,0.,0.);
6115  for(Int_t i=0; i<2; i++){
6116         electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6117         mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6118  }
6119  // Placing Volumes in Mother Interface Card Container
6120  motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6121  motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6122  for(Int_t i=0; i<2; i++){
6123         motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6124  }
6125  /////////////////////////////////////////////////////////////
6126  // Generation of Card Interface Container
6127  /////////////////////////////////////////////////////////////
6128  Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6129                                                   - fgkEndCapCardJMDConnectorLength[0]
6130                                                   - fgkEndCapInterfaceCardBThickness
6131                                                   - 9.*fgkEndCapStripConnectionThickness
6132                                                   - 8.*fgkEndCapCardElectBoardBackThickness;
6133  const Int_t kcardinterfacecontainervertexnumber = 14;
6134  Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6135  Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6136  xcardinterfacecontainervertex[0]  =-6.5*fgkEndCapCardElectBoardBackThickness
6137                                                                    - 7.0*fgkEndCapStripConnectionThickness;
6138  xcardinterfacecontainervertex[1]  = xcardinterfacecontainervertex[0];
6139  xcardinterfacecontainervertex[2]  = xcardinterfacecontainervertex[1]
6140                                                                    + fgkEndCapStripConnectionThickness
6141                                                                    - fgkEndCapCardElectBoardLayerThickness
6142                                                                    - fgkEndCapCardCableConnectorWidth[0];
6143  xcardinterfacecontainervertex[3]  = xcardinterfacecontainervertex[2];
6144  xcardinterfacecontainervertex[4]  = xcardinterfacecontainervertex[1];
6145  xcardinterfacecontainervertex[5]  = xcardinterfacecontainervertex[4];
6146  xcardinterfacecontainervertex[6]  = 1.5*fgkEndCapCardElectBoardBackThickness
6147                                                                    + 2.0*fgkEndCapStripConnectionThickness;
6148  xcardinterfacecontainervertex[7]  = xcardinterfacecontainervertex[6];
6149  xcardinterfacecontainervertex[8]  = xcardinterfacecontainervertex[7]
6150                                                                    + fgkEndCapInterfaceCardBThickness;
6151  xcardinterfacecontainervertex[9]  = xcardinterfacecontainervertex[8];
6152  xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6153                                                                    + fgkEndCapInterfaceElectBoardCardBThickness;
6154  xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6155  xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6156                                    - fgkEndCapInterfaceElectBoardCardBThickness
6157                                                                    + fgkEndCapCardJMDConnectorLength[0]
6158                                                                    + stiffenertransx+fgkEndCapStiffenerWidth;
6159  xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6160
6161  ycardinterfacecontainervertex[0]  = 0.;
6162  ycardinterfacecontainervertex[1]  = fgkEndCapCardElectBoardLayerWidth[1]
6163                                                                    + fgkEndCapCardJMDConnectorWidth[0]
6164                                                                    + fgkEndCapCardJMDConnectorWidth[1];
6165  ycardinterfacecontainervertex[2]  = ycardinterfacecontainervertex[1];
6166  ycardinterfacecontainervertex[3]  = fgkEndCapCardElectBoardBackWidth[0]
6167                                                                    - fgkEndCapStripConnectionWidth;
6168  ycardinterfacecontainervertex[4]  = ycardinterfacecontainervertex[3];
6169  ycardinterfacecontainervertex[5]  = fgkEndCapCardElectBoardBackWidth[0];
6170  ycardinterfacecontainervertex[6]  = ycardinterfacecontainervertex[5];
6171  ycardinterfacecontainervertex[7]  = fgkEndCapInterfaceCardBWidth[0]
6172                                                                    + fgkEndCapInterfaceCardBWidth[1]
6173                                                                    + fgkEndCapInterfaceCardBWidth[2];
6174  ycardinterfacecontainervertex[8]  = ycardinterfacecontainervertex[7];
6175  ycardinterfacecontainervertex[9]  = yelectboardcardBvertex[3];
6176  ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6177  ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6178  ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6179  ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6180
6181  TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6182  interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6183                                                                                   xcardinterfacecontainervertex,
6184                                                                                   ycardinterfacecontainervertex);
6185  interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6186                                                                            -    fgkEndCapCardElectBoardBackLength[0]));
6187  interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6188                                                                            +    fgkEndCapCardElectBoardBackLength[0]));
6189  TGeoVolume** cardinterfacecontainer;
6190  cardinterfacecontainer = new TGeoVolume*[4];
6191  cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6192                                                                                         interfacecardmothershape,fSSDAir);
6193  cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6194                                                                                         interfacecardmothershape,fSSDAir);
6195  cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6196                                                                                         interfacecardmothershape,fSSDAir);
6197  cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6198                                                                                         interfacecardmothershape,fSSDAir);
6199  /////////////////////////////////
6200  // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6201  // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6202  // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6203  // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6204  /////////////////////////////////
6205  TGeoRotation* endcapstripconnectionrot[2];
6206  for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6207  endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6208  endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6209  TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6210                                                                         *                                 (*endcapstripconnectionrot[0]));
6211  TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6212  endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6213                                                                                         -0.5*fgkEndCapCardElectBoardBackThickness,
6214                                                                                          fgkEndCapCardElectBoardBackWidth[0]
6215                                                                                         -endcapstripconnectionshape->GetDZ(),
6216                                                                                          0.5*fgkEndCapCardElectBoardBackLength[0]);
6217  endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6218  TGeoTranslation* cardinterfacetrans[9];
6219  TGeoHMatrix* cardinterfacematrix[9];
6220  for(Int_t i=0; i<7; i++){
6221         cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6222                                                   +                                                     fgkEndCapCardElectBoardBackThickness),
6223                                                                                                 0.0,0.0);
6224         cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6225                                                    *                             (*endcapstripconnectionmatrix));
6226  }
6227  cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6228                                                   +                                             fgkEndCapCardElectBoardBackThickness),
6229                                                                                                 0.0,0.0);
6230  cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6231                                                 *                                 (*endcapstripconnectionmatrix));
6232  cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6233                                                   +                                             fgkEndCapCardElectBoardBackThickness),
6234                                                                                                 0.0,0.0);
6235  cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6236                                                 *                                 (*endcapstripconnectionmatrix));
6237
6238  for(Int_t i=0; i<4; i++){
6239         cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6240                                                                            cardinterfacematrix[7]);
6241         cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6242                                                                            cardinterfacematrix[8]);
6243  }
6244  TGeoTranslation* mothersupplycardtrans =
6245                                         new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6246                                                                                 + 2.*fgkEndCapCardJMDConnectorLength[0]
6247                                                                                 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6248  TGeoHMatrix* mothersupplycardmatrix[7];
6249  Int_t index[4] = {1,1,1,1};
6250  for(Int_t i=0; i<7; i++){
6251         mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6252                                                         *                                 (*mothersupplycardtrans));
6253         for(Int_t j=0; j<4; j++){
6254                 switch(j){
6255                         case 0: //Layer5 EndCap Left Side
6256                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6257                                                                                                    cardinterfacematrix[i]);
6258                                 if(i!=0){
6259                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6260                                                                                                            mothersupplycardmatrix[i]);
6261                                         index[j]++;
6262
6263                                 }
6264                         break;
6265                         case 1: //Layer5 EndCap Rigth Side
6266                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6267                                                                                                    cardinterfacematrix[i]);
6268                                 if(i>0&&i<6){
6269                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6270                                                                                                            mothersupplycardmatrix[i]);
6271                                         index[j]++;
6272                                 }
6273                         break;
6274                         case 2: //Layer6 EndCap Left Side
6275                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6276                                                                                                    cardinterfacematrix[i]);
6277                                 if(i!=6){
6278                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6279                                                                                                            mothersupplycardmatrix[i]);
6280                                         index[j]++;
6281                                 }
6282                         break;
6283                         case 3: //Layer6 EndCap Right Side
6284                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6285                                                                                                    cardinterfacematrix[i]);
6286                                 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6287                                                                                                    mothersupplycardmatrix[i]);
6288                                 index[j]++;
6289                         break;
6290                 }
6291         }
6292  }
6293  // Positioning Interface
6294  TGeoTranslation* motherinterfacecardtrans =
6295                 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6296                                                          +0.5*fgkEndCapCardElectBoardBackThickness
6297                                                          -fgkEndCapCardElectBoardLayerThickness
6298                                                          +fgkEndCapStripConnectionThickness,0.,0.);
6299  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6300                                         motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6301  // Positioning Interface Card B
6302  TGeoTranslation* interfacecardBmothertrans =
6303                                         new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6304                                                                                 + 2.*fgkEndCapStripConnectionThickness
6305                                                                                         + fgkEndCapCardElectBoardBackThickness,0.,
6306                                                                            -0.5 * (fgkEndCapInterfaceCardBLength[1]
6307                                                                                         -  fgkEndCapCardElectBoardBackLength[0]));
6308  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6309                                                                                                                          interfacecardBmothertrans);
6310  // Positioning Stiffener
6311  TGeoTranslation* endcapstiffenertrans =
6312                                                 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6313                                                                            +    2.0*fgkEndCapStripConnectionThickness
6314                                                                            +    fgkEndCapInterfaceCardBThickness
6315                                                                            +    fgkEndCapCardJMDConnectorLength[0]
6316                                                                            +    stiffenertransx
6317                                                                            +    endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6318                                                                                         endcapstiffenershape->GetDZ()
6319                                                                            -    0.5*(fgkEndCapStiffenerLength
6320                                                                            -    fgkEndCapCardElectBoardBackLength[0]));
6321  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6322  /////////////////////////////////////////////////////////////
6323  // Deallocating memory
6324  /////////////////////////////////////////////////////////////
6325  delete interfacecardBrot;
6326  delete interfacecardBtrans;
6327  delete electboardcardBtrans;
6328  delete electboardcardBrot;
6329  delete jmdconnectorcardBrot;
6330  for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6331  delete jmdconnectorot;
6332  delete jmdconnectortrans[1];
6333  for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6334  delete cableconnectorcombitrans;
6335  delete electboardbacktrans;
6336  delete electboardbackrot;
6337  delete electlayerrot;
6338  for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6339  for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6340  delete mothersupplycardtrans;
6341  for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6342  /////////////////////////////////////////////////////////////
6343  return cardinterfacecontainer;
6344  }
6345  ////////////////////////////////////////////////////////////////////////////////
6346  TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6347   /////////////////////////////////////////////////////////////
6348   // Method returning EndCap Mother Volume
6349   /////////////////////////////////////////////////////////////
6350   const Int_t kendcapcoverplatesmallholenumber = 9;
6351   Double_t endcapmotherorigin[3];
6352   endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6353                                                 +  0.5 *(fgkEndCapCoverPlateLength[3]
6354                                             +  2.0 * fgkEndCapCoverPlateLength[2]);
6355   endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6356                                           -                      fgkEndCapCoverPlateWidth[2]
6357                                           -       (kendcapcoverplatesmallholenumber-1)
6358                                           *        fgkEndCapCoverPlateSmallHoleSeparation[2])
6359                                           +  0.5*(fgkEndCapSideCoverLength[2]
6360                                           +               fgkEndCapCoverPlateWidth[1]
6361                                           -       fgkEndCapCoverPlateWidth[0])
6362                                           -      (fgkEndCapCoverPlateWidth[1]
6363                                           -       fgkEndCapCoverPlateWidth[0]);
6364   endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6365                                                 + 2.*fgkEndCapCoolingTubeRadiusMax
6366                                                 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6367                                                 +      fgkEndCapSideCoverWidth[1]
6368                                                 +      fgkEndCapSideCoverThickness
6369                                                 +      fgkEndCapKaptonFoilThickness);
6370   TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6371                                                           +                              2.0* fgkEndCapCoverPlateLength[2]
6372                                                           +              2.0* fgkEndCapSideCoverThickness),
6373                                                                          0.5* (fgkEndCapSideCoverLength[2]
6374                                                           +                    fgkEndCapCoverPlateWidth[1]
6375                                                           -                                        fgkEndCapCoverPlateWidth[0]),
6376                                                                                          0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6377                                                       +                                    fgkEndCapSideCoverWidth[1]
6378                                                           +                                       fgkEndCapSideCoverThickness
6379                                                       +                                   fgkEndCapKaptonFoilThickness),
6380                                                                                          endcapmotherorigin);
6381   TGeoVolume** endcapassembly;
6382   endcapassembly = new TGeoVolume*[4];
6383   endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6384                                                                                         endcapmothershape,fSSDAir);
6385   endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6386                                                                                         endcapmothershape,fSSDAir);
6387   endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6388                                                                                         endcapmothershape,fSSDAir);
6389   endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6390                                                                                         endcapmothershape,fSSDAir);
6391  /////////////////////////////////
6392  // endcapassembly[0]:  Container End Cap Layer 5 Bellegarde Side
6393  // endcapassembly[1]:  Container End Cap Layer 5 Gex Side
6394  // endcapassembly[2]:  Container End Cap Layer 6 Bellegarde Side
6395  // endcapassembly[3]:  Container End Cap Layer 6 Gex Side
6396  /////////////////////////////////
6397   /////////////////////////////////////////////////////
6398   // Placing Endcap Cover Plate
6399   /////////////////////////////////////////////////////
6400   TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6401   TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6402   endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6403   TGeoCombiTrans* endcapcoverplatecombitrans =
6404                                                   new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6405                                                                                          endcapcoverplaterot);
6406   TGeoTranslation* endcapcoverplatetrans =
6407                                                   new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6408   TGeoHMatrix* endcapcoverplatematrix =
6409                                                   new TGeoHMatrix((*endcapcoverplatetrans)
6410                                                                           *       (*endcapcoverplatecombitrans));
6411   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6412   /////////////////////////////////////////////////////
6413   // Placing Endcap Side Cover
6414   /////////////////////////////////////////////////////
6415   TGeoVolume* endcapsidecover = GetEndCapSideCover();
6416   TGeoRotation* endcapsidecoverot[2];
6417   TGeoCombiTrans* endcapsidecovercombitrans[3];
6418   for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6419   endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6420   endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6421                                                                                         - 0.5*(fgkEndCapCoverPlateWidth[0]
6422                                                                                         - fgkEndCapCoverPlateWidth[2]
6423                                                                                     - (kendcapcoverplatesmallholenumber-1)
6424                                                                                         * fgkEndCapCoverPlateSmallHoleSeparation[2])
6425                                                                                         + 0.*fgkEndCapCoverPlateWidth[0]
6426                                                                                         + fgkEndCapSideCoverLength[2],
6427                                                                                           0.5*(fgkEndCapSideCoverThickness
6428                                                                                         + fgkEndCapCoverPlateThickness)
6429                                                                                         - 0.5*fgkEndCapCoverPlateThickness,
6430                                                                                           endcapsidecoverot[0]);
6431   endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6432   endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6433                                                                                                         0.5*fgkEndCapCoverPlateThickness
6434                                                                                                         -fgkEndCapSideCoverWidth[1],
6435                                                                                                         endcapsidecoverot[1]);
6436   endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6437                                                                                                         +fgkEndCapCoverPlateLength[3]
6438                                                                                                         +2.*fgkEndCapCoverPlateLength[2]
6439                                                                                                         +fgkEndCapSideCoverThickness,0.0,
6440                                                                                                         0.5*fgkEndCapCoverPlateThickness
6441                                                                                                         -fgkEndCapSideCoverWidth[1],
6442                                                                                                         endcapsidecoverot[1]);
6443   TGeoHMatrix* endcapsidecovermatrix[2];
6444   for(Int_t i=0; i<2; i++){
6445    endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6446                                                         *                                 (*endcapsidecovercombitrans[0]));
6447         for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6448                                                                                                                 endcapsidecovermatrix[i]);
6449   }
6450   /////////////////////////////////////////////////////
6451   // Placing Endcap Cooling Tube
6452   /////////////////////////////////////////////////////
6453   TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6454   TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6455   endcapcoolingtuberot->SetAngles(0.,180.,0.);
6456   TGeoCombiTrans* endcapccolingtubecombitrans
6457                                                 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6458                                                 + fgkEndCapCoolingTubeAxialRadius[1])
6459                                                 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6460                                                 - fgkEndCapCoolingTubeToCoverSide,
6461                                                   fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6462                                                 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6463   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6464                                                                                                           endcapccolingtubecombitrans);
6465   /////////////////////////////////////////////////////
6466   // Placing Screws
6467   /////////////////////////////////////////////////////
6468   Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6469                                                                            fgkEndCapCoverPlateScrewRadiusMin};
6470   Int_t screwcoverplatedgesnumber[2] = {20,20};
6471   Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6472                                                                                 fgkEndCapCoverPlateThickness
6473                                                                          +  fgkEndCapCoolingTubeRadiusMax};
6474   TGeoShape* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
6475                                                                                                  screwcoverplatedgesnumber,
6476                                                                                                  screwcoverplatesection);
6477   TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6478                                                                                            screwcoverplateshape,
6479                                                                                            fSSDCoolingTubePhynox);
6480   screwcoverplate->SetLineColor(12);
6481   Double_t transx[4] = {0,
6482                                                 fgkEndCapCoverPlateSmallHoleSeparation[0],
6483                                                 fgkEndCapCoverPlateSmallHoleSeparation[0]
6484                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1],
6485                                          2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6486                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1]};
6487   const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6488 //  TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6489   TGeoTranslation*** endcapcoverplatescrewtrans;
6490   endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6491   Int_t index = 0;
6492   for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6493         endcapcoverplatescrewtrans[i] =
6494                                         new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6495     for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6496                 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6497         if(index==1||index==9||index==28||index==36){
6498                         endcapcoverplatescrewtrans[i][j] =
6499                                 new TGeoTranslation(transx[i],
6500                                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6501                                                                         fgkEndCapSideCoverThickness);
6502                 }
6503                 else{
6504                         endcapcoverplatescrewtrans[i][j] =
6505                                 new TGeoTranslation(transx[i],
6506                                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6507                                                                         0.);
6508                 }
6509             if(index!=19)
6510                 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6511                                                                                           endcapcoverplatescrewtrans[i][j]);
6512         }
6513   }
6514   /////////////////////////////////////////////////////
6515   // Placing Cover Plate Clips
6516   /////////////////////////////////////////////////////
6517   TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6518                                                                                                          0.5*fgkEndCapCoverPlateClipWidth,
6519                                                                                                          0.5*fgkEndCapSideCoverThickness);
6520   TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6521                                                                                                         endcapcoverplateclipshape,
6522                                                                                                         fSSDCoolingTubePhynox);
6523   TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6524                                                                                                          0.5*fgkEndCapCoverPlateDownClipWidth,
6525                                                                                                          0.5*fgkEndCapSideCoverThickness);
6526   TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6527                                                                                                         endcapcoverplatedownclipshape,
6528                                                                                                         fSSDCoolingTubePhynox);
6529   TGeoTranslation* endcapcoverplatecliptrans[4];
6530   endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6531                                                            -                     fgkEndCapCoverPlateLength[0]
6532                                                            -                     fgkEndCapSideCoverThickness,
6533                                                                                                          0.0,
6534                                                                                                  0.5*(fgkEndCapSideCoverThickness
6535                                                            +                                              fgkEndCapCoverPlateThickness));
6536   endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6537                                                            -                     fgkEndCapCoverPlateLength[0]
6538                                                            -                     fgkEndCapSideCoverThickness,
6539                                                                                                          (kendcapcoverplatescrewnumber[1]-1)
6540                                                            *                                     fgkEndCapSideCoverWidth[5],
6541                                                                                                  0.5*(fgkEndCapSideCoverThickness
6542                                                            +                                              fgkEndCapCoverPlateThickness));
6543   endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6544                                                            -                     fgkEndCapCoverPlateLength[0]
6545                                                            +                                     fgkEndCapCoverPlateLength[1]
6546                                                            +                              2.*fgkEndCapCoverPlateLength[0]
6547                                                            -                                     fgkEndCapCoverPlateClipLength
6548                                                            +                                 fgkEndCapSideCoverThickness,
6549                                                                                                          0.0,
6550                                                                                                  0.5*(fgkEndCapSideCoverThickness
6551                                                            +                                              fgkEndCapCoverPlateThickness));
6552   endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6553                                                            -                     fgkEndCapCoverPlateLength[0]
6554                                                            +                                     fgkEndCapCoverPlateLength[1]
6555                                                            +                              2.*fgkEndCapCoverPlateLength[0]
6556                                                            -                                     fgkEndCapCoverPlateClipLength
6557                                                            +                                 fgkEndCapSideCoverThickness,
6558                                                                                                          (kendcapcoverplatescrewnumber[1]-1)
6559                                                            *                                     fgkEndCapSideCoverWidth[5],
6560                                                                                                  0.5*(fgkEndCapSideCoverThickness
6561                                                            +                                              fgkEndCapCoverPlateThickness));
6562   endcapcoverplateclip->SetLineColor(fColorPhynox);
6563   endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6564   for(Int_t i=0; i<4; i++)
6565         for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6566                                                                                                    endcapcoverplatecliptrans[i]);
6567   TGeoTranslation* endcapcoverplatedowncliptrans[4];
6568   endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6569                                                                    -                     fgkEndCapCoverPlateLength[0]
6570                                                                    -                     fgkEndCapSideCoverThickness,
6571                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6572                                                                    -                                 fgkEndCapCoverPlateClipWidth),
6573                                                                                                         0.5*(fgkEndCapSideCoverThickness
6574                                                                +                                         fgkEndCapCoverPlateThickness)
6575                                                                    -                     fgkEndCapSideCoverWidth[1]
6576                                                                    -                                     fgkEndCapSideCoverThickness);
6577   endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6578                                                                    -                     fgkEndCapCoverPlateLength[0]
6579                                                                    -                     fgkEndCapSideCoverThickness,
6580                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6581                                                                    -                                 fgkEndCapCoverPlateClipWidth)
6582                                                                    +                            fgkEndCapSideCoverLength[2]
6583                                                                    -                            fgkEndCapCoverPlateDownClipWidth,
6584                                                                                                         0.5*(fgkEndCapSideCoverThickness
6585                                                                +                                         fgkEndCapCoverPlateThickness)
6586                                                                    -                     fgkEndCapSideCoverWidth[1]
6587                                                                    -                                     fgkEndCapSideCoverThickness);
6588   endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6589                                                                    -                     fgkEndCapCoverPlateLength[0]
6590                                                                    +                     fgkEndCapSideCoverThickness
6591                                                                    +                     fgkEndCapCoverPlateLength[1]
6592                                                                    +                 2.0*fgkEndCapCoverPlateLength[0]
6593                                                                    -                     fgkEndCapCoverPlateDownClipLength,
6594                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6595                                                                    -                                 fgkEndCapCoverPlateClipWidth),
6596                                                                                                         0.5*(fgkEndCapSideCoverThickness
6597                                                                +                                         fgkEndCapCoverPlateThickness)
6598                                                                    -                     fgkEndCapSideCoverWidth[1]
6599                                                                    -                                     fgkEndCapSideCoverThickness);
6600   endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6601                                                                    -                     fgkEndCapCoverPlateLength[0]
6602                                                                    +                     fgkEndCapSideCoverThickness
6603                                                                    +                     fgkEndCapCoverPlateLength[1]
6604                                                                    +                 2.0*fgkEndCapCoverPlateLength[0]
6605                                                                    -                     fgkEndCapCoverPlateDownClipLength,
6606                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6607                                                                    -                                 fgkEndCapCoverPlateClipWidth)
6608                                                                    +                                 fgkEndCapSideCoverLength[2]
6609                                                                    -                                 fgkEndCapCoverPlateDownClipWidth,
6610                                                                                                         0.5*(fgkEndCapSideCoverThickness
6611                                                                +                                         fgkEndCapCoverPlateThickness)
6612                                                                    -                     fgkEndCapSideCoverWidth[1]
6613                                                                    -                                     fgkEndCapSideCoverThickness);
6614   for(Int_t i=0; i<4; i++)
6615         for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6616                                                                                                    endcapcoverplatedowncliptrans[i]);
6617   /////////////////////////////////////////////////////
6618   // Placing Kapton Foil
6619   /////////////////////////////////////////////////////
6620   TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6621                                                                                                  0.5*fgkEndCapKaptonFoilWidth,
6622                                                                                                  0.5*fgkEndCapKaptonFoilThickness);
6623   TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6624                                                                                                 endcapkaptonfoilshape,
6625                                                                                                 fSSDKaptonFlexMedium);
6626   endcapkaptonfoil->SetLineColor(8);
6627   TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6628                                                                                                                            0.5*fgkEndCapKaptonFoilWidth
6629                                                                                  -                     0.5*fgkEndCapCoverPlateClipWidth,
6630                                                                                                                            0.5*fgkEndCapCoverPlateThickness
6631                                                                                  -                     0.5*fgkEndCapKaptonFoilThickness
6632                                                                              -                     fgkEndCapSideCoverWidth[1]
6633                                                                                  -                     fgkEndCapSideCoverThickness);
6634   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6635   /////////////////////////////////////////////////////////////
6636   // Placing Electronic Tubes
6637   /////////////////////////////////////////////////////////////
6638   Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6639                                                                              - fgkEndCapInterfaceCardBThickness
6640                                                                              - 9.*fgkEndCapStripConnectionThickness
6641                                                                              - 8.*fgkEndCapCardElectBoardBackThickness,
6642                                                                                fgkEndCapKaptonFoilWidth
6643                                                                              - fgkEndCapInterfaceCardBThickness
6644                                                                              - 9.*fgkEndCapStripConnectionThickness
6645                                                                              - 8.*fgkEndCapCardElectBoardBackThickness
6646                                                                                  - fgkEndCapInterfaceElectBoardCardBThickness};
6647   TGeoVolume* endcapeffectivecables[2];
6648   endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6649                                                                                          fgkEndCapEffectiveCableRadiusMax,
6650                                                                                          endcapeffectivecableswidth[0],
6651                                                                                          10,"EndCapEffectiveCables1");
6652   endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6653                                                                                          fgkEndCapEffectiveCableRadiusMax,
6654                                                                                          endcapeffectivecableswidth[1],
6655                                                                                          25,"EndCapEffectiveCables2");
6656   TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6657   TGeoTranslation* endcapeffectivecablestrans[2];
6658   endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6659                                           -                                                        0.5*endcapeffectivecableswidth[0]
6660                                           -                            0.5*(fgkEndCapCoverPlateWidth[0]
6661                                           -                                                               fgkEndCapCoverPlateWidth[2]
6662                                           -                                             (kendcapcoverplatesmallholenumber-1)
6663                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6664                                           +                                             fgkEndCapSideCoverLength[2],
6665                                           -                     0.5*fgkEndCapCoverPlateThickness
6666                                           -                                             (fgkEndCapCardElectBoardBackWidth[0]
6667                                           -                                              fgkEndCapInterfaceCardBWidth[0]
6668                                           -                                              fgkEndCapInterfaceCardBWidth[1]));
6669   endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6670                                           -                                                        0.5*endcapeffectivecableswidth[1]
6671                                           -                            0.5*(fgkEndCapCoverPlateWidth[0]
6672                                           -                                                               fgkEndCapCoverPlateWidth[2]
6673                                           -                                             (kendcapcoverplatesmallholenumber-1)
6674                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6675                                           +                                         fgkEndCapSideCoverLength[2],
6676                                           -                     0.5*fgkEndCapCoverPlateThickness
6677                                           -                                             (fgkEndCapCardElectBoardBackWidth[0]
6678                                           -                                              fgkEndCapInterfaceCardBWidth[0])
6679                                           -                     0.5*fgkEndCapInterfaceCardBWidth[2]);
6680   endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6681   TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6682   endcapeffectivecablescombitrans[0]  = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6683                                                                                                                    *endcapeffectivecablesrot);
6684   endcapeffectivecablescombitrans[1]  = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6685                                                                                                                    *endcapeffectivecablesrot);
6686 //  for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6687 //                                                                                                        endcapeffectivecablescombitrans[0]);
6688   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6689                                                                                                           endcapeffectivecablescombitrans[1]);
6690   /////////////////////////////////////////////////////////////
6691   // Placing End Cap Cards
6692   /////////////////////////////////////////////////////////////
6693   TGeoVolume** endcapcards = GetEndCapCards();
6694   TGeoRotation* endcapcardsrot[2];
6695   for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6696   endcapcardsrot[0]->SetAngles(90.,0.,0.);
6697   TGeoTranslation* endcapcardstrans[2];
6698   endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6699                                                                                         -  fgkEndCapCardElectBoardBackLength[0]));
6700   TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6701   endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6702   TGeoHMatrix* endcapcardsmatrix[2];
6703   endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6704   Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6705                                                   - fgkEndCapCardJMDConnectorLength[0]
6706                                                   - fgkEndCapInterfaceCardBThickness
6707                                                   - 9.*fgkEndCapStripConnectionThickness
6708                                                   - 8.*fgkEndCapCardElectBoardBackThickness;
6709   endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6710                                           -                                             fgkEndCapCoverPlateLength[0]
6711                                           + 0.5 *              (fgkEndCapCoverPlateLength[3]
6712                                           + 2.0 *                               fgkEndCapCoverPlateLength[2]),
6713                                           -                                                     stiffenertransx-fgkEndCapStiffenerWidth
6714                                           -                                                               fgkEndCapCardJMDConnectorLength[0]
6715                                           -                                                               fgkEndCapInterfaceCardBThickness
6716                                           -     2.0 *                                             fgkEndCapStripConnectionThickness
6717                                           - 1.5 *                                             fgkEndCapInterfaceCardBThickness
6718                                           - 0.5 *                                                (fgkEndCapCoverPlateWidth[0]
6719                                           -                                                               fgkEndCapCoverPlateWidth[2]
6720                                           -                                             (kendcapcoverplatesmallholenumber-1)
6721                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6722                                           +                     fgkEndCapKaptonFoilWidth,
6723                                                                                           0.5*fgkEndCapCoverPlateThickness
6724                                           -                                                     fgkEndCapSideCoverWidth[1]);
6725   endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6726   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6727    /////////////////////////////////////////////////////////////
6728   // Deallocating memory
6729   /////////////////////////////////////////////////////////////
6730   delete endcapcoverplaterot;
6731   delete endcapcoverplatecombitrans;
6732   delete endcapcoverplatetrans;
6733   for(Int_t i=0; i<3; i++){
6734    delete endcapsidecovercombitrans[i];
6735    if(i<2) delete endcapsidecoverot[i];
6736   }
6737   for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6738   for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6739   delete endcapcardsmatrix[0];
6740   return endcapassembly;
6741  }
6742  ////////////////////////////////////////////////////////////////////////////////
6743  TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6744                                                                                                                         Double_t radiusmax,
6745                                                                                                                         Double_t width,
6746                                                                                                                         Int_t ncables,
6747                                                                                                                         const char* volname){
6748   /////////////////////////////////////////////////////////////
6749   // Generating EndCap High Voltage Tubes
6750   /////////////////////////////////////////////////////////////
6751   Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
6752   Double_t effectiveouteradius = TMath::Sqrt(effectiveinneradius*effectiveinneradius+(radiusmax-radiusmin)*(radiusmax-radiusmin));
6753
6754   TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6755   TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6756                                                                                                    effectiveouteradius,0.5*width);
6757   TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6758                                                                                                 effectiveinnertubeshape,
6759                                                                                                 fSSDStiffenerConnectorMedium);
6760   effectiveinnertube->SetLineColor(41);
6761   TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6762                                                                                                 effectiveoutertubeshape,
6763                                                                                                 fSSDKaptonChipCableMedium);
6764   effectiveoutertube->SetLineColor(39);
6765   TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6766   TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6767   effectivemothertube->AddNode(effectiveinnertube,1);
6768   effectivemothertube->AddNode(effectiveoutertube,1);
6769   return effectivemothertube;
6770  }
6771  ////////////////////////////////////////////////////////////////////////////////
6772  TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6773   /////////////////////////////////////////////////////////////
6774   // Generating EndCap Support Layer 5 and Layer 6
6775   /////////////////////////////////////////////////////////////
6776   const Int_t knedges = 5;
6777   ///////////////////////////////////////////////
6778   // Setting the vertices for TGeoXtru Up Volume
6779   ///////////////////////////////////////////////
6780   const Int_t klayernumber = 2;
6781   Double_t xupvertex[klayernumber][knedges+3];
6782   Double_t yupvertex[klayernumber][knedges+3];
6783   Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6784   Double_t middledgeangle[klayernumber] = {0.0,0.0};
6785   Double_t middlepsi[klayernumber] = {0.0,0.0};
6786   for(Int_t i=0; i<klayernumber; i++){
6787         xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6788         xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6789         xupvertex[i][2] = -xupvertex[i][1];
6790         xupvertex[i][3] = -xupvertex[i][0];
6791
6792         yupvertex[i][0] =  fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6793         yupvertex[i][1] =  0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6794         yupvertex[i][2] =  yupvertex[i][1];
6795         yupvertex[i][3] =  yupvertex[i][0];
6796
6797     middledgeangle[i] = upedgeangle[i]/knedges;
6798     middlepsi[i] = 90.0-0.5*upedgeangle[i];
6799     for(Int_t j=1; j<knedges; j++){
6800                 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6801                 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6802         }
6803   }
6804   ////////////////////////////////////
6805   // Generating Up TGeoXtru
6806   ////////////////////////////////////
6807   TGeoXtru* upendcapsupportshape[klayernumber];
6808   TGeoVolume* upendcapsupport[klayernumber];
6809   char upendcapsupportname[100];
6810   for(Int_t i=0; i<klayernumber; i++){
6811    upendcapsupportshape[i] = new TGeoXtru(2);
6812    sprintf(upendcapsupportname,"UpEndCapSupportPieceLayer%i",i+5);
6813    upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6814    upendcapsupportshape[i]->DefineSection(0,0.);
6815    upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6816    upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
6817                                                                         fSSDSupportRingAl);
6818    upendcapsupport[i]->SetLineColor(5);
6819   }
6820   ///////////////////////////////////////////////
6821   // Setting the vertices for TGeoXtru Down Volume
6822   ///////////////////////////////////////////////
6823   Double_t xdownvertex[klayernumber][2*(knedges+1)];
6824   Double_t ydownvertex[klayernumber][2*(knedges+1)];
6825   for(Int_t i=0; i<klayernumber; i++){
6826         xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6827         xdownvertex[i][1] =  xupvertex[i][0];
6828         ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6829         ydownvertex[i][1] =  yupvertex[i][0];
6830         for(Int_t j=0; j<knedges; j++){
6831                 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6832                 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6833         }
6834         for(Int_t j=0; j<knedges; j++){
6835                 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6836                                                                         * CosD(middlepsi[i]+j*middledgeangle[i]);
6837                 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6838                                                                         * SinD(middlepsi[i]+j*middledgeangle[i]);
6839         }
6840   }
6841   ////////////////////////////////////
6842   // Generating Down TGeoXtru
6843   ////////////////////////////////////
6844   TGeoXtru* downendcapsupportshape[klayernumber];
6845   TGeoVolume* downendcapsupport[klayernumber];
6846   char downendcapsupportname[100];
6847   for(Int_t i=0; i<klayernumber; i++){
6848         downendcapsupportshape[i] = new TGeoXtru(2);
6849     sprintf(downendcapsupportname,"DownEndCapSupportPieceLayer%i",i+5);
6850         downendcapsupportshape[i] = new TGeoXtru(2);
6851         downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
6852     if(i==0){
6853                 downendcapsupportshape[i]->DefineSection(0,0.);
6854                 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
6855     }
6856         else{
6857                 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
6858                                                                  -                 fgkEndCapSupportLowWidth[i]);
6859                 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6860         }
6861     downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
6862                                                                 downendcapsupportshape[i],fSSDSupportRingAl);
6863         downendcapsupport[i]->SetLineColor(5);
6864   }
6865   ///////////////////////////////////////////////
6866   // Setting TGeoPgon Volume
6867   ///////////////////////////////////////////////
6868   const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6869                                                                                                    fgkSSDLay6LadderNumber};
6870   TGeoPgon* endcapsupportmothershape[klayernumber];
6871   TGeoVolume** endcapsupportmother;
6872   endcapsupportmother = new TGeoVolume*[klayernumber];
6873   char endcapsupportmothername[100];
6874   for(Int_t i=0; i<klayernumber; i++){
6875         endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6876     sprintf(endcapsupportmothername,"EndCapSupportMotherLayer%i",i+5);
6877         endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
6878     endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
6879                                                                                           ydownvertex[i][0],yupvertex[i][1]);
6880     endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
6881                                                                                         fSSDAir);
6882   }
6883   ////////////////////////////////////
6884   TGeoRotation** endcapsupportrot[klayernumber];
6885   for(Int_t i=0; i<2; i++){
6886         endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
6887         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6888            endcapsupportrot[i][j] = new TGeoRotation();
6889            endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
6890        endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
6891        endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
6892         }
6893   }
6894   return endcapsupportmother;
6895  }
6896  ////////////////////////////////////////////////////////////////////////////////
6897  void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
6898   /////////////////////////////////////////////////////////////
6899   // Setting End Cap Support Layer 5 and 6.
6900   /////////////////////////////////////////////////////////////
6901   const Int_t kendcapcoverplatesmallholenumber = 9;
6902   const Int_t klayernumber = 2;
6903   const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6904                                                                                                    fgkSSDLay6LadderNumber};
6905   Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
6906                                                                                 360.0/kssdlayladdernumber[1]};
6907   TGeoVolume** endcapsupport = EndCapSupport();
6908   TGeoVolume** endcapassembly = GetEndCapAssembly();
6909   TGeoPgon* endcapsupportshape[klayernumber];
6910   Double_t* radiusmin[klayernumber];
6911   Double_t* radiusmax[klayernumber];
6912   for(Int_t i=0; i<klayernumber; i++){
6913     endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
6914         radiusmin[i] = endcapsupportshape[i]->GetRmin();
6915         radiusmax[i] = endcapsupportshape[i]->GetRmax();
6916   }
6917   TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
6918   Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
6919                                                                           endcapassemblyshape->GetDY(),
6920                                                                           endcapassemblyshape->GetDZ()};
6921   ///////////////////////////////////////////////
6922   // Setting TGeoPgon Volume for Mother Container
6923   ///////////////////////////////////////////////
6924   TGeoPgon* endcapsupportsystemshape[klayernumber];
6925   char endcapsupportsystemothername[100];
6926   for(Int_t i=0; i<klayernumber; i++){
6927         endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6928     sprintf(endcapsupportsystemothername,"EndCapSupportSystemLayer%i",i+5);
6929         endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
6930                                                                                              - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
6931                                                                                           (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6932                                                                                            +2.*endcapassemblycenter[2])
6933                                                                                            /CosD(0.5*upedgeangle[i]));
6934     endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
6935                                                                                                  -(fgkEndCapCoverPlateWidth[1]
6936                                                                                              - fgkEndCapCoverPlateWidth[0]),
6937                                                                                            *radiusmin[i],
6938                                                                                           (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6939                                                                                            +2.*endcapassemblycenter[2])
6940                                                                                            /CosD(0.5*upedgeangle[i]));
6941   }
6942   fgkEndCapSupportSystem = new TGeoVolume*[4];
6943   fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
6944                                                                           endcapsupportsystemshape[0],fSSDAir);
6945   fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
6946                                                                           endcapsupportsystemshape[0],fSSDAir);
6947   fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
6948                                                                           endcapsupportsystemshape[1],fSSDAir);
6949   fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
6950                                                                           endcapsupportsystemshape[1],fSSDAir);
6951   ///////////////////////////////////////////////
6952   TGeoTranslation* endcapassemblytrans[klayernumber];
6953   for(Int_t i=0; i<klayernumber; i++)
6954         endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
6955                                                                            -  fgkEndCapSideCoverThickness
6956                                                                            +  endcapassemblycenter[0],
6957                                                                            -  0.5*fgkEndCapCoverPlateThickness
6958                                                                            -  2.0*fgkEndCapCoolingTubeRadiusMax
6959                                                                            +  2.0*endcapassemblycenter[2]
6960                                                                            +  0.5*fgkEndCapSupportLength[i]
6961                                                                            /  TanD(0.5*upedgeangle[i]),
6962                                                                                   0.5*(fgkEndCapCoverPlateWidth[0]
6963                                                                            -  fgkEndCapCoverPlateWidth[2]
6964                                                                            - (kendcapcoverplatesmallholenumber-1)
6965                                                                            *  fgkEndCapCoverPlateSmallHoleSeparation[2]));
6966   TGeoRotation** endcapassemblyrot[klayernumber];
6967   TGeoHMatrix** endcapassemblymatrix[klayernumber];
6968   for(Int_t i=0; i<klayernumber; i++){
6969    endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
6970    endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
6971    for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
6972    endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
6973    endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
6974    endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
6975    endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
6976    for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6977         endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
6978         endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
6979    }
6980   }
6981   TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
6982                                                         fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
6983   for(Int_t i=0; i<2*klayernumber; i++){
6984         for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
6985                 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
6986                                                                                                                                            endcapassemblymatrix[1][j+2]);
6987         }
6988         fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
6989   }
6990    /////////////////////////////////////////////////////////////
6991   // Deallocating memory
6992   /////////////////////////////////////////////////////////////
6993   for(Int_t i=0; i<klayernumber; i++){
6994         for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
6995                 delete endcapassemblyrot[i][j];
6996         }
6997         delete [] endcapassemblyrot[i];
6998         delete endcapassemblymatrix[i][0];
6999         delete endcapassemblymatrix[i][1];
7000   }
7001   /////////////////////////////////////////////////////////////
7002   }
7003   void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
7004   /////////////////////////////////////////////////////////////
7005   // Setting End Cap Support + End Cap Assembly of Layer 5.
7006   /////////////////////////////////////////////////////////////
7007   if (! moth) {
7008     AliError("Can't insert end cap support of layer5, mother is null!\n");
7009     return;
7010   };
7011   if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
7012   TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7013   endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7014                                                                                                 fgkEndCapSupportCenterLay5ITSPosition
7015                                                                            +            fgkEndCapSupportCenterLay5Position
7016                                                                            -            fgkEndCapSideCoverLength[2]);
7017   endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7018                                                                                                 fgkEndCapSideCoverLength[2]
7019                                                                            -        fgkEndCapSupportCenterLay5Position
7020                                                                            -        fgkEndCapSupportCenterLay5ITSPosition);
7021   TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7022   endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7023   TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7024         new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7025   moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7026   moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7027    /////////////////////////////////////////////////////////////
7028   // Deallocating memory
7029   /////////////////////////////////////////////////////////////
7030   delete endcapsupportsystemrot;
7031   delete endcapsupportsystemITSCentertrans[1];
7032  }
7033   /////////////////////////////////////////////////////////////
7034   void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7035   /////////////////////////////////////////////////////////////
7036   // Setting End Cap Support + End Cap Assembly of Layer 6.
7037   /////////////////////////////////////////////////////////////
7038   if (! moth) {
7039     AliError("Can't insert end cap support of layer6, mother is null!\n");
7040     return;
7041   };
7042   if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
7043   TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7044   endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7045                                                                                                 fgkEndCapSupportCenterLay6ITSPosition
7046                                                                            +            fgkEndCapSupportCenterLay6Position
7047                                                                            -            fgkEndCapSideCoverLength[2]);
7048   endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7049                                                                                                 fgkEndCapSideCoverLength[2]
7050                                                                            -        fgkEndCapSupportCenterLay6Position
7051                                                                            -        fgkEndCapSupportCenterLay6ITSPosition);
7052   TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7053   endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7054   TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7055         new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7056   moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7057   moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7058    /////////////////////////////////////////////////////////////
7059   // Deallocating memory
7060   /////////////////////////////////////////////////////////////
7061   delete endcapsupportsystemrot;
7062   delete endcapsupportsystemITSCentertrans[1];
7063  }
7064  ////////////////////////////////////////////////////////////////////////////////
7065  void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7066   /////////////////////////////////////////////////////////////
7067   // Setting Ladder Support of Layer 5.
7068   /////////////////////////////////////////////////////////////
7069   if (! moth) {
7070     AliError("Can't insert ladder lupport of layer5, mother is null!\n");
7071     return;
7072   };
7073   if(!fLay5LadderSupportRing) SetLadderSupport(100);
7074   fMotherVol = moth;
7075   TGeoTranslation* centerITSRingSupportLay5trans[2];
7076   for(Int_t i=0; i<2; i++){
7077         centerITSRingSupportLay5trans[i] =
7078                 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7079     moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7080   }
7081  }
7082  ////////////////////////////////////////////////////////////////////////////////
7083  void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7084   /////////////////////////////////////////////////////////////
7085   // Setting Ladder Support of Layer 6.
7086   /////////////////////////////////////////////////////////////
7087   if (! moth) {
7088     AliError("Can't insert ladder lupport of layer6, mother is null!\n");
7089     return;
7090   };
7091   if(!fLay6LadderSupportRing) SetLadderSupport(100);
7092   fMotherVol = moth;
7093   TGeoTranslation* centerITSRingSupportLay6trans[2];
7094   for(Int_t i=0; i<2; i++){
7095         centerITSRingSupportLay6trans[i] =
7096                 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7097     moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7098   }
7099  }
7100  ////////////////////////////////////////////////////////////////////////////////
7101  void AliITSv11GeometrySSD::SSDCone(TGeoVolume* moth){
7102   /////////////////////////////////////////////////////////////
7103   // Setting Ladder Support of Layer 6.
7104   /////////////////////////////////////////////////////////////
7105   if (! moth) {
7106     AliError("Can't insert SSD Cone, mother is null!\n");
7107     return;
7108   };
7109   if(!fSSDCone) SetSSDCone();
7110   TGeoTranslation* ssdconetrans = new TGeoTranslation(0.,0.,0.5*fgkSSDCentralSupportLength
7111                                                                 +                                         fgkSSDCentralAL3SupportLength);
7112     moth->AddNode(fSSDCone,1,ssdconetrans);
7113 }
7114  ////////////////////////////////////////////////////////////////////////////////
7115  void AliITSv11GeometrySSD::SetSSDCone(){
7116   /////////////////////////////////////////////////////////////
7117   // Method generating SSDCone
7118   /////////////////////////////////////////////////////////////
7119   if(!fCreateMaterials) CreateMaterials();
7120   fSSDCone = new TGeoVolumeAssembly("ITSssdCone");
7121   Double_t ssdpconesectionradiusmax[16];
7122   Double_t ssdpconesectionradiusmin[16];
7123   Double_t ssdpconezsection[16];
7124   TGeoPcon* ssdpconelittleholeshape[8];
7125   TGeoVolume* ssdpconelittlehole[8];
7126   ssdpconezsection[0] = (fgkSSDPConeZLength[0]-fgkSSDPConeZLength[1]);
7127   ssdpconesectionradiusmin[0] = fgkSSDLowerPConeRadius;
7128   ssdpconesectionradiusmax[0] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7129                                                       / SinD(fgkSSDPConeAngle)
7130                                                           + ssdpconesectionradiusmin[0];
7131   ssdpconesectionradiusmin[1] = fgkSSDPConeLittleHoleRadius
7132                                                           - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7133                                                           / SinD(fgkSSDPConeAngle);
7134   ssdpconesectionradiusmax[1] = fgkSSDPConeLittleHoleRadius;
7135   ssdpconezsection[1] = (ssdpconesectionradiusmin[1]-ssdpconesectionradiusmin[0])
7136                                           * TanD(fgkSSDPConeAngle)+ssdpconezsection[0];
7137   ssdpconelittleholeshape[0] = new TGeoPcon(0.,360.,2);
7138   for(Int_t i=0; i<2;i++) ssdpconelittleholeshape[0]->DefineSection(i,ssdpconezsection[i],
7139                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7140   ssdpconelittlehole[0] = new TGeoVolume("SSDConeLittleHole1",ssdpconelittleholeshape[0],fSSDCarbonFiberMedium);
7141   ssdpconelittlehole[0]->SetLineColor(4);
7142   /////////////////////////////////////////////////////////////
7143   ssdpconezsection[2] = ssdpconezsection[1];
7144   ssdpconesectionradiusmin[2] = ssdpconesectionradiusmin[1];
7145   ssdpconesectionradiusmax[2] = ssdpconesectionradiusmax[1];
7146   ssdpconesectionradiusmin[3] = fgkSSDPConeLittleHoleRadius+fgkSSDPConeLittleHoleLength
7147                                                           - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7148                                                           / SinD(fgkSSDPConeAngle);
7149   ssdpconesectionradiusmax[3] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7150                                                           / SinD(fgkSSDPConeAngle)+ssdpconesectionradiusmin[3];
7151   ssdpconezsection[3] = (ssdpconesectionradiusmin[3]-ssdpconesectionradiusmin[2])
7152                                           * TanD(fgkSSDPConeAngle)+ssdpconezsection[2];
7153   Double_t ssdpconelittleholeangle = fgkSSDPConeLittleHoleLength/fgkSSDPConeLittleHoleRadius
7154                                                                    * TMath::RadToDeg();
7155   ssdpconelittleholeshape[1] = new TGeoPcon(30.+0.5*ssdpconelittleholeangle,
7156                                                                                                           60.-ssdpconelittleholeangle,2);
7157   for(Int_t i=2;i<4;i++) ssdpconelittleholeshape[1]->DefineSection(i-2,ssdpconezsection[i],
7158                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7159   ssdpconelittlehole[1] = new TGeoVolume("SSDConeLittleHole2",ssdpconelittleholeshape[1],fSSDCarbonFiberMedium);
7160   ssdpconelittlehole[1]->SetLineColor(4);
7161   TGeoRotation* ssdconelittleholerot[6];
7162   for(Int_t i=0; i<6; i++){
7163         ssdconelittleholerot[i] = new TGeoRotation();
7164     ssdconelittleholerot[i]->SetAngles(i*60,0.,0.);
7165   }
7166   /////////////////////////////////////////////////////////////
7167   ssdpconezsection[4] = ssdpconezsection[3];
7168   ssdpconesectionradiusmin[4] = ssdpconesectionradiusmin[3];
7169   ssdpconesectionradiusmax[4] = ssdpconesectionradiusmax[3];
7170   ssdpconesectionradiusmin[5] = fgkSSDConeMiddleRadius-ssdpconezsection[0]
7171                                                           * CosD(fgkSSDPConeAngle)
7172                                                           / SinD(fgkSSDPConeAngle);
7173   ssdpconesectionradiusmax[5] = fgkSSDConeMiddleRadius;
7174   ssdpconezsection[5] = (ssdpconesectionradiusmin[5]-ssdpconesectionradiusmin[4])
7175                                           * TanD(fgkSSDPConeAngle)+ssdpconezsection[4];
7176   ssdpconelittleholeshape[2] = new TGeoPcon(0.,360.,2);
7177   for(Int_t i=4; i<6;i++) ssdpconelittleholeshape[2]->DefineSection(i-4,ssdpconezsection[i],
7178                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7179   ssdpconelittlehole[2] = new TGeoVolume("SSDConeLittleHole3",ssdpconelittleholeshape[2],fSSDCarbonFiberMedium);
7180   ssdpconelittlehole[2]->SetLineColor(4);
7181   ///////////////////////////////////////////////////
7182   ssdpconezsection[6] = ssdpconezsection[5];
7183   ssdpconesectionradiusmin[6] = ssdpconesectionradiusmin[5];
7184   ssdpconesectionradiusmax[6] = ssdpconesectionradiusmax[5];
7185   ssdpconesectionradiusmin[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength
7186                                                           -ssdpconezsection[0]
7187                                                           * CosD(fgkSSDPConeAngle)
7188                                                           / SinD(fgkSSDPConeAngle);
7189   ssdpconesectionradiusmax[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength;
7190   ssdpconezsection[7] = (ssdpconesectionradiusmin[7]-ssdpconesectionradiusmin[6])
7191                                           * TanD(fgkSSDPConeAngle)+ssdpconezsection[6];
7192   Double_t ssdpconemiddleholeangle = fgkSSDPConeMiddleWidth/fgkSSDConeMiddleRadius
7193                                                                    * TMath::RadToDeg();
7194   ssdpconelittleholeshape[3] = new TGeoPcon(22.5+0.5*ssdpconemiddleholeangle,
7195                                                                                                           45.-ssdpconemiddleholeangle,2);
7196   for(Int_t i=6;i<8;i++) ssdpconelittleholeshape[3]->DefineSection(i-6,ssdpconezsection[i],
7197                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7198   ssdpconelittlehole[3] = new TGeoVolume("SSDConeLittleHole4",ssdpconelittleholeshape[3],fSSDCarbonFiberMedium);
7199   ssdpconelittlehole[3]->SetLineColor(4);
7200   TGeoRotation* ssdconemiddleholerot[8];
7201   for(Int_t i=0; i<8; i++){
7202         ssdconemiddleholerot[i] = new TGeoRotation();
7203     ssdconemiddleholerot[i]->SetAngles(i*45,0.,0.);
7204   }
7205   /////////////////////////////////////////////////////////////
7206   ssdpconezsection[8] = ssdpconezsection[7];
7207   ssdpconesectionradiusmin[8] = ssdpconesectionradiusmin[7];
7208   ssdpconesectionradiusmax[8] = ssdpconesectionradiusmax[7];
7209   ssdpconesectionradiusmin[9] = fgkSSDPConeUpRadius-ssdpconezsection[0]
7210                                                           * CosD(fgkSSDPConeAngle)
7211                                                           / SinD(fgkSSDPConeAngle);
7212   ssdpconesectionradiusmax[9] = fgkSSDPConeUpRadius;
7213   ssdpconezsection[9] = (ssdpconesectionradiusmin[9]-ssdpconesectionradiusmin[8])
7214                                           * TanD(fgkSSDPConeAngle)+ssdpconezsection[8];
7215   ssdpconelittleholeshape[4] = new TGeoPcon(0.,360.,2);
7216   for(Int_t i=8; i<10;i++) ssdpconelittleholeshape[4]->DefineSection(i-8,ssdpconezsection[i],
7217                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7218   ssdpconelittlehole[4] = new TGeoVolume("SSDConeLittleHole5",ssdpconelittleholeshape[4],fSSDCarbonFiberMedium);
7219   ssdpconelittlehole[4]->SetLineColor(4);
7220   /////////////////////////////////////////////////////////////
7221   Double_t ssdconetrapezoidheight = fgkSSDPConeUpMaxRadius-fgkSSDPConeUpRadius;
7222   Double_t ssdconetrapezoidbasis = fgkSSDPConeTrapezoidBasis-2.0
7223                                                                  * (0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)
7224                                                                  -  0.5*ssdconetrapezoidheight/(fgkSSDPConeUpMaxRadius
7225                                                                  -  0.5*ssdconetrapezoidheight)*(0.5*fgkSSDPConeTrapezoidBasis
7226                                                                  -  0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)));
7227   Double_t ssdconetrapezoidsection = (2.0*TMath::Pi()*fgkSSDPConeUpMaxRadius-8.0*ssdconetrapezoidbasis)/8.;
7228   Double_t ssdpconetrapezoidsectionangle = ssdconetrapezoidsection/fgkSSDPConeUpMaxRadius
7229                                                                                  * TMath::RadToDeg();
7230   ssdpconezsection[10] = ssdpconezsection[9];
7231   ssdpconesectionradiusmin[10] = ssdpconesectionradiusmin[9];
7232   ssdpconesectionradiusmax[10] = ssdpconesectionradiusmax[9];
7233   ssdpconesectionradiusmin[11] = fgkSSDPConeUpMaxRadius-ssdpconezsection[0]
7234                                                           * CosD(fgkSSDPConeAngle)
7235                                                           / SinD(fgkSSDPConeAngle);
7236   ssdpconesectionradiusmax[11] = fgkSSDPConeUpMaxRadius;
7237   ssdpconezsection[11] = (ssdpconesectionradiusmin[11]-ssdpconesectionradiusmin[10])
7238                                            * TanD(fgkSSDPConeAngle)+ssdpconezsection[10];
7239   ssdpconelittleholeshape[5] = new TGeoPcon(90.-0.5*ssdpconetrapezoidsectionangle,
7240                                                                                         ssdpconetrapezoidsectionangle,2);
7241   for(Int_t i=10;i<12;i++) ssdpconelittleholeshape[5]->DefineSection(i-10,ssdpconezsection[i],
7242                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7243   ssdpconelittlehole[5] = new TGeoVolume("SSDConeLittleHole6",ssdpconelittleholeshape[5],fSSDCarbonFiberMedium);
7244   ssdpconelittlehole[5]->SetLineColor(4);
7245   TGeoRotation* ssdconeupradiusrot[8];
7246   for(Int_t i=0; i<8; i++){
7247         ssdconeupradiusrot[i] = new TGeoRotation();
7248     ssdconeupradiusrot[i]->SetAngles(i*45,0.,0.);
7249   }
7250   /////////////////////////////////////////////////////////////
7251   ssdpconezsection[12] = ssdpconezsection[11];
7252   ssdpconezsection[13] = ssdpconezsection[12]+fgkSSDPConeRadiusWidth;
7253   ssdpconesectionradiusmin[12] = ssdpconesectionradiusmin[11];
7254   ssdpconesectionradiusmax[12] = fgkSSDPConeExternalRadius;
7255   ssdpconesectionradiusmin[13] = ssdpconesectionradiusmin[12];
7256   ssdpconesectionradiusmax[13] = fgkSSDPConeExternalRadius;
7257   ssdpconelittleholeshape[6] = new TGeoPcon(0.,360.,2);
7258   for(Int_t i=12; i<14;i++) ssdpconelittleholeshape[6]->DefineSection(i-12,ssdpconezsection[i],
7259                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7260   ssdpconelittlehole[6] = new TGeoVolume("SSDConeLittleHole7",ssdpconelittleholeshape[6],fSSDCarbonFiberMedium);
7261   ssdpconelittlehole[6]->SetLineColor(4);
7262   /////////////////////////////////////////////////////////////
7263   ssdpconezsection[14] = 0.0;
7264   ssdpconezsection[15] = ssdpconezsection[0];
7265   ssdpconesectionradiusmin[14] = ssdpconesectionradiusmin[0];
7266   ssdpconesectionradiusmax[14] = ssdpconesectionradiusmin[14];
7267   ssdpconesectionradiusmin[15] = ssdpconesectionradiusmin[0];
7268   ssdpconesectionradiusmax[15] = ssdpconesectionradiusmax[0];
7269   ssdpconelittleholeshape[7] = new TGeoPcon(0.,360.,2);
7270   for(Int_t i=14; i<16;i++) ssdpconelittleholeshape[7]->DefineSection(i-14,ssdpconezsection[i],
7271                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7272   ssdpconelittlehole[7] = new TGeoVolume("SSDConeLittleHole8",ssdpconelittleholeshape[7],fSSDCarbonFiberMedium);
7273   ssdpconelittlehole[7]->SetLineColor(4);
7274   /////////////////////////////////////////////////////////////
7275   TGeoTube* ssdtubeconeshape[2];
7276   TGeoVolume* ssdtubecone[2];
7277   TGeoTranslation* ssdtubeconetrans[2];
7278   ssdtubeconeshape[0] = new TGeoTube(fgkSSDPConeUpMiddleRadius,
7279                                                                            fgkSSDPConeExternalRadius,
7280                                                                            0.5*(fgkSSDPConeLength-ssdpconezsection[13]));
7281   ssdtubeconeshape[1] = new TGeoTube(fgkSSDPConeDownRadius,ssdpconesectionradiusmin[0],
7282                                                                            0.5*ssdpconezsection[0]);
7283   ssdtubecone[0] = new TGeoVolume("SSDConeTube1",ssdtubeconeshape[0],fSSDSupportRingAl);
7284   ssdtubecone[1] = new TGeoVolume("SSDConeTube2",ssdtubeconeshape[1],fSSDSupportRingAl);
7285   ssdtubeconetrans[0] = new TGeoTranslation(0.,0.,
7286                                                 0.5*(fgkSSDPConeLength-ssdpconezsection[13])
7287                                           + ssdpconezsection[13]);
7288   ssdtubeconetrans[1] = new TGeoTranslation(0.,0.,0.5*ssdpconezsection[0]);
7289   ssdtubecone[0]->SetLineColor(4);
7290   ssdtubecone[1]->SetLineColor(4);
7291   /////////////////////////////////////////////////////////////
7292   // Mother Volume Container
7293   /////////////////////////////////////////////////////////////
7294   Double_t ssdconemotherradiusmin[8];
7295   Double_t ssdconemotherradiusmax[8];
7296   Double_t ssdconemothersection[8];
7297   ssdconemotherradiusmin[0] = fgkSSDPConeDownRadius;
7298   ssdconemotherradiusmax[0] = ssdpconesectionradiusmin[0];
7299   ssdconemotherradiusmin[1] = fgkSSDPConeDownRadius;
7300   ssdconemotherradiusmax[1] = ssdpconesectionradiusmax[0];
7301   ssdconemotherradiusmin[2] = ssdpconesectionradiusmin[0];
7302   ssdconemotherradiusmax[2] = ssdpconesectionradiusmax[0];
7303   ssdconemotherradiusmin[3] = ssdpconesectionradiusmin[11];
7304   ssdconemotherradiusmax[3] = ssdpconesectionradiusmax[11];
7305   ssdconemotherradiusmin[4] = ssdpconesectionradiusmin[12];
7306   ssdconemotherradiusmax[4] = ssdpconesectionradiusmax[12];
7307   ssdconemotherradiusmin[5] = ssdpconesectionradiusmin[13];
7308   ssdconemotherradiusmax[5] = ssdpconesectionradiusmax[13];
7309   ssdconemotherradiusmin[6] = fgkSSDPConeUpMiddleRadius;
7310   ssdconemotherradiusmax[6] = fgkSSDPConeExternalRadius;
7311   ssdconemotherradiusmin[7] = fgkSSDPConeUpMiddleRadius;
7312   ssdconemotherradiusmax[7] = fgkSSDPConeExternalRadius;
7313   ssdconemothersection[0] = 0.0;
7314   ssdconemothersection[1] = ssdpconezsection[0];
7315   ssdconemothersection[2] = ssdpconezsection[0];
7316   ssdconemothersection[3] = ssdpconezsection[11];
7317   ssdconemothersection[4] = ssdpconezsection[11];
7318   ssdconemothersection[5] = ssdpconezsection[13];
7319   ssdconemothersection[6] = ssdpconezsection[13];
7320   ssdconemothersection[7] = fgkSSDPConeLength;
7321   TGeoPcon* ssdconemothershape = new TGeoPcon(0.,360,8);
7322   for(Int_t i=0; i<8; i++) ssdconemothershape->DefineSection(i,ssdconemothersection[i],
7323                                                                         ssdconemotherradiusmin[i],ssdconemotherradiusmax[i]);
7324   TGeoVolume* ssdconemother = new TGeoVolume("SSDMotherCone",ssdconemothershape,fSSDAir);
7325   /////////////////////////////////////////////////////////////
7326   //Placing the Volumes into Mother
7327   /////////////////////////////////////////////////////////////
7328   ssdconemother->AddNode(ssdpconelittlehole[0],1);
7329   for(Int_t i=0; i<6; i++){
7330         ssdconemother->AddNode(ssdpconelittlehole[1],i+1,ssdconelittleholerot[i]);
7331   }
7332   ssdconemother->AddNode(ssdpconelittlehole[2],1);
7333   for(Int_t i=0; i<8; i++){
7334     ssdconemother->AddNode(ssdpconelittlehole[3],i+1,ssdconemiddleholerot[i]);
7335   }
7336   ssdconemother->AddNode(ssdpconelittlehole[4],1);
7337   for(Int_t i=0; i<8; i++){
7338     ssdconemother->AddNode(ssdpconelittlehole[5],i+1,ssdconeupradiusrot[i]);
7339   }
7340   ssdconemother->AddNode(ssdpconelittlehole[6],1);
7341   ssdconemother->AddNode(ssdpconelittlehole[7],1);
7342   ssdconemother->AddNode(ssdtubecone[0],1,ssdtubeconetrans[0]);
7343   ssdconemother->AddNode(ssdtubecone[1],1,ssdtubeconetrans[1]);
7344   /////////////////////////////////////////////////////////////
7345   // ITS General Support
7346   /////////////////////////////////////////////////////////////
7347   TGeoTube* ssdcentralsupportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7348                                                                 fgkSSDCentralSupportRadius,0.5*fgkSSDCentralSupportLength);
7349   TGeoVolume* ssdcentralsupport = new TGeoVolume("SSDCentralSupport",ssdcentralsupportshape,fSSDRohaCellCone);
7350   TGeoTranslation* ssdcentralsupportrans = new TGeoTranslation(0.,0.,-0.5*fgkSSDCentralSupportLength
7351                                                                              - fgkSSDCentralAL3SupportLength);
7352   ssdcentralsupport->SetLineColor(4);
7353   fSSDCone->AddNode(ssdcentralsupport,1,ssdcentralsupportrans);
7354   TGeoTube* ssdcentralal3supportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7355                                                                 fgkSSDCentralSupportRadius,0.25*fgkSSDCentralAL3SupportLength);
7356   TGeoVolume* ssdcentralal3support = new TGeoVolume("SSDCentralAl3Support",ssdcentralal3supportshape,fSSDSupportRingAl);
7357   TGeoTranslation* ssdcentralal3supportrans[3];
7358   ssdcentralal3supportrans[0] = new TGeoTranslation(0.,0.,-0.75*fgkSSDCentralAL3SupportLength);
7359   ssdcentralal3supportrans[1] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7360                                                           - 1.25*fgkSSDCentralAL3SupportLength);
7361   ssdcentralal3support->SetLineColor(4);
7362   fSSDCone->AddNode(ssdcentralal3support,1,ssdcentralal3supportrans[0]);
7363   fSSDCone->AddNode(ssdcentralal3support,2,ssdcentralal3supportrans[1]);
7364   TGeoPcon* ssdpconcentralal3shape = new TGeoPcon(0.,360.,2);
7365   Double_t ssdpconcentralradiusmin[2];
7366   Double_t ssdpconcentralradiusmax[2];
7367   Double_t ssdpconcentralsection[2];
7368   ssdpconcentralradiusmin[0] = fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth;
7369   ssdpconcentralradiusmin[1] = fgkSSDCentralSupportRadius-fgkSSDCentralAL3SupportWidth;
7370   ssdpconcentralradiusmax[0] = fgkSSDCentralSupportRadius;
7371   ssdpconcentralradiusmax[1] = fgkSSDCentralSupportRadius;
7372   ssdpconcentralsection[0] = -0.5*fgkSSDCentralAL3SupportLength;
7373   ssdpconcentralsection[1] = 0.;
7374   for(Int_t i=0; i<2;i++) ssdpconcentralal3shape->DefineSection(i,ssdpconcentralsection[i],
7375                                                   ssdpconcentralradiusmin[i],ssdpconcentralradiusmax[i]);
7376   TGeoVolume* ssdpconcentralal3 = new TGeoVolume("SSDPConeCentralAl3",ssdpconcentralal3shape,fSSDSupportRingAl);
7377   ssdpconcentralal3->SetLineColor(4);
7378   fSSDCone->AddNode(ssdpconcentralal3,1);
7379   TGeoRotation* ssdcentralal3supportrot = new TGeoRotation();
7380   ssdcentralal3supportrot->SetAngles(90.,180,-90.);
7381   ssdcentralal3supportrans[2] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7382                                                                 -2.*fgkSSDCentralAL3SupportLength);
7383   TGeoCombiTrans* ssdcentralal3supporcombitrans = new TGeoCombiTrans(*ssdcentralal3supportrans[2],
7384                                                                                                                      *ssdcentralal3supportrot);
7385   fSSDCone->AddNode(ssdpconcentralal3,2,ssdcentralal3supporcombitrans);
7386   TGeoRotation* ssdconemotherot = new TGeoRotation();
7387   ssdconemotherot->SetAngles(90.,180.,-90.);
7388   TGeoTranslation* ssdconemothertrans = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7389                                                                                                                         -2.*fgkSSDCentralAL3SupportLength);
7390   TGeoCombiTrans* ssdconemothercombitrans = new TGeoCombiTrans(*ssdconemothertrans,*ssdconemotherot);
7391   fSSDCone->AddNode(ssdconemother,1);
7392   fSSDCone->AddNode(ssdconemother,2,ssdconemothercombitrans);
7393   /////////////////////////////////////////////////////////////
7394   // Deallocating memory
7395   /////////////////////////////////////////////////////////////
7396   delete ssdcentralal3supportrot;
7397   delete ssdcentralal3supportrans[2];
7398   delete ssdconemotherot;
7399   delete ssdconemothertrans;
7400   /////////////////////////////////////////////////////////////
7401  }
7402  ////////////////////////////////////////////////////////////////////////////////
7403  void AliITSv11GeometrySSD::SSDCables(TGeoVolume* moth){
7404   /////////////////////////////////////////////////////////////
7405   // Setting SSD Cables
7406   /////////////////////////////////////////////////////////////
7407   if (! moth) {
7408     AliError("Can't insert SSD Cables, mother is null!\n");
7409     return;
7410   };
7411   TGeoVolume* ssdcables = SetSSDCables();
7412   moth->AddNode(ssdcables,1);
7413 }
7414  ////////////////////////////////////////////////////////////////////////////////
7415  TGeoVolume* AliITSv11GeometrySSD::SetSSDCables(){
7416   /////////////////////////////////////////////////////////////
7417   // Method generating SSDCables
7418   /////////////////////////////////////////////////////////////
7419   // SSD Layer 5 Cables
7420   //////////////////////////////////////////////////////////////////////////////////////////////////
7421   TGeoVolumeAssembly* ssdcablesmother = new TGeoVolumeAssembly("SSDCables");
7422   Double_t ssdcablelayvertical = 0.05; // Internal variables to control overlapping with SDD cables
7423   Double_t ssdcablelaylateral = 0.55;   // Internal variables to control overlapping with SDD cables
7424   Double_t ssdcablesfactor = 0.5;     // Internal variables to control overlapping with SDD cables
7425   //////////////////////////////////////////////////////////////////////////////////////////////////
7426   Double_t ssdcableslay5rigthsideradiusmin = fgkEndCapSupportMiddleRadius[0]+fgkSSDCablesLay5TubeRadiusMin;
7427   Double_t ssdcableslay5endconedistance = (ssdcableslay5rigthsideradiusmin
7428                                                                             -  fgkSSDLowerPConeRadius)
7429                                                                             * TanD(fgkSSDPConeAngle);
7430   Double_t ssdcableslay5startconedistance = fgkEndCapSupportCenterLay5ITSPosition
7431                                                                               + fgkEndCapSupportCenterLay5Position
7432                                                                               - 0.5*fgkSSDCentralSupportLength-fgkSSDCentralAL3SupportLength;
7433   Double_t ssdcablelay5rightsidelength = ssdcableslay5endconedistance
7434                                                                            - ssdcableslay5startconedistance;
7435   ssdcablelay5rightsidelength *= ssdcablesfactor;
7436   Double_t ssdcableslay5rightsideradiusmax = ssdcableslay5rigthsideradiusmin+fgkSSDCablesLay5RightSideHeight;
7437   TGeoTube* ssdcablelay5rightubeshape = new TGeoTube(ssdcableslay5rigthsideradiusmin,
7438                                                                                                 ssdcableslay5rightsideradiusmax,
7439                                                                                                 0.5*ssdcablelay5rightsidelength);
7440   TGeoVolume* ssdcablelay5righttube = new TGeoVolume("SSDCableLay5RightSideTube",
7441                                                                                                          ssdcablelay5rightubeshape,
7442                                                                                                          fSSDCopper);
7443   ssdcablelay5righttube->SetLineColor(9);
7444   TGeoTranslation* ssdcablelay5rightrans =
7445                                           new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay5ITSPosition
7446                                                                                  +              fgkEndCapSupportCenterLay5Position
7447                                                                                  +      0.5*ssdcablelay5rightsidelength);
7448   ////////////////////////////////////
7449   //  Double_t cablescapacity[20];
7450   //  cablescapacity[0] = ssdcablelay5rightubeshape->Capacity();
7451   ////////////////////////////////////
7452   ssdcablesmother->AddNode(ssdcablelay5righttube,1,ssdcablelay5rightrans);
7453   ////////////////////////////////////
7454   // TGeoPCone Volumes
7455   ///////////////////////////////////
7456   TGeoPcon* ssdcableslay5pconshape[3];
7457   TGeoVolume* ssdcableslay5pcon[3];
7458   ssdcableslay5pconshape[0] = new TGeoPcon(0.,360.,2);
7459   Double_t ssdcableslay5pconzsection[6];
7460   Double_t ssdcableslay5pconrmin[6];
7461   Double_t ssdcableslay5pconrmax[6];
7462   ssdcableslay5pconrmin[0] = ssdcablelay5rightubeshape->GetRmin();
7463   ssdcableslay5pconrmax[0] = ssdcablelay5rightubeshape->GetRmax();
7464   ssdcableslay5pconrmin[1] = fgkSSDPConeUpRadius*(1.0+ssdcablelayvertical);
7465   ssdcableslay5pconrmax[1] = ssdcableslay5pconrmin[1]+fgkSSDCablesLay5RightSideHeight;
7466   ssdcableslay5pconzsection[0] = fgkEndCapSupportCenterLay5ITSPosition
7467                                                            + fgkEndCapSupportCenterLay5Position
7468                                                            + 2.*ssdcablelay5rightubeshape->GetDz();
7469   ssdcableslay5pconzsection[1] = 0.5*fgkSSDCentralSupportLength
7470                                                            + fgkSSDCentralAL3SupportLength
7471                                                            + (fgkSSDPConeUpRadius-fgkSSDLowerPConeRadius)
7472                                                            * TanD(fgkSSDPConeAngle);
7473   for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[0]->DefineSection(i,ssdcableslay5pconzsection[i],
7474                                                   ssdcableslay5pconrmin[i],ssdcableslay5pconrmax[i]);
7475   ssdcableslay5pcon[0] = new TGeoVolume("SSDCableLay5RightSidePCon1",
7476                                                            ssdcableslay5pconshape[0],fSSDCopper);
7477   ssdcableslay5pcon[0]->SetLineColor(9);
7478   ssdcablesmother->AddNode(ssdcableslay5pcon[0],1);
7479 ////////////////////////////////////
7480 //  cablescapacity[1] = ssdcableslay5pconshape[0]->Capacity();
7481 ////////////////////////////////////
7482   ssdcableslay5pconzsection[2] = ssdcableslay5pconzsection[1];
7483   ssdcableslay5pconzsection[3] = 0.5*fgkSSDCentralSupportLength
7484                                                            + fgkSSDCentralAL3SupportLength
7485                                                            + 0.25*TanD(fgkSSDPConeAngle)*(fgkSSDPConeUpMaxRadius
7486                                                            + 3.*fgkSSDPConeUpRadius-4.*fgkSSDLowerPConeRadius);
7487   Double_t ssdcableangle = (fgkSSDPConeTrapezoidBasis-2.*(fgkSSDPConeUpMaxRadius
7488                                              -  fgkSSDPConeUpRadius)/TanD(fgkSSDPConeTrapezoidAngle))
7489                                                  /  fgkSSDPConeUpRadius*TMath::RadToDeg()*2;
7490   ssdcableslay5pconshape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7491                                                                                    ssdcableangle,2);
7492   ssdcableslay5pconrmin[2] = ssdcableslay5pconrmin[1];
7493   ssdcableslay5pconrmax[2] = ssdcableslay5pconrmax[1];
7494   ssdcableslay5pconrmin[3] = 0.25*(fgkSSDPConeUpMaxRadius+3.*fgkSSDPConeUpRadius
7495                                                    - 4.*fgkSSDLowerPConeRadius)+fgkSSDLowerPConeRadius;
7496   ssdcableslay5pconrmin[3]*=(1.0+ssdcablelayvertical);
7497   ssdcableslay5pconrmax[3] = ssdcableslay5pconrmin[3]+fgkSSDCablesLay5RightSideHeight;
7498   for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[1]->DefineSection(i,ssdcableslay5pconzsection[i+2],
7499                                                   ssdcableslay5pconrmin[i+2],ssdcableslay5pconrmax[i+2]);
7500   ssdcableslay5pcon[1] = new TGeoVolume("SSDCableLay5RightSidePCon2",ssdcableslay5pconshape[1],fSSDCopper);
7501   ssdcableslay5pcon[1]->SetLineColor(9);
7502   ////////////////////////////////////
7503   ssdcableslay5pconshape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7504                                                                                    ssdcableangle,2);
7505   ssdcableslay5pconrmin[4] = ssdcableslay5pconrmin[3];
7506   ssdcableslay5pconrmax[4] = ssdcableslay5pconrmax[3];
7507   ssdcableslay5pconrmin[5] = ssdcableslay5pconrmin[4];
7508   ssdcableslay5pconrmax[5] = ssdcableslay5pconrmax[4];
7509   ssdcableslay5pconzsection[4] = ssdcableslay5pconzsection[3];
7510   ssdcableslay5pconzsection[5] = (ssdcableslay5pconrmin[5]-fgkSSDLowerPConeRadius)
7511                                                            * TanD(fgkSSDPConeAngle)
7512                                                            + 0.5*fgkSSDCentralSupportLength
7513                                                            + fgkSSDCentralAL3SupportLength;
7514   ssdcableslay5pconzsection[5]-= ssdcablelaylateral;
7515   for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[2]->DefineSection(i,ssdcableslay5pconzsection[i+4],
7516                                                   ssdcableslay5pconrmin[i+4],ssdcableslay5pconrmax[i+4]);
7517   ssdcableslay5pcon[2] = new TGeoVolume("SSDCableLay5RightSidePCon3",ssdcableslay5pconshape[2],fSSDCopper);
7518   ssdcableslay5pcon[2]->SetLineColor(9);
7519 ////////////////////////////////////
7520   TGeoRotation* ssdcableslay5pconrot[4];
7521   for(Int_t i=0; i<4; i++){
7522    ssdcableslay5pconrot[i] = new TGeoRotation();
7523    ssdcableslay5pconrot[i]->SetAngles(90.0*i,0.,0.);
7524    ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+1,ssdcableslay5pconrot[i]);
7525    ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+1,ssdcableslay5pconrot[i]);
7526   }
7527   ////////////////////////////////////
7528   //cablescapacity[2] = 4.0*ssdcableslay5pconshape[1]->Capacity();
7529   //cablescapacity[3] = 4.0*ssdcableslay5pconshape[2]->Capacity();
7530   ////////////////////////////////////
7531   // Positioning Left SSD Cables Part
7532   ////////////////////////////////////
7533   TGeoTranslation* ssdcablesLay5RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7534                                                                                                         - 0.5*ssdcablelay5rightsidelength
7535                                                                                                         - fgkEndCapSupportCenterLay5Position
7536                                                                                                     - fgkEndCapSupportCenterLay5ITSPosition);
7537   ssdcablesmother->AddNode(ssdcablelay5righttube,2,ssdcablesLay5RightTubeToLeftrans);
7538   TGeoRotation* ssdcablesLay5RightPConToLeftRot = new TGeoRotation();
7539   ssdcablesLay5RightPConToLeftRot->SetAngles(90.,180.,-90);
7540   ssdcablesmother->AddNode(ssdcableslay5pcon[0],2,ssdcablesLay5RightPConToLeftRot);
7541   TGeoHMatrix* ssdcablesLay5RightPConToLeftMatrix[4];
7542   for(Int_t i=0; i<4; i++){ ssdcablesLay5RightPConToLeftMatrix[i] =
7543         new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconrot[i]));
7544         ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7545     ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7546   }
7547   ////////////////////////////////////
7548   //cablescapacity[4] = ssdcablelay5rightubeshape->Capacity();
7549   //cablescapacity[5] = ssdcableslay5pconshape[0]->Capacity();
7550   //cablescapacity[6] = 4.*ssdcableslay5pconshape[1]->Capacity();
7551   //cablescapacity[7] = 4.*ssdcableslay5pconshape[2]->Capacity();
7552   /////////////////////////////////////////////////////////////
7553   // Water Tubes Layer 5
7554   /////////////////////////
7555   TGeoTube* ssdcablelay5rightubewatershape = new TGeoTube(ssdcableslay5rightsideradiusmax,
7556                                                                                      ssdcableslay5rightsideradiusmax
7557                                                                                + fgkSSDCablesLay5RightSideWaterHeight,
7558                                                                                      0.5*ssdcablelay5rightsidelength);
7559   TGeoVolume* ssdcablelay5rightwatertube = new TGeoVolume("SSDCableLay5RightSideWaterTube",
7560                                                                                                          ssdcablelay5rightubewatershape,
7561                                                                                                          fSSDCoolingTubeWater);
7562   ssdcablelay5rightwatertube->SetLineColor(7);
7563   ssdcablesmother->AddNode(ssdcablelay5rightwatertube,1,ssdcablelay5rightrans);
7564   ssdcablesmother->AddNode(ssdcablelay5rightwatertube,2,ssdcablesLay5RightTubeToLeftrans);
7565   ////////////////////////////////////
7566   // TGeoPCone Water Volumes Layer
7567   ///////////////////////////////////
7568   TGeoPcon* ssdcableslay5pconwatershape[3];
7569   TGeoVolume* ssdcableslay5pconwater[3];
7570   ssdcableslay5pconwatershape[0] = new TGeoPcon(0.,360.,2);
7571   Double_t ssdcableslay5pconwaterzsection[6];
7572   Double_t ssdcableslay5pcwateronrmin[6];
7573   Double_t ssdcableslay5pconwaterrmax[6];
7574   ssdcableslay5pcwateronrmin[0] = ssdcableslay5pconrmax[0];
7575   ssdcableslay5pconwaterrmax[0] = ssdcableslay5pcwateronrmin[0]
7576                                                                 + fgkSSDCablesLay5RightSideWaterHeight;
7577   ssdcableslay5pcwateronrmin[1] = ssdcableslay5pconrmax[1];
7578   ssdcableslay5pconwaterrmax[1] = ssdcableslay5pcwateronrmin[1]
7579                                                                 + fgkSSDCablesLay5RightSideWaterHeight;
7580   ssdcableslay5pconwaterzsection[0] = ssdcableslay5pconzsection[0];
7581   ssdcableslay5pconwaterzsection[1] = ssdcableslay5pconzsection[1];
7582   for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[0]->DefineSection(i,ssdcableslay5pconwaterzsection[i],
7583                                                   ssdcableslay5pcwateronrmin[i],ssdcableslay5pconwaterrmax[i]);
7584   ssdcableslay5pconwater[0] = new TGeoVolume("SSDCableLay5RightSidePConWater1",
7585                                                            ssdcableslay5pconwatershape[0],fSSDCoolingTubeWater);
7586   ssdcableslay5pconwater[0]->SetLineColor(7);
7587   ssdcablesmother->AddNode(ssdcableslay5pconwater[0],1);
7588   ssdcablesmother->AddNode(ssdcableslay5pconwater[0],2,ssdcablesLay5RightPConToLeftRot);
7589 ////////////////////////////////////
7590   ssdcableslay5pconwaterzsection[2] = ssdcableslay5pconzsection[2];
7591   ssdcableslay5pconwaterzsection[3] = ssdcableslay5pconzsection[3];
7592   ssdcableslay5pconwatershape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7593                                                                                                 ssdcableangle,2);
7594   ssdcableslay5pcwateronrmin[2] = ssdcableslay5pconrmax[1];
7595   ssdcableslay5pconwaterrmax[2] = ssdcableslay5pcwateronrmin[2]
7596                                                                 + fgkSSDCablesLay5RightSideWaterHeight;
7597   ssdcableslay5pcwateronrmin[3] = ssdcableslay5pconrmax[3];
7598   ssdcableslay5pconwaterrmax[3] = ssdcableslay5pcwateronrmin[3]
7599                                                                 + fgkSSDCablesLay5RightSideWaterHeight;
7600   for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[1]->DefineSection(i,ssdcableslay5pconwaterzsection[i+2],
7601                                                   ssdcableslay5pcwateronrmin[i+2],ssdcableslay5pconwaterrmax[i+2]);
7602   ssdcableslay5pconwater[1] = new TGeoVolume("SSDCableLay5RightSidePConWater2",
7603                                                            ssdcableslay5pconwatershape[1],fSSDCoolingTubeWater);
7604   ssdcableslay5pconwater[1]->SetLineColor(7);
7605 ////////////////////////////////////
7606   ssdcableslay5pconwatershape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7607                                                                                                 ssdcableangle,2);
7608   ssdcableslay5pcwateronrmin[4] = ssdcableslay5pconrmax[3];
7609   ssdcableslay5pconwaterrmax[4] = ssdcableslay5pcwateronrmin[4]
7610                                                                 + fgkSSDCablesLay5RightSideWaterHeight;
7611   ssdcableslay5pcwateronrmin[5] = ssdcableslay5pconrmax[4];
7612   ssdcableslay5pconwaterrmax[5] = ssdcableslay5pcwateronrmin[4]
7613                                                                 + fgkSSDCablesLay5RightSideWaterHeight;
7614   ssdcableslay5pconwaterzsection[4] = ssdcableslay5pconzsection[4];
7615   ssdcableslay5pconwaterzsection[5] = ssdcableslay5pconzsection[5];
7616   for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[2]->DefineSection(i,ssdcableslay5pconwaterzsection[i+4],
7617                                                   ssdcableslay5pcwateronrmin[i+4],ssdcableslay5pconwaterrmax[i+4]);
7618   ssdcableslay5pconwater[2] = new TGeoVolume("SSDCableLay5RightSidePConWater3",
7619                                                            ssdcableslay5pconwatershape[2],fSSDCoolingTubeWater);
7620   ssdcableslay5pconwater[2]->SetLineColor(7);
7621 ////////////////////////////////////
7622   TGeoRotation* ssdcableslay5pconwaterot[4];
7623   TGeoHMatrix* ssdcablesLay5RightPConWaterToLeftMatrix[4];
7624   for(Int_t i=0; i<4; i++){
7625    ssdcableslay5pconwaterot[i] = new TGeoRotation();
7626    ssdcableslay5pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7627    ssdcablesLay5RightPConWaterToLeftMatrix[i] =
7628         new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconwaterot[i]));
7629         ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+1,ssdcableslay5pconwaterot[i]);
7630         ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7631         ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+1,ssdcableslay5pconwaterot[i]);
7632         ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7633   }
7634   /////////////////////////
7635   // SSD Layer 6 Cables
7636   /////////////////////////
7637   Double_t ssdcableslay6rigthsideradiusmin = fgkEndCapSupportMiddleRadius[1]+fgkSSDCablesLay6TubeRadiusMin;
7638   Double_t ssdcablelay6rightsidelength = 2.*ssdcablelay5rightsidelength;
7639   Double_t ssdcableslay6rightsideradiusmax = ssdcableslay6rigthsideradiusmin+fgkSSDCablesLay6RightSideHeight;
7640   TGeoTube* ssdcablelay6rightubeshape = new TGeoTube(ssdcableslay6rigthsideradiusmin,
7641                                                                                                 ssdcableslay6rightsideradiusmax,
7642                                                                                                 0.5*ssdcablelay6rightsidelength);
7643   TGeoVolume* ssdcablelay6righttube = new TGeoVolume("SSDCableLay6RightSideTube",
7644                                                                                                          ssdcablelay6rightubeshape,
7645                                                                                                          fSSDCopper);
7646   ssdcablelay6righttube->SetLineColor(9);
7647   TGeoTranslation* ssdcablelay6rightrans =
7648                                           new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay6ITSPosition
7649                                                                                  +              fgkEndCapSupportCenterLay6Position
7650                                                                                  +      0.5*ssdcablelay6rightsidelength);
7651   TGeoTranslation* ssdcablesLay6RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7652                                                                                                         - 0.5*ssdcablelay6rightsidelength
7653                                                                                                         - fgkEndCapSupportCenterLay6Position
7654                                                                                                     - fgkEndCapSupportCenterLay6ITSPosition);
7655   ssdcablesmother->AddNode(ssdcablelay6righttube,1,ssdcablelay6rightrans);
7656   ssdcablesmother->AddNode(ssdcablelay6righttube,2,ssdcablesLay6RightTubeToLeftrans);
7657   ////////////////////////////////////
7658   //cablescapacity[8] = 2.*ssdcablelay6rightubeshape->Capacity();
7659   ////////////////////////////////////
7660   TGeoPcon* ssdcableslay6pconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7661                                                                                    ssdcableangle,2);
7662   TGeoVolume* ssdcableslay6pcon;
7663   Double_t ssdcableslay6pconrmin[2];
7664   Double_t ssdcableslay6pconrmax[2];
7665   Double_t ssdcableslay6pconzsection[2];
7666   ssdcableslay6pconrmin[0] = ssdcableslay6rigthsideradiusmin;
7667   ssdcableslay6pconrmax[0] = ssdcableslay6rightsideradiusmax;
7668   ssdcableslay6pconrmin[1] = ssdcableslay6pconrmin[0];
7669   ssdcableslay6pconrmax[1] = ssdcableslay6pconrmax[0];
7670   ssdcableslay6pconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7671                                                            + fgkEndCapSupportCenterLay6Position
7672                                                            + ssdcablelay6rightsidelength;
7673   ssdcableslay6pconzsection[1] = ssdcableslay5pconwaterzsection[5];
7674   for(Int_t i=0; i<2;i++) ssdcableslay6pconshape->DefineSection(i,ssdcableslay6pconzsection[i],
7675                                                   ssdcableslay6pconrmin[i],ssdcableslay6pconrmax[i]);
7676   ssdcableslay6pcon = new TGeoVolume("SSDCableLay6RightSidePCon",
7677                                                            ssdcableslay6pconshape,fSSDCopper);
7678   ssdcableslay6pcon->SetLineColor(9);
7679   for(Int_t i=0; i<4; i++){
7680    ssdcablesmother->AddNode(ssdcableslay6pcon,i+1,ssdcableslay5pconrot[i]);
7681    ssdcablesmother->AddNode(ssdcableslay6pcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7682   }
7683   ////////////////////////////////////
7684   //cablescapacity[9] = 8.*ssdcableslay6pconshape->Capacity();
7685   /////////////////////////
7686   // Water Tubes Layer 6
7687   /////////////////////////
7688   TGeoTube* ssdcablelay6righwatertubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax,
7689                                                                                                                   ssdcableslay6rightsideradiusmax
7690                                                                                    +                      fgkSSDCablesLay5RightSideWaterHeight,
7691                                                                                                                   0.5*ssdcablelay6rightsidelength);
7692   TGeoVolume* ssdcablelay6rightwatertube = new TGeoVolume("SSDCableLay6RightSideWaterTube",
7693                                                                                                          ssdcablelay6righwatertubeshape,
7694                                                                                                          fSSDCoolingTubeWater);
7695   ssdcablelay6rightwatertube->SetLineColor(7);
7696   ssdcablesmother->AddNode(ssdcablelay6rightwatertube,1,ssdcablelay6rightrans);
7697   ssdcablesmother->AddNode(ssdcablelay6rightwatertube,2,ssdcablesLay6RightTubeToLeftrans);
7698   TGeoPcon* ssdcableslay6waterpconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7699                                                                                    ssdcableangle,2);
7700   TGeoVolume* ssdcableslay6waterpcon;
7701   Double_t ssdcableslay6waterpconrmin[2];
7702   Double_t ssdcableslay6waterpconrmax[2];
7703   Double_t ssdcableslay6waterpconzsection[2];
7704   ssdcableslay6waterpconrmin[0] = ssdcableslay6rightsideradiusmax;
7705   ssdcableslay6waterpconrmax[0] = ssdcableslay6rightsideradiusmax
7706                                                             + fgkSSDCablesLay5RightSideWaterHeight;
7707   ssdcableslay6waterpconrmin[1] = ssdcableslay6waterpconrmin[0];
7708   ssdcableslay6waterpconrmax[1] = ssdcableslay6waterpconrmax[0];
7709   ssdcableslay6waterpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7710                                                            + fgkEndCapSupportCenterLay6Position
7711                                                            + ssdcablelay6rightsidelength;
7712   ssdcableslay6waterpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7713   for(Int_t i=0; i<2;i++) ssdcableslay6waterpconshape->DefineSection(i,ssdcableslay6waterpconzsection[i],
7714                                                   ssdcableslay6waterpconrmin[i],ssdcableslay6waterpconrmax[i]);
7715   ssdcableslay6waterpcon = new TGeoVolume("SSDCableLay6RightSideWaterPCon",
7716                                                            ssdcableslay6waterpconshape,fSSDCoolingTubeWater);
7717   ssdcableslay6waterpcon->SetLineColor(7);
7718   TGeoRotation* ssdcableslay6pconwaterot[4];
7719   TGeoRotation* ssdcablesLay6RightPConToLeftRot = new TGeoRotation();
7720   ssdcablesLay6RightPConToLeftRot->SetAngles(90.,180.,-90);
7721   TGeoHMatrix* ssdcablesLay6RightPConToLeftMatrix[4];
7722   for(Int_t i=0; i<4; i++){
7723    ssdcableslay6pconwaterot[i] = new TGeoRotation();
7724    ssdcableslay6pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7725    ssdcablesLay6RightPConToLeftMatrix[i] = new TGeoHMatrix((*ssdcablesLay6RightPConToLeftRot)
7726                                                                                  * (*ssdcableslay6pconwaterot[i]));
7727    ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+1,ssdcableslay6pconwaterot[i]);
7728    ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+5,ssdcablesLay6RightPConToLeftMatrix[i]);
7729   }
7730   ////////////////////////////////////////
7731   // From ITS Ring to Patch Panel3-RB26
7732   ////////////////////////////////////////
7733   Double_t ssdcablepatchpanel3BB26radiusmin[2];
7734   Double_t ssdcablepatchpanel3BB26radiusmax[2];
7735   Double_t ssdcablepatchpanel3RB26zsection[2];
7736   ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*fgkSSDPatchPanelHeight+2.8;
7737   ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0]
7738                                                                           + fgkSSDCablesLay5RightSideHeight
7739                                                                           + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
7740   ssdcablepatchpanel3BB26radiusmin[1] = fgkSSDPatchPanel2RB26Radius;
7741   ssdcablepatchpanel3BB26radiusmax[1] = ssdcablepatchpanel3BB26radiusmin[1]
7742                                                                           + 0.*fgkSSDCablesLay5RightSideHeight
7743                                                                           + 0.*fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
7744   ssdcablepatchpanel3RB26zsection[0] = 0.5*fgkSSDCentralSupportLength
7745                                                                                  + fgkSSDCentralAL3SupportLength
7746                                                                                  + fgkSSDPConeZLength[0];
7747   ssdcablepatchpanel3RB26zsection[1] = fgkSSDPatchPanel2RB26ITSDistance;
7748   TGeoPcon* ssdcablepatchpanel3RB26pconshape =
7749                                                                 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
7750                                                                                                 - 0.5*ssdcableangle,ssdcableangle,2);
7751   for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB26pconshape->DefineSection(i,ssdcablepatchpanel3RB26zsection[i],
7752                                                   ssdcablepatchpanel3BB26radiusmin[i],ssdcablepatchpanel3BB26radiusmax[i]);
7753   TGeoVolume* ssdcablepatchpanel3RB26pcon = new TGeoVolume("SSDCablePatchPanel3RB26",
7754                                                                                                 ssdcablepatchpanel3RB26pconshape,fSSDCopper);
7755   ssdcablepatchpanel3RB26pcon->SetLineColor(9);
7756   TGeoRotation* ssdcablepatchpanel3B26rot[3];
7757   for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
7758   ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
7759   ssdcablepatchpanel3B26rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB26Angle[0]
7760                                                                   +                       fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
7761   ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0);
7762   ssdcablepatchpanel3B26rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB26Angle[0]
7763                                                                   +                       fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
7764   for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]);
7765   ////////////////////////////////////
7766   //cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity();
7767   ////////////////////////////////////////
7768   //  ITS Ring Cables RB26 Part
7769   ////////////////////////////////////////
7770   Double_t ssdcableitsring3BB26pconzsection[2];
7771   Double_t ssdcableitsring3BB26pconrmin[2];
7772   Double_t ssdcableitsring3BB26pconrmax[2];
7773   ssdcableitsring3BB26pconzsection[0] = 0.5*fgkSSDCentralSupportLength
7774                                                                           + fgkSSDCentralAL3SupportLength
7775                                                                           + (4.0/5.0)*fgkSSDPConeZLength[0];
7776   ssdcableitsring3BB26pconzsection[1] = ssdcablepatchpanel3RB26zsection[0];
7777   ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
7778   ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0]
7779                                                                   + fgkSSDCablesLay5RightSideHeight
7780                                                                   + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
7781   ssdcableitsring3BB26pconrmin[1] = ssdcablepatchpanel3BB26radiusmin[0];
7782   ssdcableitsring3BB26pconrmax[1] = ssdcablepatchpanel3BB26radiusmax[0];
7783   TGeoPcon* ssdcableitsring3BB26pconshape[4];
7784   ssdcableitsring3BB26pconshape[0] = new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
7785                                                                    -              0.5*ssdcableangle,ssdcableangle
7786                                                                    +                            (fgkSSDCablesPatchPanel2RB26Angle[0]
7787                                                                    -                             fgkSSDCableAngle),2);
7788   ssdcableitsring3BB26pconshape[1] = new TGeoPcon(90.0+fgkSSDCablesPatchPanel2RB26Angle[1]
7789                                                                    -              0.5*ssdcableangle,ssdcableangle
7790                                                                    +                      3.0*fgkSSDCableAngle
7791                                                                    -                      fgkSSDCablesPatchPanel2RB26Angle[1],2);
7792   ssdcableitsring3BB26pconshape[2] = new TGeoPcon(270-fgkSSDCablesPatchPanel2RB26Angle[0]
7793                                                                    -              0.5*ssdcableangle,ssdcableangle
7794                                                                    -                      fgkSSDCableAngle
7795                                                                    +                      fgkSSDCablesPatchPanel2RB26Angle[0],2);
7796   ssdcableitsring3BB26pconshape[3] = new TGeoPcon(270.0+fgkSSDCablesPatchPanel2RB26Angle[1]
7797                                                                    -              0.5*ssdcableangle,ssdcableangle
7798                                                                    +                      3.0*fgkSSDCableAngle
7799                                                                    -                      fgkSSDCablesPatchPanel2RB26Angle[1],2);
7800   for(Int_t i=0;i<4;i++)
7801         for(Int_t j=0; j<2; j++) ssdcableitsring3BB26pconshape[i]->DefineSection(j,ssdcableitsring3BB26pconzsection[j],
7802                                                          ssdcableitsring3BB26pconrmin[j],
7803                                                          ssdcableitsring3BB26pconrmax[j]);
7804   TGeoVolume* ssdcableitsring3BB26pcon[4];
7805   ssdcableitsring3BB26pcon[0] = new TGeoVolume("SSDCableITSRing3RB26Part1",
7806                                                                                                 ssdcableitsring3BB26pconshape[0],fSSDCopper);
7807   ssdcableitsring3BB26pcon[1] = new TGeoVolume("SSDCableITSRing3RB26Part2",
7808                                                                                                 ssdcableitsring3BB26pconshape[1],fSSDCopper);
7809   ssdcableitsring3BB26pcon[2] = new TGeoVolume("SSDCableITSRing3RB26Part3",
7810                                                                                                 ssdcableitsring3BB26pconshape[2],fSSDCopper);
7811   ssdcableitsring3BB26pcon[3] = new TGeoVolume("SSDCableITSRing3RB26Part4",
7812                                                                                                 ssdcableitsring3BB26pconshape[3],fSSDCopper);
7813   for(Int_t i=0;i<4;i++){
7814         ssdcableitsring3BB26pcon[i]->SetLineColor(9);
7815         ssdcablesmother->AddNode(ssdcableitsring3BB26pcon[i],1);
7816 }
7817   ////////////////////////////////////
7818   //cablescapacity[11] = ssdcableitsring3BB26pconshape[0]->Capacity()
7819   //                             + ssdcableitsring3BB26pconshape[1]->Capacity()
7820   //                             + ssdcableitsring3BB26pconshape[2]->Capacity()
7821   //                             + ssdcableitsring3BB26pconshape[3]->Capacity();
7822   ////////////////////////////////////////
7823   // From ITS Ring to Patch Panel2-RB24
7824   ////////////////////////////////////////
7825   Double_t ssdcablepatchpanel3BB24radiusmin[2];
7826   Double_t ssdcablepatchpanel3BB24radiusmax[2];
7827   Double_t ssdcablepatchpanel3RB24zsection[2];
7828   ssdcablepatchpanel3BB24radiusmin[0] = ssdcablepatchpanel3BB26radiusmin[0];
7829   ssdcablepatchpanel3BB24radiusmax[0] = ssdcablepatchpanel3BB26radiusmax[0];
7830   ssdcablepatchpanel3BB24radiusmin[1] = fgkSSDPatchPanel2RB24Radius;
7831   ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1]
7832                                                                           + 0.*fgkSSDCablesLay5RightSideHeight
7833                                                                           + 0.*fgkSSDCablesLay6RightSideHeight
7834                                                                           + 0.5*fgkSSDPatchPanelHeight;
7835   ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength
7836                                                                          -  fgkSSDCentralAL3SupportLength
7837                                                                          -  fgkSSDPConeZLength[0];
7838   ssdcablepatchpanel3RB24zsection[1] = -fgkSSDPatchPanel2RB24ITSDistance;
7839   TGeoPcon* ssdcablepatchpanel3RB24pconshape =
7840                                                                 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
7841                                                                                                 - 0.5*ssdcableangle,ssdcableangle,2);
7842   for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB24pconshape->DefineSection(i,ssdcablepatchpanel3RB24zsection[i],
7843                                                   ssdcablepatchpanel3BB24radiusmin[i],ssdcablepatchpanel3BB24radiusmax[i]);
7844   TGeoVolume* ssdcablepatchpanel3RB24pcon = new TGeoVolume("SSDCablePatchPanel3RB24",
7845                                                                                                 ssdcablepatchpanel3RB24pconshape,
7846                                                                                                 fSSDCopper);
7847   ssdcablepatchpanel3RB24pcon->SetLineColor(9);
7848   TGeoRotation* ssdcablepatchpanel3B24rot[3];
7849   for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation();
7850   ssdcablepatchpanel3B24rot[0]->SetAngles(-6.0,0.0,0.0);
7851   ssdcablepatchpanel3B24rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB24Angle[0]
7852                                                                   +                       fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
7853   ssdcablepatchpanel3B24rot[2]->SetAngles(174.0,0.0,0.0);
7854   ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB24Angle[0]
7855                                                                   +                       fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
7856   for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB24pcon,i+1,ssdcablepatchpanel3B24rot[i]);
7857   ////////////////////////////////////
7858   //cablescapacity[12] = 4.*ssdcablepatchpanel3RB24pconshape->Capacity();
7859   ////////////////////////////////////////
7860   //  ITS Ring Cables RB24 Part
7861   ////////////////////////////////////////
7862   Double_t ssdcableitsring3BB24pconzsection[2];
7863   Double_t ssdcableitsring3BB24pconrmin[2];
7864   Double_t ssdcableitsring3BB24pconrmax[2];
7865   ssdcableitsring3BB24pconzsection[0] = -ssdcableitsring3BB26pconzsection[0];
7866   ssdcableitsring3BB24pconzsection[1] = ssdcablepatchpanel3RB24zsection[0];
7867   ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
7868   ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0]
7869                                                                   + fgkSSDCablesLay5RightSideHeight
7870                                                                   + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
7871   ssdcableitsring3BB24pconrmin[1] = ssdcablepatchpanel3BB24radiusmin[0];
7872   ssdcableitsring3BB24pconrmax[1] = ssdcablepatchpanel3BB24radiusmax[0];
7873   TGeoPcon* ssdcableitsring3BB24pconshape[4];
7874   ssdcableitsring3BB24pconshape[0] = new TGeoPcon(fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7875                                                                    +                            (90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
7876                                                                    -                             fgkSSDCableAngle),2);
7877   ssdcableitsring3BB24pconshape[1] = new TGeoPcon(90.0+fgkSSDCableAngle-0.5*ssdcableangle,
7878                                                                      ssdcableangle-fgkSSDCableAngle
7879                                                                    +                      fgkSSDCablesPatchPanel2RB24Angle[0],2);
7880   ssdcableitsring3BB24pconshape[2] = new TGeoPcon(180.0+fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7881                                                                    -                      fgkSSDCableAngle
7882                                                                    +                      90.0-fgkSSDCablesPatchPanel2RB24Angle[1],2);
7883   ssdcableitsring3BB24pconshape[3] = new TGeoPcon(270.0+fgkSSDCableAngle-0.5*ssdcableangle,
7884                                                                                                   ssdcableangle-fgkSSDCableAngle
7885                                                                    +                      fgkSSDCablesPatchPanel2RB24Angle[0],2);
7886   for(Int_t i=0;i<4;i++)
7887         for(Int_t j=0; j<2; j++) ssdcableitsring3BB24pconshape[i]->DefineSection(j,ssdcableitsring3BB24pconzsection[j],
7888                                                          ssdcableitsring3BB24pconrmin[j],
7889                                                          ssdcableitsring3BB24pconrmax[j]);
7890   TGeoVolume* ssdcableitsring3BB24pcon[4];
7891   ssdcableitsring3BB24pcon[0] = new TGeoVolume("SSDCableITSRing3RB24Part1",
7892                                                                                                 ssdcableitsring3BB24pconshape[0],fSSDCopper);
7893   ssdcableitsring3BB24pcon[1] = new TGeoVolume("SSDCableITSRing3RB24Part2",
7894                                                                                                 ssdcableitsring3BB24pconshape[1],fSSDCopper);
7895   ssdcableitsring3BB24pcon[2] = new TGeoVolume("SSDCableITSRing3RB24Part3",
7896                                                                                                 ssdcableitsring3BB24pconshape[2],fSSDCopper);
7897   ssdcableitsring3BB24pcon[3] = new TGeoVolume("SSDCableITSRing3RB24Part4",
7898                                                                                                 ssdcableitsring3BB24pconshape[3],fSSDCopper);
7899   for(Int_t i=0;i<4;i++){
7900         ssdcableitsring3BB24pcon[i]->SetLineColor(9);
7901         ssdcablesmother->AddNode(ssdcableitsring3BB24pcon[i],1);
7902 }
7903   ////////////////////////////////////
7904   //cablescapacity[13] = ssdcableitsring3BB24pconshape[0]->Capacity()
7905   //                                     + ssdcableitsring3BB24pconshape[1]->Capacity()
7906   //                                     + ssdcableitsring3BB24pconshape[2]->Capacity()
7907   //                                     + ssdcableitsring3BB24pconshape[3]->Capacity();
7908   ////////////////////////////////////
7909   // Volumes for Material Budget
7910   ////////////////////////////////////
7911   TGeoTube* ssdcablelay6materialbudgetubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax
7912                                                                                            +     fgkSSDCablesLay5RightSideWaterHeight,
7913                                                                                                          ssdcableslay6rightsideradiusmax
7914                                                                                            +     fgkSSDCablesLay5RightSideWaterHeight
7915                                                                                            +     fgkSSDCableMaterialBudgetHeight,0.5*ssdcablelay6rightsidelength);
7916   TGeoVolume* ssdcablelay6materialbudgetube = new TGeoVolume("SSDCableLay6MaterialBudgetTube",
7917                                                                                                          ssdcablelay6materialbudgetubeshape,
7918                                                                                                          fSSDCopper);
7919   ssdcablelay6materialbudgetube->SetLineColor(9);
7920   ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,1,ssdcablelay6rightrans);
7921   ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,2,ssdcablesLay6RightTubeToLeftrans);
7922
7923   TGeoPcon* ssdcablelay6materialbudgetpconshape =
7924                                         new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle,2);
7925   TGeoVolume* ssdcablelay6materialbudgetpcon;
7926   Double_t ssdcablelay6materialbudgetpconrmin[2];
7927   Double_t ssdcablelay6materialbudgetpconrmax[2];
7928   Double_t ssdcablelay6materialbudgetpconzsection[2];
7929   ssdcablelay6materialbudgetpconrmin[0] = ssdcableslay6rightsideradiusmax
7930                                                                                 + fgkSSDCablesLay5RightSideWaterHeight;
7931   ssdcablelay6materialbudgetpconrmax[0] = ssdcablelay6materialbudgetpconrmin[0]
7932                                                                                 + fgkSSDCableMaterialBudgetHeight;
7933   ssdcablelay6materialbudgetpconrmin[1] = ssdcablelay6materialbudgetpconrmin[0];
7934   ssdcablelay6materialbudgetpconrmax[1] = ssdcablelay6materialbudgetpconrmax[0];
7935   ssdcablelay6materialbudgetpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7936                                                                                         + fgkEndCapSupportCenterLay6Position
7937                                                                                         + ssdcablelay6rightsidelength;
7938   ssdcablelay6materialbudgetpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7939   for(Int_t i=0; i<2;i++) ssdcablelay6materialbudgetpconshape->DefineSection(i,
7940                                                   ssdcablelay6materialbudgetpconzsection[i],
7941                                                   ssdcablelay6materialbudgetpconrmin[i],
7942                                                   ssdcablelay6materialbudgetpconrmax[i]);
7943   ssdcablelay6materialbudgetpcon = new TGeoVolume("SSDCableLay6MaterialBudgetPCon",
7944                                                            ssdcablelay6materialbudgetpconshape,fSSDCopper);
7945   ssdcablelay6materialbudgetpcon->SetLineColor(9);
7946   for(Int_t i=0; i<4; i++){
7947    ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+1,ssdcableslay5pconrot[i]);
7948    ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7949   }
7950 ////////////////////////////////////
7951  /* cablescapacity[14] = 2.*ssdcablelay6materialbudgetubeshape->Capacity();
7952   cablescapacity[15] = 2.*ssdcablelay6materialbudgetpconshape->Capacity();
7953   Double_t ssdcablesvolume = 0.0;
7954   for(Int_t i=0;i<16;i++) ssdcablesvolume+=cablescapacity[i];
7955   std::cout << ssdcablesvolume << std::endl;*/
7956   return ssdcablesmother;
7957  }
7958  ////////////////////////////////////////////////////////////////////////////////
7959 TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
7960                                             Double_t height, const char* shapename, Int_t isign) const{
7961   /////////////////////////////////////////////////////////////
7962   // Method generating an Arb shape
7963   /////////////////////////////////////////////////////////////
7964   const Int_t kvertexnumber = 8;
7965   const Int_t ktransvectnumber = 2;
7966   TVector3 vertex[kvertexnumber];
7967   TVector3 transvector[2];
7968   for(Int_t i=0; i<ktransvectnumber; i++) transvector[i].SetY(width[i]);
7969   /////////////////////////////////////////////////////////////
7970   //Setting the vertices for TGeoArb8
7971   /////////////////////////////////////////////////////////////
7972   vertex[0] = *vertexpos[0];
7973   vertex[1] = *vertexpos[1];
7974   vertex[2] = vertex[1];
7975   vertex[3] = vertex[0];
7976   vertex[4] = *vertexpos[2];
7977   vertex[5] = *vertexpos[3];
7978   vertex[6] = vertex[5];
7979   vertex[7] = vertex[4];
7980
7981   // NB: order of points is clockwise
7982   if (isign < 0) {
7983     vertex[2] -= transvector[0];
7984     vertex[3] -= transvector[0];
7985     vertex[6] -= transvector[1];
7986     vertex[7] -= transvector[1];
7987   }
7988   else {
7989     vertex[0] += transvector[0];
7990     vertex[1] += transvector[0];
7991     vertex[4] += transvector[1];
7992     vertex[5] += transvector[1];
7993   }
7994
7995   /////////////////////////////////////////////////////////////
7996   TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
7997   for(Int_t i = 0; i<kvertexnumber;i++) {
7998     arbshape->SetVertex(i,vertex[i].X(),vertex[i].Y());
7999   }
8000
8001   return arbshape;
8002 }
8003 ///////////////////////////////////////////////////////////////////////////////
8004 TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
8005                                                                 Double_t rmax, Int_t nedges, Double_t height){
8006   /////////////////////////////////////////////////////////////
8007   // Method generating Arc shape
8008   /////////////////////////////////////////////////////////////
8009         const Int_t kvertexnumber = 2*nedges+2;
8010         TGeoXtru* arcshape = new TGeoXtru(2);
8011         TVector3** vertexposition[2];
8012         for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
8013         Double_t angle = 0.;
8014     for(Int_t i=0; i<nedges+1; i++){
8015                 angle = 90.+0.5*phi-i*(phi/nedges);
8016                 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
8017                 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
8018         }
8019         Double_t *xvertexpoints = new Double_t[kvertexnumber];
8020         Double_t *yvertexpoints = new Double_t[kvertexnumber];
8021         for(Int_t i=0; i<kvertexnumber; i++){
8022                 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
8023                                   yvertexpoints[i] = vertexposition[0][i]->Y();
8024                 }
8025                 else if(i>=1&&i<nedges+2)
8026                 {
8027                         xvertexpoints[i] = vertexposition[1][i-1]->X();
8028                         yvertexpoints[i] = vertexposition[1][i-1]->Y();
8029                 }
8030         else
8031                 {
8032                         xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
8033                         yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
8034                 }
8035     }
8036   arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
8037   arcshape->DefineSection(0,-0.5*height);
8038   arcshape->DefineSection(1,0.5*height);
8039   /////////////////////////////////////////////////////////////
8040   // Deallocating memory
8041   /////////////////////////////////////////////////////////////
8042   for(Int_t i=0; i<2; i++){
8043         for(Int_t j=0; j<nedges+1; j++)
8044                 delete vertexposition[i][j];
8045         delete [] vertexposition[i];
8046   }
8047   delete [] xvertexpoints;
8048   delete [] yvertexpoints;
8049   /////////////////////////////////////////////////////////////
8050         return arcshape;
8051 }
8052 ////////////////////////////////////////////////////////////////////////////////
8053 TGeoShape* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
8054   ///////////////////////////////////////////////////////////////////////
8055   // Method Generating the Screw Shape
8056   // radius[0]: outer radius
8057   // radius[1]: inner radius
8058   // edgesnumber[0]: outer number of edges
8059   // edgesnumber[1]: inner number of edges
8060   // section[0]: lower section position
8061   // section[1]: higher section position
8062   ///////////////////////////////////////////////////////////////////////
8063   Double_t outradius = radius[0];
8064   Double_t inradius = radius[1];
8065   Int_t outvertexnumber = edgesnumber[0];
8066   Int_t invertexnumber = edgesnumber[1];
8067   Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8068   Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8069   for(Int_t i=0; i<outvertexnumber; i++){
8070         xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
8071         yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
8072   }
8073   for(Int_t i=0; i<invertexnumber; i++){
8074         xscrewvertex[outvertexnumber+i] = inradius*CosD(90.+i*360./invertexnumber);
8075         yscrewvertex[outvertexnumber+i] = inradius*SinD(90.+i*360./invertexnumber);
8076   }
8077   TGeoXtru* screwshapeout = new TGeoXtru(2);
8078   screwshapeout->DefinePolygon(outvertexnumber,xscrewvertex,yscrewvertex);
8079   screwshapeout->DefineSection(0,section[0]);
8080   screwshapeout->DefineSection(1,section[1]);
8081   TGeoXtru* screwshapein = new TGeoXtru(2);
8082   screwshapein->DefinePolygon(invertexnumber,&xscrewvertex[outvertexnumber],&yscrewvertex[outvertexnumber]);
8083   screwshapein->DefineSection(0,section[0]-0.01); // make inner part bigger in Z
8084   screwshapein->DefineSection(1,section[1]+0.01); // safer when we subtract it
8085   TGeoSubtraction *snode = new TGeoSubtraction(screwshapeout, screwshapein);
8086   TGeoCompositeShape *screwshape = new TGeoCompositeShape("", snode);
8087
8088   delete [] xscrewvertex;
8089   delete [] yscrewvertex;
8090   return screwshape;
8091 }
8092 ////////////////////////////////////////////////////////////////////////////////
8093 TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
8094   ///////////////////////////////////////////////////////////////////////
8095   // Method Generating the Hole Shape
8096   // radius of the Hole
8097   // nedges: number of edges to approximate the circle
8098   ///////////////////////////////////////////////////////////////////////
8099   Double_t* xholevertex = new Double_t[nedges];
8100   Double_t* yholevertex = new Double_t[nedges];
8101   Double_t z  = 0.5*(section[0]+section[1]);
8102   Double_t dz = 0.5*(section[1]-section[0]);
8103   TGeoTranslation *tr = 0;
8104   if (TMath::Abs(z) > TGeoShape::Tolerance()) {
8105      tr = new TGeoTranslation(0.,0.,z);
8106      tr->RegisterYourself();
8107   }
8108   TGeoBBox *box = new TGeoBBox("",radius,radius,dz);
8109   for(Int_t i=0; i<nedges; i++){
8110         xholevertex[i] = radius*CosD(i*360./nedges);
8111         yholevertex[i] = radius*SinD(i*360./nedges);
8112   }
8113   TGeoXtru* holeshapeout = new TGeoXtru(2);
8114   holeshapeout->DefinePolygon(nedges,xholevertex,yholevertex);
8115   holeshapeout->DefineSection(0,section[0]-0.01); // make subtracted part larger in Z
8116   holeshapeout->DefineSection(1,section[1]+0.01);
8117   TGeoSubtraction *snode = new TGeoSubtraction(box,holeshapeout,tr);
8118   TGeoCompositeShape *holeshape = new TGeoCompositeShape("", snode);
8119
8120   delete [] xholevertex;
8121   delete [] yholevertex;
8122   return holeshape;
8123 }
8124 ////////////////////////////////////////////////////////////////////////////////
8125 TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
8126   /////////////////////////////////////////////////////////////
8127   // Given an axis specified by param, it gives the reflection of the point
8128   // respect to the axis
8129   /////////////////////////////////////////////////////////////
8130   TVector3* n = new TVector3(param[0],param[1],param[2]);
8131   Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
8132   TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
8133   /////////////////////////////////////////////////////////////
8134   // Deallocating memory
8135   /////////////////////////////////////////////////////////////
8136   delete n;
8137   /////////////////////////////////////////////////////////////
8138   return reflectedvector;
8139 }
8140 ////////////////////////////////////////////////////////////////////////////////
8141 TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct,
8142                                                        Double_t dx,
8143                                                        Double_t dy,
8144                                                        Double_t dz) const{
8145   /////////////////////////////////////////////////////////////
8146   // Add a dx,dy,dz translation to the initial TGeoCombiTrans
8147   /////////////////////////////////////////////////////////////
8148   TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
8149   const Double_t *vect = hmatrix->GetTranslation();
8150   Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
8151   hmatrix->SetTranslation(newvect);
8152   TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
8153   delete hmatrix;
8154   return matrix;
8155 }
8156 ////////////////////////////////////////////////////////////////////////////////
8157 TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
8158   /////////////////////////////////////////////////////////////
8159   // Method returning the Medium type
8160   /////////////////////////////////////////////////////////////
8161   char ch[100];
8162   sprintf(ch, "ITS_%s",mediumName);
8163   TGeoMedium* medium =  gGeoManager->GetMedium(ch);
8164   if (! medium)
8165     AliError(Form("medium %s not found !\n", mediumName));
8166   return medium;
8167 }
8168 ////////////////////////////////////////////////////////////////////////////////
8169 void AliITSv11GeometrySSD::CreateMaterials(){
8170 ///////////////////////////////////
8171 // This part has to be modified
8172 ///////////////////////////////////
8173   ///////////////////////////////////
8174   // Silicon for Sensor
8175   ///////////////////////////////////
8176   fSSDSensorMedium = GetMedium("SI$");
8177   ///////////////////////////////////
8178   // Silicon Mixture for Sensor
8179   ///////////////////////////////////
8180   fSSDChipMedium = GetMedium("SPD SI CHIP$");
8181   fSSDChipGlueMedium = GetMedium("EPOXY$");
8182   ///////////////////////////////////
8183   // Stiffener Components Materials
8184   ///////////////////////////////////
8185   fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
8186   ///////////////////////////
8187   // Stiffener Connectors
8188   ///////////////////////////
8189   fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
8190   ////////////////////////////////
8191   // Stiffener 0603-1812 Capacitor
8192   ////////////////////////////////
8193   fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8194   fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8195   fSSDStiffenerCapacitorCapMedium = GetMedium("NiSn$");
8196   ///////////////////////////
8197   // Stiffener Hybrid Wire
8198   ///////////////////////////
8199   fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
8200   ///////////////////////////
8201   // Al for Cooling Block
8202   ///////////////////////////
8203   fSSDAlCoolBlockMedium = GetMedium("AL$");
8204   //////////////////////////////////////////////////////
8205   // Kapton and Al for Chip Cable Flex and Ladder Cables
8206   //////////////////////////////////////////////////////
8207   fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8208   fSSDAlTraceChipCableMedium = GetMedium("AL$");
8209   fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
8210   fSSDAlTraceFlexMedium = GetMedium("AL$");
8211   fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8212   fSSDAlTraceLadderCableMedium = GetMedium("AL$");
8213   /////////////////////////////////////////////////////////////////
8214   // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
8215   //////////////////////////////////////////////////////////////////
8216   fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
8217   /////////////////////////////////////////////////////////////////
8218   // G10 for Detector Leg, TubeHolder
8219   //////////////////////////////////////////////////////////////////
8220   fSSDTubeHolderMedium = GetMedium("G10FR4$");
8221   fSSDSensorSupportMedium = GetMedium("G10FR4$");
8222   fSSDMountingBlockMedium = GetMedium("G10FR4$");
8223   fSSDMountingBlockMedium = GetMedium("G10FR4$");
8224   /////////////////////////////////////////////////////////////////
8225   // Water and Phynox for Cooling Tube
8226   //////////////////////////////////////////////////////////////////
8227   fSSDCoolingTubeWater = GetMedium("WATER$");
8228   fSSDCoolingTubePhynox = GetMedium("INOX$");
8229   /////////////////////////////////////////////////////////////////////
8230   // Material for Support Rings
8231   /////////////////////////////////////////////////////////////////////
8232   fSSDSupportRingAl = GetMedium("AL$");
8233   fSSDRohaCellCone = GetMedium("ROHACELL$");
8234   /////////////////////////////////////////////////////////////////////
8235   fSSDAir = GetMedium("SDD AIR$");
8236   fSSDCopper = GetMedium("COPPER$");
8237   fSSDSn = GetMedium("Sn$");
8238   fCreateMaterials = kTRUE;
8239 }
8240 /////////////////////////////////////////////////////////////////////