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::fgkSSDsensitiveVolName5 = "ITSssdSensitivL5";
  46 const char* AliITSv11GeometrySSD::fgkSSDsensitiveVolName6 = "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 = 624.9*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 /////////////////////////////////////////////////////////////////////////////////
 528 ClassImp(AliITSv11GeometrySSD)
 529 /////////////////////////////////////////////////////////////////////////////////
 530 AliITSv11GeometrySSD::AliITSv11GeometrySSD():
 531   AliITSv11Geometry(),
 532   fSSDChipMedium(),
 533   fSSDChipGlueMedium(),
 534   fSSDStiffenerMedium(),
 535   fSSDStiffenerConnectorMedium(),
 536   fSSDStiffener0603CapacitorMedium(),
 537   fSSDStiffener1812CapacitorMedium(),
 538   fSSDStiffenerCapacitorCapMedium(),
 539   fSSDStiffenerHybridWireMedium(),
 540   fSSDKaptonFlexMedium(),
 541   fSSDAlTraceFlexMedium(),
 542   fSSDAlTraceLadderCableMedium(),
 543   fSSDKaptonLadderCableMedium(),
 544   fSSDKaptonChipCableMedium(),
 545   fSSDAlTraceChipCableMedium(),
 546   fSSDAlCoolBlockMedium(),
 547   fSSDSensorMedium(),
 548   fSSDSensorSupportMedium(),
 549   fSSDCarbonFiberMedium(),
 550   fSSDTubeHolderMedium(),
 551   fSSDCoolingTubeWater(),
 552   fSSDCoolingTubePhynox(),
 553   fSSDSupportRingAl(),
 554   fSSDMountingBlockMedium(),
 555   fSSDRohaCellCone(),
 556   fSSDAir(),
 557   fSSDCopper(),
 558   fSSDSn(),
 559   fCreateMaterials(kFALSE),
 560   fTransformationMatrices(kFALSE),
 561   fBasicObjects(kFALSE),
 562   fcarbonfiberjunction(),
 563   fcoolingtubesupport(),
 564   fhybridmatrix(),
 565   fssdcoolingblocksystem(),
 566   fcoolingblocksystematrix(),
 567   fssdstiffenerflex(),
 568   fssdendflex(),
 569   fcoolingtube(0),
 570   fendladdercoolingtubesupportmatrix(),
 571   fendladdermountingblock(),
 572   fendladdermountingblockclip(),
 573   fSSDSensor5(),
 574   fSSDSensor6(),
 575   fSSDLayer5(),
 576   fSSDLayer6(),
 577   fMotherVol(),
 578   fLay5LadderSupportRing(),
 579   fLay6LadderSupportRing(),
 580   fgkEndCapSupportSystem(),
 581   fSSDCone(),
 582   fColorCarbonFiber(4),
 583   fColorRyton(5),
 584   fColorPhynox(14),
 585   fColorSilicon(3),
 586   fColorAl(38),
 587   fColorNiSn(40),
 588   fColorKapton(6),
 589   fColorPolyhamide(5),
 590   fColorStiffener(9),
 591   fColorEpoxy(30),
 592   fColorWater(7),
 593   fColorG10(41)
 594 {
 595   ////////////////////////
 596   // Standard constructor
 597   ////////////////////////
 598   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++){
 599     fendladdermountingblockcombitrans[i] = NULL;
 600   }
 601   for (Int_t i=0; i < fgkcarbonfibersupportnumber; i++) {
 602     fcarbonfibersupport[i] = 0;
 603     fcarbonfibersupportmatrix[i] = 0;
 604   }
 605   for (Int_t i=0; i < fgkcarbonfiberjunctionumber; i++) {
 606     fcarbonfiberjunctionmatrix[i] = 0;
 607   }
 608   for (Int_t i=0; i < fgkcarbonfiberlowersupportnumber; i++) {
 609     fcarbonfiberlowersupport[i] = 0;
 610     fcarbonfiberlowersupportrans[0] = 0;
 611   }
 612   for (Int_t i=0; i < fgkvolumekind; i++) {
 613     fssdsensorsupport[i] = 0;
 614   }
 615   for (Int_t i=0; i < fgkssdsensorsupportnumber; i++) {
 616     fssdsensorsupportmatrix[i] = 0;
 617   }
 618   for (Int_t i=0; i < fgkcoolingtubesupportnumber; i++) {
 619     fcoolingtubesupportmatrix[i] = 0;
 620   }
 621   for (Int_t i=0; i < fgkhybridcompnumber; i++) {
 622     fssdhybridcomponent[i] = 0;
 623   }
 624   for (Int_t i=0; i < fgkcoolingblocknumber; i++) {
 625     fcoolingblockmatrix[i] = 0;
 626   }
 627   for (Int_t i=0; i < fgkflexnumber; i++) {
 628     fstiffenerflexmatrix[i] = 0;
 629     fendflexmatrix[i] = 0;
 630   }
 631   for (Int_t i=0; i < fgkendladdercoolingtubenumber; i++) {
 632     fendladdercoolingtube[i] = 0;
 633     for (Int_t j = 0; j < 2; j++)
 634       fendladdercoolingtubematrix[i][j] = 0;
 635   }
 636   for (Int_t i=0; i < fgkendlabbercarbonfiberjunctionumber; i++) {
 637     fendladdercarbonfiberjunction[i] = 0;
 638   }
 639   for (Int_t i=0; i < fgkendladdercarbonfiberjunctionmatrixnumber; i++) {
 640     fendladdercarbonfiberjunctionmatrix[i] = 0;
 641   }
 642   for (Int_t i=0; i < fgkendladdercarbonfibermatrixnumber; i++) {
 643     fendladdercarbonfibermatrix[i] = 0;
 644   }
 645   for (Int_t i=0; i < fgkendladdermountingblocknumber; i++) {
 646     fendladdermountingblockclipmatrix[i] = 0;
 647   }
 648   for (Int_t i = 0; i < fgkendladderlowersuppnumber+1; i++) {
 649     fendladderlowersupptrans[i] = 0;
 650   }
 651   for (Int_t i = 0; i < fgkladdercablesnumber; i++) {
 652     fladdercablematrix[i] = 0;
 653   }
 654   for (Int_t i = 0; i < fgkladdersegmentnumber; i++) {
 655     fladdersegment[i] = 0;
 656   }
 657   for (Int_t i = 0; i < fgkladdernumber; i++) {
 658     fladder[i] = 0;
 659     fladdermatrix[i] = 0;
 660     fssdsensormatrix[i] = 0;
 661     flayermatrix[i] = 0;
 662   }
 663   for (Int_t i = 0; i < 2; i++) {
 664     fLay5LadderSupport[i] = 0;
 665     fLay6LadderSupport[i] = 0;
 666     fcoolingtubematrix[i] = NULL;
 667     fendladdersegment[i] = NULL;
 668     fendladdersegmentmatrix[i] = NULL;
 669   }
 670 }
 671
 672 ///////////////////////////////////////////////////////////////////////////////
 673 void AliITSv11GeometrySSD::CreateTransformationMatrices(){
 674   ///////////////////////////////////////////////////////////////////////
 675   // Method generating the trasformation matrix for the whole SSD Geometry
 676   ///////////////////////////////////////////////////////////////////////
 677   // Setting some variables for Carbon Fiber Supportmatrix creation
 678   //////////////////////////////////////////////////////////////////////
 679   Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
 680                                                                                    * CosD(fgkCarbonFiberJunctionAngle[0]);
 681   Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
 682                                                                  +      fgkCarbonFiberSupportTopEdgeDist[0]
 683                                                                  +      fgkCarbonFiberSupportWidth);
 684   Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
 685                                                                         * TanD(fgkCarbonFiberJunctionAngle[0]);
 686   TGeoRotation* carbonfiberot[3];
 687   for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
 688   carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
 689   carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
 690   carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
 691   Double_t transvector[3] = {fgkCarbonFiberTriangleLength
 692                                                   *  CosD(fgkCarbonFiberTriangleAngle),0.,
 693                                                   -  fgkCarbonFiberTriangleLength
 694                                                   *      SinD(fgkCarbonFiberTriangleAngle)};
 695   ///////////////////////////////////////////
 696   //Setting Local Translations and Rotations:
 697   ///////////////////////////////////////////
 698   TGeoCombiTrans* localcarbonfibersupportmatrix[3];
 699   localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
 700                                                                          0.5*carbonfibersupportheight,NULL);
 701   localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
 702                                                                          2.*symmetryplaneposition+transvector[1],
 703                                                                          transvector[2], carbonfiberot[2]);
 704   localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
 705   /////////////////////////////////////////////////////////////
 706   // Carbon Fiber Support Transformations
 707   /////////////////////////////////////////////////////////////
 708   const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
 709   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
 710                 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
 711                 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
 712                         fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
 713   }
 714   /////////////////////////////////////////////////////////////
 715   // Carbon Fiber Junction Transformation
 716   /////////////////////////////////////////////////////////////
 717   const Int_t kcarbonfiberjunctionmatrixnumber = 2;
 718   TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
 719   TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
 720   TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
 721   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
 722         localcarbonfiberjunctionmatrix[i] =
 723                                                 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
 724         localcarbonfiberjunctionrot[i] =
 725                                                 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
 726         localcarbonfiberjunctiontrans[i] =
 727                                                 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
 728   }
 729   ///////////////////////
 730   // Setting Translations
 731   ///////////////////////
 732   localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
 733   localcarbonfiberjunctiontrans[1][0] =
 734                                  new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
 735   localcarbonfiberjunctiontrans[2][0] =
 736                                  new TGeoTranslation(fgkCarbonFiberTriangleLength
 737                                  * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
 738                                  fgkCarbonFiberTriangleLength
 739                                  * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
 740   localcarbonfiberjunctiontrans[0][1] =
 741                                  new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
 742   localcarbonfiberjunctiontrans[1][1] =
 743                                  new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
 744   localcarbonfiberjunctiontrans[2][1] =
 745                                  new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
 746   ////////////////////
 747   // Setting Rotations
 748   ////////////////////
 749   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
 750                 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
 751                         localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
 752   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
 753         localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
 754   localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
 755   localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
 756   localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
 757   ////////////////////////////////////////
 758   // Setting Carbon Fiber Junction matrix
 759   ////////////////////////////////////////
 760   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
 761                 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
 762                 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
 763                         localcarbonfiberjunctionmatrix[i][j] =
 764                         new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
 765                                                            *localcarbonfiberjunctionrot[i][j]);
 766                     fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
 767          }
 768   }
 769   /////////////////////////////////////////////////////////////
 770   // Carbon Fiber Lower Support Transformations
 771   /////////////////////////////////////////////////////////////
 772   TGeoTranslation* localcarbonfiberlowersupportrans[2];
 773   localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
 774                                                                          fgkCarbonFiberLowerSupportVolumePosition[1]
 775                                                                 +    fgkCarbonFiberLowerSupportVolumePosition[0],
 776                                                                          0.0);
 777   localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
 778                                                                          fgkCarbonFiberJunctionWidth
 779                                                                 -    fgkCarbonFiberLowerSupportWidth
 780                                                                 -    fgkCarbonFiberLowerSupportVolumePosition[0]
 781                                                                 -    fgkCarbonFiberLowerSupportVolumePosition[1],
 782                                                                 -    0.5*fgkCarbonFiberLowerSupportHeight);
 783    localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
 784    fcarbonfiberlowersupportrans[0] =
 785                                                 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
 786    fcarbonfiberlowersupportrans[1] =
 787                                                 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
 788   /////////////////////////////////////////////////////////////
 789   // SSD Sensor Support Transformations
 790   /////////////////////////////////////////////////////////////
 791   const Int_t kssdsensorsupportmatrixnumber = 3;
 792   TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
 793   TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
 794   TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
 795   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 796         localssdsensorsupportmatrix[i] =
 797                                                 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
 798         localssdsensorsupportrot[i] =
 799                                                 new TGeoRotation*[kssdsensorsupportmatrixnumber];
 800         localssdsensorsupportrans[i] =
 801                                                 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
 802   }
 803   ///////////////////////
 804   // Setting Translations
 805   ///////////////////////
 806   localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
 807                                                                           0.5*fgkSSDSensorSideSupportWidth,
 808                                                                           0.0);
 809   localssdsensorsupportrans[1][0] =
 810                                                  new TGeoTranslation(*localssdsensorsupportrans[0][0]);
 811   localssdsensorsupportrans[2][0] =
 812                                                  new TGeoTranslation(*localssdsensorsupportrans[0][0]);
 813   localssdsensorsupportrans[0][1] =
 814                                                  new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
 815                                                                                 0.5*fgkSSDSensorSideSupportThickness[0],
 816                                                                                 0.0);
 817   localssdsensorsupportrans[1][1] =
 818                                                  new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
 819                                                                         -   0.5*fgkSSDSensorSideSupportThickness[0]
 820                                                                     -   fgkSSDModuleSensorSupportDistance,
 821                                                                                 0.0);
 822   localssdsensorsupportrans[2][1] =
 823                                                  new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
 824                                                                         -    fgkSSDSensorCenterSupportPosition,
 825                                                                                  0.5*fgkSSDSensorCenterSupportWidth
 826                                                                         -    0.5*fgkSSDModuleSensorSupportDistance,
 827                                                                                  fgkSSDSensorCenterSupportThickness[0]);
 828   localssdsensorsupportrans[0][2] =
 829                                                  new TGeoTranslation(fgkCarbonFiberTriangleLength
 830                                                                         +    fgkCarbonFiberJunctionToSensorSupport,
 831                                                                                  fgkCarbonFiberJunctionWidth
 832                                                                     -    0.5*(fgkCarbonFiberLowerSupportWidth
 833                                                                         +    fgkSSDSensorCenterSupportLength
 834                                                                         -    fgkSSDSensorCenterSupportThickness[0])
 835                                                                         -    fgkSSDSensorCenterSupportPosition,
 836                                                                              0.0);
 837   localssdsensorsupportrans[1][2] =
 838                                                 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
 839   localssdsensorsupportrans[2][2] =
 840                                                 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
 841   ////////////////////
 842   // Setting Rotations
 843   ////////////////////
 844   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
 845                 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
 846                         localssdsensorsupportrot[i][j] = new TGeoRotation();
 847   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 848         localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
 849         localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
 850   }
 851   localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
 852   localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
 853   localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
 854   ////////////////////////////////////////
 855   // SSD Sensor Support matrix
 856   ////////////////////////////////////////
 857   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 858                 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
 859                 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
 860                         localssdsensorsupportmatrix[i][j] =
 861                         new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
 862                                                            *localssdsensorsupportrot[i][j]);
 863                     fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
 864          }
 865   }
 866   /////////////////////////////////////////////////////////////
 867   // SSD Cooling Tube Support Transformations
 868   /////////////////////////////////////////////////////////////
 869   const Int_t kcoolingtubesupportmatrixnumber = 2;
 870   TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
 871   TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
 872   TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
 873   Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
 874                                                                                                         /fgkCoolingTubeSupportRmax);
 875   localcoolingtubesupportrans[0] =
 876                         new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
 877                                                 +  2.*(fgkCoolingTubeSupportLength
 878                                                 -  fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
 879                                                 +  fgkCarbonFiberTriangleLength
 880                                                 -  2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
 881   localcoolingtubesupportrans[1] =
 882                         new TGeoTranslation(fgkCarbonFiberJunctionLength
 883                                         - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
 884                                         - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 885                                                    fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 886                     +  0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 887                     -  0.5*(fgkCarbonFiberLowerSupportWidth
 888                                         +          fgkSSDSensorCenterSupportLength
 889                     -      fgkSSDSensorCenterSupportThickness[0])
 890                                         +  0.5*fgkSSDSensorLength,
 891                                         -  0.5*fgkCoolingTubeSupportHeight);
 892   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
 893   localcoolingtubesupportrot[i] = new TGeoRotation();
 894   localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
 895   localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
 896   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
 897         localcoolingtubesupportmatrix[i] =
 898                 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
 899                                                    *localcoolingtubesupportrot[i]);
 900   fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
 901   fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
 902                                                                 (*localcoolingtubesupportmatrix[0]));
 903   /////////////////////////////////////////////////////////////
 904   // End Ladder SSD Cooling Tube Support Transformations
 905   /////////////////////////////////////////////////////////////
 906   TGeoTranslation** localendladdercooltubetrans[2];
 907   localendladdercooltubetrans[0] = new TGeoTranslation*[4];
 908   localendladdercooltubetrans[1] = new TGeoTranslation*[2];
 909   for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
 910   localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
 911                                                                                         -          (fgkCoolingTubeSupportLength
 912                                                                                         -               fgkCoolingTubeSupportRmax),
 913                                                                                                         fgkEndLadderMountingBlockPosition[0]
 914                                                                                         -               fgkendladdercoolingsupportdistance[0]
 915                                                                                         +   0.5*fgkCoolingTubeSupportWidth,
 916                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 917   localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
 918                                                                                         -          (fgkCoolingTubeSupportLength
 919                                                                                         -               fgkCoolingTubeSupportRmax),
 920                                                                                                         fgkEndLadderMountingBlockPosition[0]
 921                                                                                         +               fgkendladdercoolingsupportdistance[1]
 922                                                                                         +   0.5*fgkCoolingTubeSupportWidth,
 923                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 924   localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
 925                                                                                         -       fgkCoolingTubeSupportRmax)
 926                                                                                         +               fgkCarbonFiberTriangleLength
 927                                                                                         -   2.0*fgkCarbonFiberJunctionLength,
 928                                                                                                 0.0,
 929                                                                                                 0.0);
 930   localendladdercooltubetrans[0][3]->SetTranslation(0.0,
 931                                                                                                         fgkendladdercoolingsupportdistance[0]
 932                                                                                         +               fgkendladdercoolingsupportdistance[1],
 933                                                                                                         0.0);
 934   for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
 935   localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
 936                                                                                         +               fgkCarbonFiberJunctionLength
 937                                                                                         -               fgkCoolingTubeSupportLength,
 938                                                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[1]
 939                                                                                         -       0.5*fgkCoolingTubeSupportWidth
 940                                                                                                    -fgkendladdercoolingsupportdistance[2],
 941                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 942   localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
 943                                                                                         +               fgkCoolingTubeSupportLength
 944                                                                                         -               fgkCoolingTubeSupportRmax
 945                                                                                         -               fgkCarbonFiberJunctionLength,
 946                                                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[1]
 947                                                                                         -       0.5*fgkCoolingTubeSupportWidth
 948                                                                                         -               fgkendladdercoolingsupportdistance[2],
 949                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 950   fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
 951   fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
 952   fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
 953   fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
 954   (*localcoolingtubesupportrot[1]));
 955   fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
 956   (*localcoolingtubesupportrot[1]));
 957   fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
 958   fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
 959   fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
 960   fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
 961   fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
 962
 963   fendladdercoolingtubesupportmatrix[1][0] =
 964                                                         new TGeoHMatrix((*localendladdercooltubetrans[1][0])
 965                                                                                    *(*localcoolingtubesupportrot[1]));
 966   fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
 967   fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
 968   fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
 969   /////////////////////////////////////////////////////////////
 970   // SSD Cooling Tube Transformations
 971   /////////////////////////////////////////////////////////////
 972   TGeoRotation* localcoolingtuberot = new TGeoRotation();
 973   localcoolingtuberot->SetAngles(0.,90.,0.);
 974   TGeoTranslation* localcoolingtubetrans[2];
 975   TVector3* localcoolingtubevect[2];
 976
 977   localcoolingtubevect[0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
 978                                                   -fgkCarbonFiberTriangleLength),
 979                                             fgkCarbonFiberJunctionWidth         // Y-coord is local Z, from sensor translation
 980                                             - fgkCarbonFiberLowerSupportWidth
 981                                             - fgkLowerSupportToSensorZ ,
 982                                                   -  0.5*fgkCoolingTubeSupportHeight);
 983   localcoolingtubevect[1] = new TVector3( -localcoolingtubevect[0]->X()+fgkCarbonFiberTriangleLength,
 984                                               localcoolingtubevect[0]->Y(),
 985                                               localcoolingtubevect[0]->Z());
 986   for(Int_t j=0; j<2; j++){
 987     localcoolingtubetrans[j] =
 988         new TGeoTranslation(localcoolingtubevect[j]->X(),
 989                             localcoolingtubevect[j]->Y(),
 990                             localcoolingtubevect[j]->Z());
 991      fcoolingtubematrix[j] = new TGeoHMatrix((*localcoolingtubetrans[j])
 992                                              *(*localcoolingtuberot));
 993   }
 994   /////////////////////////////////////////////////////////////
 995   // SSD End Ladder Cooling Tube Transformations
 996   /////////////////////////////////////////////////////////////
 997   TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
 998   localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
 999   TGeoTranslation** localendlladdercoolingtubetrans[2];
1000   localendlladdercoolingtubetrans[0] = new TGeoTranslation*[2];
1001   localendlladdercoolingtubetrans[1] = new TGeoTranslation*[2];
1002   for(Int_t i=0; i<2; i++)
1003         for(Int_t j=0; j<2; j++)
1004                 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
1005
1006   Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
1007   localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1008                                                                         -        fgkCoolingTubeSupportRmax)
1009                                                                         +        fgkCarbonFiberJunctionLength,
1010                                                         0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
1011                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1012   localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1013                                                                         -        fgkCoolingTubeSupportRmax)
1014                                                                         -        fgkCarbonFiberJunctionLength
1015                                                                         +    fgkCarbonFiberTriangleLength,
1016                                                         0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
1017                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1018
1019   localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1020                                                           -   fgkCoolingTubeSupportRmax)
1021                                                         +       fgkCarbonFiberJunctionLength,
1022                                                         0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
1023                                                   -             0.5*fgkCoolingTubeSupportHeight);
1024   localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1025                                                   -      fgkCoolingTubeSupportRmax)
1026                                                   -      fgkCarbonFiberJunctionLength
1027                                                   +    fgkCarbonFiberTriangleLength,
1028                                                         0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
1029                                                   -             0.5*fgkCoolingTubeSupportHeight);
1030   for(Int_t i=0; i<2; i++)
1031         for(Int_t j=0; j<2; j++){
1032                 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1033                 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1034         }
1035   /////////////////////////////////////////////////////////////
1036   // SSD Hybrid Components Transformations
1037   /////////////////////////////////////////////////////////////
1038   const Int_t khybridmatrixnumber = 3;
1039   TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1040   localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1041                                             0.5*fgkSSDStiffenerWidth,
1042                                             0.5*fgkSSDStiffenerHeight);
1043   localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1044                                             fgkSSDModuleStiffenerPosition[1],0.0);
1045
1046   localhybridtrans[2] = new TGeoTranslation(
1047                       -  0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1048                       -      (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1049                               fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1050                       +         0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1051                       -         0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1052                       -       fgkSSDSensorCenterSupportThickness[0]),
1053                       -      (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
1054                       -       fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight
1055                                           -       fgkSSDModuleVerticalDisalignment));
1056   fhybridmatrix = new TGeoHMatrix();
1057   for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1058   /////////////////////////////////////////////////////////////
1059   // SSD Cooling Block Transformations
1060   /////////////////////////////////////////////////////////////
1061   TGeoTranslation localcoolingblocktrans (fcoolingtubematrix[0]->GetTranslation()[0]
1062                                           - 0.5*fgkSSDCoolingBlockLength,
1063                                           fhybridmatrix->GetTranslation()[1]-0.5*fgkSSDStiffenerWidth,
1064                                           fhybridmatrix->GetTranslation()[2]+0.5*fgkSSDStiffenerHeight+
1065                                           0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1066   fcoolingblocksystematrix = new TGeoHMatrix(localcoolingblocktrans);
1067   /////////////////////////////////////////////////////////////
1068   // SSD Stiffener Flex Transformations
1069   /////////////////////////////////////////////////////////////
1070   const Int_t klocalflexmatrixnumber = 4;
1071   TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1072   for(Int_t i=0; i<fgkflexnumber; i++)
1073       localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1074   for(Int_t i=0; i<fgkflexnumber; i++)
1075       for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1076             localflexmatrix[i][j] = new TGeoCombiTrans();
1077   Double_t ssdstiffenerseparation = fgkSSDSensorLength
1078                                                                   - 2.*fgkSSDModuleStiffenerPosition[1]
1079                                                                   -    fgkSSDStiffenerWidth;
1080   localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1081                                         +0.5*fgkSSDStiffenerLength,
1082                                          0.5*fgkSSDStiffenerWidth,
1083                                         -0.5*fgkSSDStiffenerHeight
1084                                         -0.5*fgkSSDFlexHeight[0]);
1085   localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1086                                         +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1087                                         -0.5*fgkSSDStiffenerWidth,
1088                                         -0.5*fgkSSDStiffenerHeight
1089                                         -0.5*fgkSSDFlexHeight[0]);
1090   TGeoRotation* localflexrot = new TGeoRotation();
1091   localflexrot->SetAngles(180.,0.,0.);
1092   localflexmatrix[1][0]->SetRotation(localflexrot);
1093   for(Int_t i=0; i<fgkflexnumber; i++)
1094       for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1095             localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1096   for(Int_t i=0; i<fgkflexnumber; i++){
1097       fstiffenerflexmatrix[i] = new TGeoHMatrix();
1098       for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1099             fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
1100   }
1101   /////////////////////////////////////////////////////////////
1102   // SSD End Flex Transformations
1103   /////////////////////////////////////////////////////////////
1104   TGeoRotation* localendflexrot = new TGeoRotation();
1105   localendflexrot->SetAngles(0.0,90.0,0.0);
1106   TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1107   Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1108                             /  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1109   Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1110                             * TMath::DegToRad()*ssdflexradiusmax
1111                                                                - fgkSSDFlexLength[2]-TMath::Pi()
1112                                                                * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1113                                                                                    - 0.1*fgkSSDFlexFullLength;
1114   Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1115                             + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1116                             +      fgkSSDFlexLength[2];
1117   localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1118                               0.5*fgkSSDFlexWidth[0],
1119                               2.*fgkSSDStiffenerHeight
1120                             + 0.5*fgkSSDFlexHeight[0]);
1121   localendflexmatrix->SetRotation(localendflexrot);
1122   for(Int_t i=0; i<fgkflexnumber; i++)
1123       fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1124   /////////////////////////////////////////////////////////////
1125   // End Ladder Carbon Fiber Junction
1126   /////////////////////////////////////////////////////////////
1127   TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1128   TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1129   TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1130   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1131       localendladdercarbonfiberjunctionmatrix[i]
1132             = new TGeoCombiTrans*[fgkendladdercarbonfiberjunctionmatrixnumber];
1133       localendladdercarbonfiberjunctionrot[i]
1134             = new TGeoRotation*[fgkendladdercarbonfiberjunctionmatrixnumber];
1135       localendladdercarbonfiberjunctiontrans[i]
1136             = new TGeoTranslation*[fgkendladdercarbonfiberjunctionmatrixnumber];
1137       fendladdercarbonfiberjunctionmatrix[i]
1138             = new TGeoHMatrix*[fgkendladdercarbonfiberjunctionmatrixnumber];
1139   }
1140   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1141       for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
1142             localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1143             localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1144       }
1145   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1146       for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++)
1147           localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1148   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1149       localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1150                               0.0,0.0);
1151       localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1152                 *                     CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1153                 *                     SinD(fgkCarbonFiberTriangleAngle),
1154                         0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1155   -                          fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1156   }
1157   TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1158   TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1159   TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1160   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1161       localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1162       localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1163       localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1164       localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1165             0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1166       localendladdercarbonfiberjunctionglobalmatrix[i] =
1167             new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1168                                *localendladdercarbonfiberjunctionglobalrot[i]);
1169   }
1170   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1171       for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
1172             localendladdercarbonfiberjunctionmatrix[i][j] =
1173                   new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1174                                      *localendladdercarbonfiberjunctionrot[i][j]);
1175            fendladdercarbonfiberjunctionmatrix[i][j] =
1176             new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1177             *               (*localendladdercarbonfiberjunctionmatrix[i][j]));
1178       }
1179   /////////////////////////////////////////////////////////////
1180   // End Ladder Carbon Fiber Support
1181   /////////////////////////////////////////////////////////////
1182   TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1183   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1184       localendladdercarbonfibertrans[i] = new TGeoTranslation();
1185       localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1186             i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1187       fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1188   }
1189   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1190       for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1191             fendladdercarbonfibermatrix[i][j] =
1192             new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1193             *(*fcarbonfibersupportmatrix[j]));
1194   /////////////////////////////////////////////////////////////
1195   // End Ladder SSD Mounting Block
1196   /////////////////////////////////////////////////////////////
1197   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1198       fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1199   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1200       fendladdermountingblockcombitrans[i]->SetTranslation(-  0.25*(fgkSSDMountingBlockLength[0]
1201                                 +        fgkSSDMountingBlockLength[1])
1202                                 +  0.5*fgkCarbonFiberTriangleLength,
1203                                 fgkEndLadderMountingBlockPosition[i],
1204                                 -  fgkSSDMountingBlockHeight[1]
1205                                 +  0.5*fgkSSDMountingBlockHeight[0]);
1206   TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1207   endladdermountingblockrot->SetAngles(0.,90.,0.);
1208   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1209         fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1210   /////////////////////////////////////////////////////////////
1211   // End Ladder SSD Mounting Block Clip Matrix
1212   /////////////////////////////////////////////////////////////
1213   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1214         fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1215
1216   TGeoRotation* localendladdercliprot = new TGeoRotation();
1217   TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1218   localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1219                                                                                   -     fgkSSDMountingBlockLength[1])
1220                                                                                   + fgkSSDMountingBlockLength[0],0.,0.);
1221   localendladdercliprot->SetAngles(90.,180.,-90.);
1222   TGeoCombiTrans* localendladderclipcombitrans =
1223                         new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1224   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1225         for(Int_t j=0; j<2; j++){
1226                 fendladdermountingblockclipmatrix[i][j] =
1227                                                 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1228                 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1229         }
1230   /////////////////////////////////////////////////////////////
1231   // End Ladder Carbon Fiber Lower Support
1232   /////////////////////////////////////////////////////////////
1233   for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1234       fendladderlowersupptrans[i] =
1235             new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1236                         +  0.5*fgkSSDMountingBlockWidth),
1237                         -  0.5*fgkCarbonFiberLowerSupportHeight);
1238   fendladderlowersupptrans[0]->SetDz(-0.5*fgkCarbonFiberLowerSupportHeight-fgkSSDTolerance);
1239   fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1240                                                                          fgkCarbonFiberLowerSupportVolumePosition[1]
1241                                                                 +    fgkCarbonFiberLowerSupportVolumePosition[0],
1242                                                                          0.0);
1243   fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1244  /////////////////////////////////////////////////////////////
1245   // Matrix for positioning Ladder into mother volume
1246   /////////////////////////////////////////////////////////////
1247   TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1248   for(Int_t i=0; i<fgkladdernumber; i++)
1249         ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1250   TGeoRotation* localladdermotherrot = new TGeoRotation();
1251   localladdermotherrot->SetAngles(0.,90.,0.);
1252   TGeoTranslation* localladdermothertrans[fgkladdernumber];
1253   TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1254   for(Int_t i=0; i<fgkladdernumber; i++){
1255         localladdermothertrans[i] = new TGeoTranslation(0.,
1256                                                           - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1257                                                           + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1258                                                           + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1259                                                           * fgkCarbonFiberJunctionWidth,0.);
1260         localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1261                                                                                                                 *localladdermotherrot);
1262         ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1263         ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
1264   }
1265   /////////////////////////////////////////////////////////////
1266   // Ladder Cables Matrices
1267   /////////////////////////////////////////////////////////////
1268   Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
1269                                              + fgkSSDFlexHeight[1];
1270   Double_t ssdladdercabletransx[3];
1271   ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1272                                                   *   SinD(2.*fgkSSDFlexAngle)
1273                                                   *       CosD(2.*fgkSSDFlexAngle);
1274   ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1275                                                   -     ssdladdercabletransx[0]
1276                                                   /     SinD(2.*fgkSSDFlexAngle))
1277                                                   *     CosD(fgkSSDFlexAngle);
1278   ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1279                                                   *       TMath::DegToRad()*ssdflexradiusmax
1280                                                   -     fgkSSDFlexLength[2]-TMath::Pi()
1281                                                   *       fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1282                                                   -       fgkSSDLadderCableWidth)
1283                                                   *       CosD(2.*fgkSSDFlexAngle);
1284   Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
1285                                                   *     TanD(2.*fgkSSDFlexAngle),
1286                                                         ssdladdercabletransx[1]
1287                                                   *     TanD(fgkSSDFlexAngle),
1288                                                         ssdladdercabletransx[2]
1289                                                   *     TanD(2.*fgkSSDFlexAngle)};
1290   TGeoRotation* localladdercablerot[3];
1291   for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1292   localladdercablerot[0]->SetAngles(90.,0.,0.);
1293   localladdercablerot[1]->SetAngles(90.,60.,-90.);
1294   localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1295                                                  *                        (*localladdercablerot[0]));
1296   //TGeoRotation* localladdercablerot = new TGeoRotation();
1297   //localladdercablerot->SetAngles(90.,0.,0.);
1298   ////////////////////////////////////////////
1299   // LocalLadderCableCombiTransMatrix
1300   ////////////////////////////////////////////
1301   const Int_t klocalladdersidecablesnumber = 2;
1302   const Int_t klocalladdercombitransnumber = 5;
1303   TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1304   for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1305          localladdercablecombitransmatrix[i] =
1306                                                            new TGeoCombiTrans*[klocalladdercombitransnumber];
1307   ///////////////////////////////////////////
1308   // Left Side Ladder Cables Transformations
1309   ///////////////////////////////////////////
1310   localladdercablecombitransmatrix[0][0]  =
1311                                                 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1312                                                 0.,0.,NULL);
1313   localladdercablecombitransmatrix[0][1] =
1314         new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1315                                            - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1316                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1317                                            + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1318                                            - 0.5*(fgkCarbonFiberLowerSupportWidth
1319                                            + fgkSSDSensorCenterSupportLength
1320                                            - fgkSSDSensorCenterSupportThickness[0]),
1321                                            - (fgkSSDModuleCoolingBlockToSensor
1322                                            + 0.5*fgkCoolingTubeSupportHeight
1323                                            - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1324                                            - fgkSSDChipHeight),NULL);
1325   localladdercablecombitransmatrix[0][2] =
1326                                                 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1327                                                                                    fgkSSDModuleStiffenerPosition[1],0.,0);
1328   localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1329                                         0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1330                                    +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1331                                    fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1332                                          - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1333                                                                                                 new TGeoRotation("",180.,0.,0.));
1334   localladdercablecombitransmatrix[0][4] =
1335                                                 new TGeoCombiTrans(-ssdladdercabletransx[0]
1336                                                 -     ssdladdercabletransx[1]-ssdladdercabletransx[2]
1337                                                 +     fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1338                                                           0.,
1339                                                           0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1340                                                 +         fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
1341                                                 +     ssdladdercabletransz[0]-ssdladdercabletransz[1]
1342                                                 +         ssdladdercabletransz[2],localladdercablerot[2]);
1343   ///////////////////////////////////////////
1344   // Rigth Side Ladder Cables Transformations
1345   ///////////////////////////////////////////
1346   TGeoCombiTrans* localladdercablessdmodulematrix =
1347         new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1348                                                                   - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1349                                                                          fgkSSDStiffenerWidth,
1350                                                                   - 0.5*fgkSSDFlexHeight[0],NULL);
1351   for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1352    localladdercablecombitransmatrix[1][i] =
1353                         (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1354                                         new TGeoCombiTrans(*localladdercablessdmodulematrix));
1355   ///////////////////////////////////////////
1356   // Setting LadderCableHMatrix
1357   ///////////////////////////////////////////
1358   Int_t beamaxistrans[2][3];
1359   beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1360   beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1361   beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1362   beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1363   beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1364   beamaxistrans[1][2] = beamaxistrans[1][0];
1365   TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1366   TGeoRotation* laddercablerot = new TGeoRotation();
1367   TGeoTranslation* laddercabletrans = new TGeoTranslation();
1368   TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1369   Double_t* laddercabletransvector;
1370   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1371         localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1372         fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1373   }
1374   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1375         for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1376                 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1377                 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1378                         localladdercablehmatrix[i][j]->MultiplyLeft(
1379                         localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1380         }
1381                 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1382                 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1383                 laddercabletrans->SetTranslation(laddercabletransvector[0],
1384                                                                          laddercabletransvector[1]
1385                                         +                (j==0 ? beamaxistrans[i][0] : 0.)
1386                                         *                                fgkCarbonFiberJunctionWidth,
1387                                                                          laddercabletransvector[2]);
1388                 laddercablecombitrans->SetRotation(*laddercablerot);
1389                 laddercablecombitrans->SetTranslation(*laddercabletrans);
1390                 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1391         }
1392     fladdercablematrix[i][2] =
1393                                         AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1394                                         beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1395         fladdercablematrix[i][3] =
1396                                         AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1397                                         beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1398   }
1399   for(Int_t i=0; i<fgkladdercablesnumber; i++)
1400     for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1401       fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1402
1403   ///////////////////////////////////////////
1404   // Setting Ladder HMatrix
1405   ///////////////////////////////////////////
1406   Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1407                                                                                                 fgkSSDLay6SensorsNumber};
1408   for(Int_t i=0; i<fgkladdernumber; i++){
1409         fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1410         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1411                 fladdermatrix[i][j] = new TGeoHMatrix();
1412                 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1413                 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1414                 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1415         }
1416   }
1417   ///////////////////////////////////////////
1418   // Setting SSD Sensor Matrix
1419   ///////////////////////////////////////////
1420   TGeoCombiTrans* localssdsensorcombitrans[2];
1421   TGeoRotation* localssdsensorrot = new TGeoRotation();
1422   localssdsensorrot->SetAngles(0.,90.,0.);
1423   TGeoTranslation* localssdsensortrans[2];
1424   for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1425   localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1426                                          fgkCarbonFiberJunctionWidth
1427                                          - fgkCarbonFiberLowerSupportWidth
1428                                          - fgkLowerSupportToSensorZ,
1429                                                         0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1430                                           -             fgkSSDModuleCoolingBlockToSensor
1431                                           +    (fgkSSDSensorSideSupportHeight[1]
1432                                           -             fgkSSDSensorSideSupportHeight[0]));
1433   localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1434                                          fgkCarbonFiberJunctionWidth
1435                                          - fgkCarbonFiberLowerSupportWidth
1436                                          - fgkLowerSupportToSensorZ,
1437                                                     0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1438                                                         -fgkSSDModuleCoolingBlockToSensor);
1439
1440   for(Int_t i=0; i<2; i++)
1441         localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1442                                                                                                          *localssdsensorrot);
1443     for(Int_t i=0; i<fgkladdernumber; i++){
1444         fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1445         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1446                 switch(i){
1447                         case 0: //Ladder of Layer5
1448                         fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1449                                                                    * ((j%2==0 ? *localssdsensorcombitrans[0] :
1450                                                                                                 *localssdsensorcombitrans[1])));
1451                         break;
1452                         case 1: //Ladder of Layer6
1453                         fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1454                                                                    * ((j%2==0 ? *localssdsensorcombitrans[1] :
1455                                                                                                 *localssdsensorcombitrans[0])));
1456                 break;
1457                 }
1458           }
1459   }
1460   //////////////////////////
1461   // Setting SSD End Ladder
1462   //////////////////////////
1463   for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1464   for(Int_t i=0; i<2; i++){
1465         fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1466         fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1467         fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1468         fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1469         fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1470         fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1471         fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1472         fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1473    }
1474   /////////////////////////////////////////////////////
1475   // Setting the CombiTransformation to pass ITS center
1476   /////////////////////////////////////////////////////
1477   Double_t itscentertransz[fgklayernumber];
1478   itscentertransz[0] = fgkSSDLay5LadderLength
1479                                          - fgkLay5CenterITSPosition;
1480   itscentertransz[1] = fgkSSDLay6LadderLength
1481                                          - fgkLay6CenterITSPosition;
1482   Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1483                                                    + 0.5*fgkCoolingTubeSupportHeight;
1484   TGeoRotation* itscenterrot[3];
1485   for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1486   itscenterrot[0]->SetAngles(90.,180.,-90.);
1487   itscenterrot[1]->SetAngles(0.,90.,0.);
1488   itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1489   TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1490   for(Int_t i=0; i<fgklayernumber; i++)
1491         itscentercombitrans[i] = new TGeoCombiTrans(0.,
1492                                                          itssensortransy,
1493                                                          fgkEndLadderCarbonFiberLowerJunctionLength[1]
1494                                                    - itscentertransz[i],itscenterrot[2]);
1495   TGeoRotation** locallayerrot[fgklayernumber];
1496   TGeoTranslation** locallayertrans[fgklayernumber];
1497   TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1498   TGeoTranslation* localbeamaxistrans[fgklayernumber];
1499   localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1500                                          - fgkLay5CenterITSPosition);
1501   localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1502                                          - fgkLay6CenterITSPosition);
1503   const Int_t kssdlayladdernumber[fgklayernumber] =
1504                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1505   for(Int_t i=0; i<fgklayernumber; i++){
1506     locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1507     locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1508         locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1509         flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1510   }
1511   Double_t layerladderangleposition[fgklayernumber] =
1512                 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1513   Double_t layerradius = 0.;
1514   for(Int_t i=0; i<fgklayernumber; i++){
1515         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1516                 switch(i){
1517                         case 0: //Ladder of Layer5
1518                         layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1519                         break;
1520                         case 1: //Ladder of Layer6
1521                         layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1522                 break;
1523                 }
1524                 locallayerrot[i][j] = new TGeoRotation();
1525                 locallayertrans[i][j] = new TGeoTranslation();
1526                 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1527                 locallayertrans[i][j]->SetTranslation(layerradius
1528                                                           *     CosD(90.0+j*layerladderangleposition[i]),
1529                                                             layerradius
1530                                                           * SinD(90.0+j*layerladderangleposition[i]),0.);
1531                 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1532                                                                          *locallayerrot[i][j]);
1533                 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1534                 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1535                 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1536         }
1537   }
1538   /////////////////////////////////////////////////////////////
1539   // Deallocating memory
1540   /////////////////////////////////////////////////////////////
1541   for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1542         delete carbonfiberot[i];
1543         delete localcarbonfibersupportmatrix[i];
1544   }
1545   for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1546      for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1547        delete localcarbonfiberjunctionmatrix[i][j];
1548            delete localcarbonfiberjunctionrot[i][j];
1549            delete localcarbonfiberjunctiontrans[i][j];
1550            }
1551        delete [] localcarbonfiberjunctionmatrix[i];
1552        delete [] localcarbonfiberjunctionrot[i];
1553        delete [] localcarbonfiberjunctiontrans[i];
1554   }
1555   for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1556            delete localcarbonfiberlowersupportrans[i];
1557   for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1558      for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1559        delete localssdsensorsupportmatrix[i][j];
1560            delete localssdsensorsupportrot[i][j];
1561            delete localssdsensorsupportrans[i][j];
1562            }
1563        delete [] localssdsensorsupportmatrix[i];
1564        delete [] localssdsensorsupportrot[i];
1565        delete [] localssdsensorsupportrans[i];
1566   }
1567   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1568         delete localcoolingtubesupportmatrix[i];
1569         delete localcoolingtubesupportrot[i];
1570         delete localcoolingtubesupportrans[i];
1571   }
1572   for(Int_t j=0; j<2; j++){
1573     delete localcoolingtubevect[j];
1574     delete localcoolingtubetrans[j];
1575   }
1576  delete endladdermountingblockrot;
1577  for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
1578  for(Int_t i=0; i<fgkflexnumber; i++){
1579       for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1580             delete localflexmatrix[i][j];
1581       delete [] localflexmatrix[i];
1582  }
1583  delete localendlladdercoolingtuberot;
1584  for(Int_t i=0; i<2; i++){
1585         for(Int_t j=0; j<2; j++)
1586           delete localendlladdercoolingtubetrans[i][j];
1587         delete [] localendlladdercoolingtubetrans[i];
1588   }
1589
1590  delete localflexrot;
1591  delete localendflexrot;
1592  delete localendflexmatrix;
1593  for(Int_t i=0; i<fgkladdernumber; i++){
1594         delete localladdermothertrans[i];
1595         delete localladdermothercombitrans[i];
1596   }
1597  delete localladdermotherrot;
1598  for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1599       for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
1600             delete localendladdercarbonfiberjunctionmatrix[i][j];
1601             delete localendladdercarbonfiberjunctionrot[i][j];
1602             delete localendladdercarbonfiberjunctiontrans[i][j];
1603       }
1604       delete [] localendladdercarbonfiberjunctionmatrix[i];
1605       delete [] localendladdercarbonfiberjunctionrot[i];
1606       delete [] localendladdercarbonfiberjunctiontrans[i];
1607       delete localendladdercarbonfiberjunctionglobalrot[i];
1608       delete localendladdercarbonfiberjunctionglobaltrans[i];
1609       delete localendladdercarbonfiberjunctionglobalmatrix[i];
1610  }
1611   for(Int_t i=0; i<2; i++){
1612         for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1613         delete [] localendladdercooltubetrans[i];
1614   }
1615   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1616       delete localendladdercarbonfibertrans[i];
1617   for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1618   for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1619         for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1620                 delete localladdercablecombitransmatrix[i][j];
1621                 delete []localladdercablecombitransmatrix[i];
1622   }
1623   delete localendladdercliprot;
1624   delete localendladdercliptrans;
1625   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1626         for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1627                 delete localladdercablehmatrix[i][j];
1628         delete []localladdercablehmatrix[i];
1629   }
1630   delete laddercablerot;
1631   delete laddercabletrans;
1632   delete laddercablecombitrans;
1633   delete localladdercablessdmodulematrix;
1634   delete localssdsensorrot;
1635   for(Int_t i=0; i<2; i++){
1636         delete localssdsensortrans[i];
1637         delete localssdsensorcombitrans[i];
1638   }
1639   for(Int_t i=0; i<fgklayernumber; i++){
1640         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1641                 delete locallayerrot[i][j];
1642                 delete locallayertrans[i][j];
1643                 delete locallayercombitrans[i][j];
1644     }
1645         delete [] locallayerrot[i];
1646         delete [] locallayertrans[i];
1647         delete [] locallayercombitrans[i];
1648         delete localbeamaxistrans[i];
1649   }
1650   for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1651   for(Int_t i=0; i<fgkladdernumber; i++){
1652         for(Int_t j=0; j<fgkladdernumber; j++)
1653                 delete ladderglobalmatrix[i][j];
1654         delete [] ladderglobalmatrix[i];
1655   }
1656   /////////////////////////////////////////////////////////////
1657   fTransformationMatrices = kTRUE;
1658 }
1659 ///////////////////////////////////////////////////////////////////////////////
1660 void AliITSv11GeometrySSD::CreateBasicObjects(){
1661   /////////////////////////////////////////////////////////////
1662   // Method generating the Objects of SSD Geometry
1663   /////////////////////////////////////////////////////////////
1664   // SSD Sensor
1665   ///////////////////////////////////
1666   SetSSDSensor();
1667   /////////////////////////////////////////////////////////////
1668   // Carbon Fiber Support
1669   /////////////////////////////////////////////////////////////
1670   TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1671   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1672       fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
1673   /////////////////////////////////////////////////////////////
1674   // Carbon Fiber Junction
1675   /////////////////////////////////////////////////////////////
1676   fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth-fgkSSDTolerance);
1677   /////////////////////////////////////////////////////////////
1678   // Carbon Fiber Lower Support
1679   /////////////////////////////////////////////////////////////
1680   TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1681   for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1682         fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1683   /////////////////////////////
1684   // SSD Sensor Support
1685   /////////////////////////////
1686   for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1687                                                                                 new TGeoVolume*[fgkssdsensorsupportnumber];
1688   Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
1689                                                                          fgkSSDSensorSideSupportThickness[1]};
1690   for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1691         fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1692                                                                                            fgkSSDSensorSideSupportHeight[i],
1693                                                                                            fgkSSDSensorSideSupportWidth,
1694                                                                                            sidesupporthickness);
1695         fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1696                                                                                            fgkSSDSensorCenterSupportHeight[i],
1697                                                                                            fgkSSDSensorCenterSupportWidth,
1698                                                                                            sidesupporthickness);
1699   }
1700   /////////////////////////////////////////////////////////////
1701   // SSD Cooling Tube Support
1702   /////////////////////////////////////////////////////////////
1703   Int_t edgesnumber = 3;
1704   fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1705   /////////////////////////////////////////////////////////////
1706   // SSD Hybrid
1707   /////////////////////////////////////////////////////////////
1708   TList* ssdhybridcomponentslist = GetSSDHybridParts();
1709   for(Int_t i=0; i<fgkhybridcompnumber; i++)
1710         fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1711   /////////////////////////////////////////////////////////////
1712   // SSD Cooling Block System
1713   /////////////////////////////////////////////////////////////
1714   fssdcoolingblocksystem = GetCoolingBlockSystem();
1715    /////////////////////////////////////////////////////////////
1716   // SSD Cooling Tube
1717   /////////////////////////////////////////////////////////////
1718   CreateCoolingTubes();
1719   /////////////////////////////////////////////////////////////
1720   // SSD Flex
1721   /////////////////////////////////////////////////////////////
1722   fssdstiffenerflex = GetSSDStiffenerFlex();
1723   fssdendflex = GetSSDEndFlex();
1724   ///////////////////////////////////
1725   // End Ladder Carbon Fiber Junction
1726   ///////////////////////////////////
1727   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1728                                                    fendladdercarbonfiberjunction[i] =
1729                                                    new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1730   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1731     fendladdercarbonfiberjunction[i][0] =
1732                   GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]-fgkSSDTolerance);
1733     fendladdercarbonfiberjunction[i][1] =
1734                   GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]-fgkSSDTolerance);
1735   }
1736   ///////////////////////////////////
1737   // End Ladder Mounting Block
1738   ///////////////////////////////////
1739   fendladdermountingblock = GetSSDMountingBlock();
1740   ///////////////////////////////////
1741   // End Ladder Mounting Block
1742   ///////////////////////////////////
1743   fendladdermountingblockclip = GetMountingBlockClip();
1744   ///////////////////////////////////
1745   // Ladder Support
1746   ///////////////////////////////////
1747   TList* laddersupportlist = GetMountingBlockSupport(20);
1748   fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1749   fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1750   fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1751   fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
1752   /////////////////////////////////////////////////////////////
1753   // Deallocating memory
1754   /////////////////////////////////////////////////////////////
1755   delete carbonfibersupportlist;
1756   delete carbonfiberlowersupportlist;
1757   delete ssdhybridcomponentslist;
1758   delete laddersupportlist;
1759   /////////////////////////////////////////////////////////////
1760   fBasicObjects = kTRUE;
1761 }
1762 /////////////////////////////////////////////////////////////////////////////////
1763 void AliITSv11GeometrySSD::SetSSDSensor(){
1764   ////////////////////////////////////////////////////////////////
1765   // Method generating SSD Sensors: it sets the private variables
1766   // fSSDSensor5, fSSDSensor6
1767   ////////////////////////////////////////////////////////////////
1768   Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1769   Double_t ssdsensitivewidth  = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1770   TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
1771                                                 0.5*ssdsensitivewidth,
1772                                                 0.5*fgkSSDSensorHeight,
1773                                                 0.5*ssdsensitivelength);
1774   TGeoVolume* ssdsensorsensitiveLay5 =
1775         new TGeoVolume(fgkSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
1776   TGeoVolume* ssdsensorsensitiveLay6 =
1777         new TGeoVolume(fgkSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
1778   ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1779   ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
1780   TGeoBBox* ssdsensorinsensitiveshape[2];
1781   ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
1782                                                 0.5*fgkSSDSensorInsensitiveWidth,
1783                                                 0.5*fgkSSDSensorHeight,
1784                                                 0.5*fgkSSDSensorLength);
1785   ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
1786                                                 0.5*ssdsensitivewidth,
1787                                                 0.5*fgkSSDSensorHeight,
1788                                                 0.5*fgkSSDSensorInsensitiveWidth);
1789   const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
1790                                              "SSDSensorInsensitive2"};
1791   TGeoVolume* ssdsensorinsensitive[2];
1792   for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1793       new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1794                      fSSDSensorMedium);
1795       ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
1796   }
1797   /////////////////////////////////////////////////////////////
1798   // Virtual Volume containing SSD Sensor
1799   /////////////////////////////////////////////////////////////
1800   TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1801                                                                                              0.5*fgkSSDSensorWidth,
1802                                                                                              0.5*fgkSSDSensorHeight,
1803                                                                                              0.5*fgkSSDSensorLength);
1804   fSSDSensor5 = new TGeoVolume("ITSssdSensor5",virtualSSDSensorShape,
1805                                                                                  fSSDAir);
1806   fSSDSensor6 = new TGeoVolume("ITSssdSensor6",virtualSSDSensorShape,
1807                                                                                  fSSDAir);
1808   /////////////////////////////////////////////////////////////
1809   for(Int_t i=0; i<4; i++){
1810             fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1811             ssdsensorinsensitive[1],i<2?1:2,
1812                         new TGeoTranslation(
1813                          0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1814       *   (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1815                         0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1816       *   (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1817             fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1818             ssdsensorinsensitive[1],i<2?1:2,
1819                         new TGeoTranslation(
1820                          0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1821       *   (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1822                         0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1823       *   (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1824   }
1825     fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1826     fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
1827 }
1828 ///////////////////////////////////////////////////////////////////////////////
1829 TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1830   /////////////////////////////////////////////////////////////
1831   // Method generating the Carbon Fiber Support
1832   /////////////////////////////////////////////////////////////
1833   const Int_t kvertexnumber = 4;
1834   const Int_t kshapesnumber = 2;
1835   TVector3** vertexposition[kshapesnumber];
1836   for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1837   Double_t carbonfibersupportxaxisEdgeproj =
1838                 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1839         *       TMath::DegToRad());
1840   Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1841                                  /                         fgkCarbonFiberSupportXAxisLength);
1842   /////////////////////
1843   //Vertex Positioning
1844   ////////////////////
1845   vertexposition[0][0] = new TVector3();
1846   vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
1847                                       fgkCarbonFiberSupportYAxisLength, 0);
1848   vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
1849                                                                           carbonfibersupportxaxisEdgeproj
1850                                       *                   TMath::Tan(theta), 0);
1851   vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
1852                                            -                      carbonfibersupportxaxisEdgeproj,
1853                                                                           fgkCarbonFiberSupportYAxisLength
1854                                       - vertexposition[0][2]->Y(), 0);
1855   ////////////////////////////////////////////////////
1856   //Setting the parameters for Isometry Transformation
1857   ////////////////////////////////////////////////////
1858   Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
1859                                                                  +      fgkCarbonFiberSupportTopEdgeDist[0]
1860                                                                  +      fgkCarbonFiberSupportWidth);
1861   Double_t* param = new Double_t[4];
1862   param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
1863   for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
1864     new TVector3((GetReflection(vertexposition[0][j],param))->X(),
1865                  (GetReflection(vertexposition[0][j],param))->Y(), 0);
1866   const char* carbonfibersupportshapename[kshapesnumber] =
1867                                                 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
1868   const char* carbonfibersupportname[kshapesnumber] =
1869                                                 {"CarbonFiberSupport1","CarbonFiberSupport2"};
1870   TGeoArb8* carbonfibersupportshape[kshapesnumber];
1871   TGeoVolume* carbonfibersupport[kshapesnumber];
1872   TList* carbonfibersupportlist = new TList();
1873   Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
1874   Double_t carbonfibersupportheight =
1875           carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1876           *TMath::DegToRad());
1877   for(Int_t i = 0; i< kshapesnumber; i++){
1878    carbonfibersupportshape[i] =
1879                                         GetArbShape(vertexposition[i],width,carbonfibersupportheight,
1880                                                                 carbonfibersupportshapename[i],i==0 ? 1: -1);
1881    carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
1882                                                    carbonfibersupportshape[i],fSSDCarbonFiberMedium);
1883    carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
1884    carbonfibersupportlist->Add(carbonfibersupport[i]);
1885    }
1886   /////////////////////////////////////////////////////////////
1887   // Deallocating memory
1888   /////////////////////////////////////////////////////////////
1889   for(Int_t i=0; i< kshapesnumber; i++){
1890      for(Int_t j=0; j< kvertexnumber; j++)
1891            delete vertexposition[i][j];
1892        delete [] vertexposition[i];
1893   }
1894   delete [] param;
1895   /////////////////////////////////////////////////////////////
1896    return carbonfibersupportlist;
1897 }
1898 /////////////////////////////////////////////////////////////////////////////////
1899 TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
1900   /////////////////////////////////////////////////////////////
1901   // Method generating SSD Carbon Fiber Junction
1902   /////////////////////////////////////////////////////////////
1903   const Int_t kvertexnumber = 6;
1904   TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
1905   Double_t reflectionparam[4] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1906                                             *  TMath::DegToRad()),-1.,0.,0.};
1907   TVector3* vertex[kvertexnumber];
1908   vertex[0] = new TVector3();
1909   vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
1910                         *                         TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1911                         *                         TMath::DegToRad()),
1912                                                   fgkCarbonFiberJunctionEdge[0]
1913                         *                         TMath::Sin(fgkCarbonFiberJunctionAngle[0]
1914                                         * TMath::DegToRad()), 0);
1915   vertex[4] = new TVector3(fgkCarbonFiberJunctionLength-fgkSSDTolerance,
1916                            fgkCarbonFiberJunctionEdge[1], 0);
1917   vertex[5] = new TVector3(fgkCarbonFiberJunctionLength-fgkSSDTolerance, 0, 0);
1918   vertex[1] = GetReflection(vertex[5],reflectionparam);
1919   vertex[2] = GetReflection(vertex[4],reflectionparam);
1920   Double_t xvertexpoints[6], yvertexpoints[6];
1921   for(Int_t i=0; i<kvertexnumber; i++)
1922           xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
1923   carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
1924   carbonfiberjunctionshape->DefineSection(0,-0.5*width);
1925   carbonfiberjunctionshape->DefineSection(1,0.5*width);
1926   TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
1927                                                                 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
1928   carbonfiberjunction->SetLineColor(fColorCarbonFiber);
1929   /////////////////////////////////////////////////////////////
1930   // Deallocating memory
1931   /////////////////////////////////////////////////////////////
1932   for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
1933   /////////////////////////////////////////////////////////////
1934   return carbonfiberjunction;
1935 }
1936 ////////////////////////////////////////////////////////////////////////////////
1937 TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
1938   /////////////////////////////////////////////////////////////
1939   // Method generating the Carbon Fiber Lower Support
1940   /////////////////////////////////////////////////////////////
1941   const Int_t kvertexnumber = 4;
1942   const Int_t kshapesnumber = 2;
1943   Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
1944                                                                 fgkCarbonFiberLowerSupportWidth};
1945   TVector3** vertexposition[kshapesnumber];
1946   for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
1947                                                  new TVector3*[kvertexnumber];
1948   //First Shape Vertex Positioning
1949   vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght, 0, 0);
1950   vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
1951                                       - fgkCarbonFiberLowerSupportLowerLenght, 0, 0);
1952   vertexposition[0][2] = new TVector3();
1953   vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength, 0, 0);
1954   //Second Shape Vertex Positioning
1955   Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
1956                                  -                              fgkCarbonFiberLowerSupportVolumePosition[0])
1957                                  /                              fgkCarbonFiberTriangleLength);
1958   vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
1959                                                                 vertexposition[0][0]->X()*TMath::Tan(theta)
1960                                       + fgkCarbonFiberLowerSupportVolumePosition[0], 0);
1961   vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
1962                                                                 vertexposition[0][1]->X()*TMath::Tan(theta)
1963                                       + fgkCarbonFiberLowerSupportVolumePosition[0], 0);
1964   vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0], 0);
1965   vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
1966                                       fgkCarbonFiberLowerSupportVolumePosition[1], 0);
1967   const char* carbonfiberlowersupportshapename[kshapesnumber] =
1968                           {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
1969   const char* carbonfiberlowersupportname[kshapesnumber] =
1970                           {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
1971   TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
1972   TGeoVolume* carbonfiberlowersupport[kshapesnumber];
1973   TList* carbonfiberlowersupportlist = new TList();
1974   for(Int_t i = 0; i< kshapesnumber; i++){
1975         carbonfiberlowersupportshape[i] =
1976                                                                 GetArbShape(vertexposition[i],width,
1977                                                                                         fgkCarbonFiberLowerSupportHeight,
1978                                                                                         carbonfiberlowersupportshapename[i]);
1979     carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
1980                                                 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
1981         carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
1982     carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
1983   }
1984   /////////////////////////////////////////////////////////////
1985   // Deallocating memory
1986   /////////////////////////////////////////////////////////////
1987   for(Int_t i=0; i< kshapesnumber; i++){
1988      for(Int_t j=0; j< kvertexnumber; j++)
1989            delete vertexposition[i][j];
1990        delete [] vertexposition[i];
1991   }
1992   /////////////////////////////////////////////////////////////
1993   return carbonfiberlowersupportlist;
1994 }
1995 ///////////////////////////////////////////////////////////////////////////////
1996 TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
1997                                                                  Double_t width, const Double_t* thickness)const{
1998   /////////////////////////////////////////////////////////////
1999   // Method generating the Sensor Support
2000   /////////////////////////////////////////////////////////////
2001         const Int_t kvertexnumber = 6;
2002         TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2003     TVector3* vertexposition[kvertexnumber];
2004         vertexposition[0] = new TVector3();
2005         vertexposition[1] = new TVector3(0.0,length,0);
2006         vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y(),0);
2007         vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0],0);
2008         vertexposition[4] = new TVector3(height,vertexposition[3]->Y(),0);
2009         vertexposition[5] = new TVector3(vertexposition[4]->X(),0,0);
2010         Double_t xvertexpoints[6], yvertexpoints[6];
2011         for(Int_t i=0; i<kvertexnumber; i++)
2012                 xvertexpoints[i] = vertexposition[i]->X(),
2013                 yvertexpoints[i] = vertexposition[i]->Y();
2014     ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2015     ssdsensorsupportshape->DefineSection(0,-0.5*width);
2016     ssdsensorsupportshape->DefineSection(1,0.5*width);
2017     TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2018                                                                  ssdsensorsupportshape,fSSDSensorSupportMedium);
2019   /////////////////////////////////////////////////////////////
2020   // Deallocating memory
2021   /////////////////////////////////////////////////////////////
2022         for (Int_t i=0; i<kvertexnumber; i++)
2023                 delete vertexposition[i];
2024   /////////////////////////////////////////////////////////////
2025     return ssdsensorsupport;
2026 }
2027 ////////////////////////////////////////////////////////////////////////////////
2028 TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2029   /////////////////////////////////////////////////////////////
2030   // Method generating the Cooling Tube Support
2031   /////////////////////////////////////////////////////////////
2032   if(nedges%2!=0) nedges--;
2033   const Int_t kvertexnumber = nedges+5;
2034   Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2035                            /                     fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2036   Double_t angle = 90.+phi;
2037   Double_t psi = 90.-phi;
2038   ///////////////////////////////////////
2039   // Vertex Positioning for TGeoXTru
2040   ///////////////////////////////////////
2041   TVector3** vertexposition = new TVector3*[kvertexnumber];
2042
2043   Double_t router = fgkCoolingTubeSupportRmin/CosD(phi/nedges);  //  Recalc inner radius so that tube fits inside
2044   vertexposition[0] = new TVector3(router*CosD(angle),
2045                                    router*SinD(angle), 0);
2046   vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2047                                    fgkCoolingTubeSupportRmax*SinD(angle),0);
2048   vertexposition[2] = new TVector3(vertexposition[1]->X(),
2049                                    fgkCoolingTubeSupportRmax, 0);
2050   vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2051                                    fgkCoolingTubeSupportRmax, 0);
2052   vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2053                                    vertexposition[1]->Y(), 0);
2054
2055   for(Int_t i=0; i<nedges; i++)
2056         vertexposition[i+5] =
2057                 new TVector3(router*CosD(psi+i*(2.*phi/nedges)),
2058                              router*SinD(psi+i*(2.*phi/nedges)), 0);
2059   ///////////////////////////////////////////////////////////////////////
2060   // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2061   ///////////////////////////////////////////////////////////////////////
2062   TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2063   Double_t* xvertexpoints = new Double_t[kvertexnumber];
2064   Double_t* yvertexpoints = new Double_t[kvertexnumber];
2065   for(Int_t i=0; i<kvertexnumber; i++){
2066         xvertexpoints[i] = vertexposition[i]->X();
2067         yvertexpoints[i] = vertexposition[i]->Y();
2068   }
2069   coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2070                                                                                         yvertexpoints);
2071   coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2072   coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2073   TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2074                                                                           coolingtubesupportarcshape,
2075                                                                                   fSSDTubeHolderMedium);
2076   coolingtubesupportarc->SetLineColor(fColorG10);
2077   //////////////////////////////////////////////////////////////////////////
2078   // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2079   //////////////////////////////////////////////////////////////////////////
2080   TGeoTubeSeg* coolingtubesupportsegshape =
2081                                                         new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2082                                                                                         fgkCoolingTubeSupportRmax,
2083                                                                                         0.5*fgkCoolingTubeSupportWidth,
2084                                                                                         phi,360-phi);
2085   TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2086                                                                                         coolingtubesupportsegshape,
2087                                                                                         fSSDTubeHolderMedium);
2088   coolingtubesupportseg->SetLineColor(fColorG10);
2089   //////////////////////////////////////////////////////////////////////////
2090   // TGeoBBox Volume definition for Cooling Tube Support Box Part
2091   //////////////////////////////////////////////////////////////////////////
2092   Double_t* boxorigin = new Double_t[3];
2093   Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2094   boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2095   TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2096                                                                                  0.5*fgkCoolingTubeSupportHeight,
2097                                                                                  0.5*fgkCoolingTubeSupportWidth,boxorigin);
2098   TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2099                                coolingtubesupportboxshape,fSSDTubeHolderMedium);
2100   coolingtubesupportbox->SetLineColor(fColorG10);
2101   //////////////////////////////////////////////////////////////////////////
2102   // Cooling Tube for Cooling Tube Support
2103   //////////////////////////////////////////////////////////////////////////
2104   TGeoXtru* coolingtubearcshape[2];
2105   coolingtubearcshape[0] = new TGeoXtru(2);
2106   Double_t* xvert = new Double_t[nedges+2];
2107   Double_t* yvert = new Double_t[nedges+2];
2108   Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2109   ////////////////////////////////////////
2110   // Positioning the vertices for TGeoXTru
2111   ////////////////////////////////////////
2112   xvert[0] = 0., yvert[0] = 0.;
2113   xvert[1] = vertexposition[0]->X()*ratio,  yvert[1] = vertexposition[0]->Y()*ratio;
2114   for(Int_t i=0; i< nedges; i++)
2115                 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2116                 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2117   ////////////////////////////////////////
2118   // Defining TGeoXTru PolyGone
2119   ////////////////////////////////////////
2120   coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2121   coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2122   coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2123   coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2124                 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2125   TGeoVolume* coolingtubearc[2];
2126   coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2127                                                                   coolingtubearcshape[0],fSSDCoolingTubeWater);
2128   coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2129                                                                   coolingtubearcshape[1],fSSDCoolingTubePhynox);
2130   coolingtubearc[0]->SetLineColor(fColorWater);
2131   coolingtubearc[1]->SetLineColor(fColorPhynox);
2132   ////////////////////////////////////////////
2133   // Defining TGeoTubeSeg Part of Cooling Tube
2134   ////////////////////////////////////////////
2135   TGeoTubeSeg* coolingtubesegshape[2];
2136   coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2137                                                         0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2138   coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2139                                                         0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2140   TGeoVolume* coolingtubeseg[2];
2141   coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2142                                                                  coolingtubesegshape[0],fSSDCoolingTubePhynox);
2143   coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2144                                                                  coolingtubesegshape[1],fSSDCoolingTubeWater);
2145   coolingtubeseg[0]->SetLineColor(fColorPhynox);
2146   coolingtubeseg[1]->SetLineColor(fColorWater);
2147   /////////////////////////////////////////////////////////////
2148   // Virtual Volume containing Cooling Tube Support
2149   /////////////////////////////////////////////////////////////
2150   TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2151   const Int_t kvirtualvertexnumber = 8;
2152   TVector3* virtualvertex[kvirtualvertexnumber];
2153    ////////////////////////////////////////
2154   // Positioning the vertices for TGeoXTru
2155   ////////////////////////////////////////
2156   virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax, 0);
2157   virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y(),0);
2158   virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y(),0);
2159   virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight,0);
2160   virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y(),0);
2161   virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y(),0);
2162   virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y(),0);
2163   virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y(),0);
2164   Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2165   for(Int_t i=0; i< kvirtualvertexnumber; i++)
2166         xmothervertex[i] = virtualvertex[i]->X(),
2167         ymothervertex[i] = virtualvertex[i]->Y();
2168   ////////////////////////////////////////
2169   // Defining TGeoXTru PolyGone
2170   ////////////////////////////////////////
2171   virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2172                                                                                                                                          ymothervertex);
2173   virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2174   virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2175   /*TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2176     virtualCoolingTubeSupportShape,fSSDAir); */
2177   TGeoVolume* virtualcoolingtubesupport = new TGeoVolumeAssembly("CoolingTubeSupport");
2178
2179   ////////////////////////////////////////
2180   // Positioning Volumes in Virtual Volume
2181   ////////////////////////////////////////
2182   TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2183   coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2184   virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2185   virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2186   virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
2187   //virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2188   //virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2189   //virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2190   //virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
2191   /////////////////////////////////////////////////////////////
2192   // Deallocating memory
2193   /////////////////////////////////////////////////////////////
2194   delete [] vertexposition;
2195   delete [] xvertexpoints;
2196   delete [] yvertexpoints;
2197   delete [] xvert;
2198   delete [] yvert;
2199   for(Int_t i=0; i< kvirtualvertexnumber; i++)
2200         delete virtualvertex[i];
2201   /////////////////////////////////////////////////////////////
2202         return virtualcoolingtubesupport;
2203 }
2204 /////////////////////////////////////////////////////////////////////////////////
2205 TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2206   /////////////////////////////////////////////////////////////
2207   // Method generating List containing SSD Hybrid Components
2208   /////////////////////////////////////////////////////////////
2209   TList* ssdhybridlist = new TList();
2210   const Int_t kssdstiffenernumber = 2;
2211   Double_t ssdstiffenerseparation = fgkSSDSensorLength
2212                                                                   - 2.*fgkSSDModuleStiffenerPosition[1]
2213                                                                   -    fgkSSDStiffenerWidth;
2214   Double_t ssdchipcablesradius[kssdstiffenernumber];
2215   for(Int_t i=0; i<kssdstiffenernumber; i++)
2216           ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2217                                -  fgkSSDChipCablesHeight[0]
2218                                -  fgkSSDChipCablesHeight[1]);
2219   /////////////////////////////////////////////////////////////
2220   // Mother Volumes Containers
2221   /////////////////////////////////////////////////////////////
2222   const Int_t kmothernumber = 2;
2223   const Int_t kmothervertexnumber = 8;
2224   Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2225   Double_t ymothervertex[kmothernumber][kmothervertexnumber];
2226
2227   TGeoVolumeAssembly* ssdhybridassembly[kmothernumber];
2228   TGeoVolume* ssdhybridmother[kmothernumber][2];
2229
2230   TGeoRotation hybridmotherrotR(TGeoRotation("",-90.0,0.0,0.0)*TGeoRotation("",0.0,90.0,0.0)*TGeoRotation("",90.,180.,-90));
2231   TGeoRotation hybridmotherrotL(TGeoRotation("",180.,0.0,0.0)*hybridmotherrotR);
2232   TGeoRotation *hybridmotherrotInv = new TGeoRotation(hybridmotherrotR.Inverse());
2233
2234   const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2235   for(Int_t i=0; i<kmothernumber; i++){
2236     xmothervertex[i][0] = -0.5*fgkSSDStiffenerWidth;
2237     ymothervertex[i][0] = 0.5*fgkSSDStiffenerHeight;
2238     xmothervertex[i][1] = -0.5*fgkSSDStiffenerWidth;
2239     ymothervertex[i][1] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2240       -fgkSSDChipCablesHeight[i+2];
2241
2242     xmothervertex[i][2] = 0.5*(fgkSSDSensorLength-ssdstiffenerseparation); //0.5*fgkSSDStiffenerWidth;
2243     ymothervertex[i][2] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight -fgkSSDChipCablesHeight[i+2];
2244     xmothervertex[i][3] = xmothervertex[i][2];
2245     ymothervertex[i][3] = ymothervertex[i][2]+fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1]+fgkSSDTolerance;
2246
2247     xmothervertex[i][4] = xmothervertex[i][2]-0.4;
2248     ymothervertex[i][4] = ymothervertex[i][3];
2249     xmothervertex[i][5] = xmothervertex[i][4];
2250     ymothervertex[i][5] = ymothervertex[i][4]+2*ssdchipcablesradius[i]-fgkSSDTolerance;
2251
2252     xmothervertex[i][6] = 0.5*fgkSSDStiffenerWidth+ssdchipcablesradius[i]+0.3*fgkmm;
2253     ymothervertex[i][6] = ymothervertex[i][5];
2254
2255     xmothervertex[i][7] = xmothervertex[i][6];
2256     ymothervertex[i][7] = 0.5*fgkSSDStiffenerHeight;
2257     TGeoXtru *shape = new TGeoXtru(2);
2258     shape->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
2259     shape->DefineSection(0,-0.5*fgkSSDStiffenerLength);
2260     shape->DefineSection(1,0.5*fgkSSDStiffenerLength);
2261     ssdhybridmother[i][0] = new TGeoVolume(TString(ssdhybridmothername[i])+"L",shape,fSSDAir);
2262     ssdhybridmother[i][1] = new TGeoVolume(TString(ssdhybridmothername[i])+"R",shape,fSSDAir);
2263     ssdhybridassembly[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]);
2264    }
2265   /////////////////////////////////////////////////////////////
2266   // SSD Stiffener
2267   /////////////////////////////////////////////////////////////
2268   TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2269                                              0.5*fgkSSDStiffenerLength,
2270                                              0.5*(fgkSSDStiffenerWidth-fgkSSDTolerance),
2271                                              0.5*fgkSSDStiffenerHeight);
2272   TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2273                                             fSSDStiffenerMedium);
2274   ssdstiffener->SetLineColor(fColorStiffener);
2275
2276 ////////////////////////////
2277 // Capacitor 0603-2200 nF
2278 ///////////////////////////
2279   const Int_t knapacitor0603number = 5;
2280   TGeoBBox* capacitor0603mothershape =  new TGeoBBox("Capacitor0603MotherShape",
2281                                                0.5*fgkSSDCapacitor0603Length + fgkSSDCapacitor0603CapLength,
2282                                                0.5*fgkSSDCapacitor0603Width,
2283                                                0.5*fgkSSDCapacitor0603Height);
2284   TGeoVolume* capacitor0603mother = new TGeoVolume("Capacitor0603Mother",capacitor0603mothershape,
2285                                              fSSDAir);
2286
2287   TGeoBBox* capacitor0603shape =  new TGeoBBox("Capacitor0603Shape",
2288                                                0.5*fgkSSDCapacitor0603Length,
2289                                                0.5*fgkSSDCapacitor0603Width,
2290                                                0.5*fgkSSDCapacitor0603Height);
2291   TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
2292                                              fSSDStiffener0603CapacitorMedium);
2293   capacitor0603->SetLineColor(fColorAl);
2294   TGeoTranslation *cap0603trans = new TGeoTranslation(0.,0.,0.);
2295   capacitor0603mother->AddNode(capacitor0603,1,cap0603trans);
2296
2297   TGeoBBox* capacitor0603capshape =  new TGeoBBox("Capacitor0603CapShape",
2298                                                0.5*fgkSSDCapacitor0603CapLength,
2299                                                0.5*fgkSSDCapacitor0603Width,
2300                                                0.5*fgkSSDCapacitor0603Height);
2301   TGeoVolume* capacitor0603cap = new TGeoVolume("Capacitor0603Cap",capacitor0603capshape,
2302                                              fSSDStiffenerCapacitorCapMedium);
2303   capacitor0603cap->SetLineColor(fColorNiSn);
2304   TGeoTranslation *cap0603captrans1 = new TGeoTranslation(- capacitor0603shape->GetDX() - capacitor0603capshape->GetDX(),0.,0.);
2305   capacitor0603mother->AddNode(capacitor0603cap,1,cap0603captrans1);
2306   TGeoTranslation *cap0603captrans2 = new TGeoTranslation(capacitor0603shape->GetDX() + capacitor0603capshape->GetDX(),0.,0.);
2307   capacitor0603mother->AddNode(capacitor0603cap,2,cap0603captrans2);
2308
2309
2310   TGeoVolume* ssdchip = GetSSDChip();
2311
2312   const Int_t knedges = 5;
2313   TGeoVolume *ssdchipcables[2];
2314
2315   for(Int_t i=0; i<kmothernumber; i++){
2316     for(Int_t j=0; j<kssdstiffenernumber; j++){
2317       ssdhybridmother[i][j]->AddNode(ssdstiffener,1,hybridmotherrotInv);
2318       for(Int_t k=1; k<knapacitor0603number+1; k++){
2319         ssdhybridmother[i][j]->AddNode(capacitor0603mother,k,
2320                                        new TGeoCombiTrans("",
2321                                                           -0.5*(fgkSSDStiffenerWidth - fgkSSDCapacitor0603Width),
2322                                                           -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height),
2323                                                           (k-3.)/6*fgkSSDStiffenerLength,
2324                                                           hybridmotherrotInv));
2325       }
2326     }
2327
2328     GetSSDChipCables(ssdchipcables[0],ssdchipcables[1],fgkSSDChipCablesHeight[i+2],knedges);
2329     for(Int_t k=0; k<fgkSSDChipNumber; k++){
2330       TGeoTranslation *chipcabletrans = new TGeoTranslation("",0.5*fgkSSDStiffenerWidth-fgkSSDChipWidth,
2331                                                             - 0.5*fgkSSDStiffenerHeight - fgkSSDChipHeight
2332                                                             - fgkSSDChipCablesHeight[i+2],
2333                                                             (k+0.5-fgkSSDChipNumber/2)*
2334                                                             (fgkSSDChipLength + fgkSSDChipSeparationLength));
2335       TGeoCombiTrans *chiptrans = new TGeoCombiTrans("",0.5*(fgkSSDStiffenerWidth-fgkSSDChipWidth),
2336                                                      - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight),
2337                                                      (k+0.5-fgkSSDChipNumber/2)*(fgkSSDChipLength + fgkSSDChipSeparationLength),
2338                                                      hybridmotherrotInv);
2339       for(Int_t j=0; j<kssdstiffenernumber; j++){
2340         ssdhybridmother[i][j]->AddNode(ssdchipcables[j],k+1,chipcabletrans);
2341         ssdhybridmother[i][j]->AddNode(ssdchip,k+1,chiptrans);
2342       }
2343     }
2344     // Final placement by assembly
2345     ssdhybridassembly[i]->AddNode(ssdhybridmother[i][0],1,new TGeoCombiTrans(TGeoTranslation("",0,0,0),hybridmotherrotL));
2346     ssdhybridassembly[i]->AddNode(ssdhybridmother[i][1],1,new TGeoCombiTrans(TGeoTranslation("",0,ssdstiffenerseparation,0),hybridmotherrotR));
2347     ssdhybridlist->Add(ssdhybridassembly[i]);
2348   }
2349   /////////////////////////////////////////////////////////////
2350   // Mother Volume Containing Capacitor Part
2351   /////////////////////////////////////////////////////////////
2352   const Int_t kcapacitormothernumber = 8;
2353   Double_t xcapacitorvertex[kcapacitormothernumber];
2354   Double_t ycapacitorvertex[kcapacitormothernumber];
2355   ///////////////////////
2356   // Setting the vertices
2357   ///////////////////////
2358   xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2359   xcapacitorvertex[1] = xcapacitorvertex[0];
2360   xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2361   xcapacitorvertex[3] = xcapacitorvertex[2];
2362   xcapacitorvertex[4] = xcapacitorvertex[0];
2363   xcapacitorvertex[5] = xcapacitorvertex[0];
2364   xcapacitorvertex[6] = -xcapacitorvertex[0];
2365   xcapacitorvertex[7] = xcapacitorvertex[6];
2366   ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2367   ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2368   ycapacitorvertex[2] = ycapacitorvertex[1];
2369   ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2370   ycapacitorvertex[4] = ycapacitorvertex[3];
2371   ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2372   ycapacitorvertex[6] = ycapacitorvertex[5];
2373   ycapacitorvertex[7] = ycapacitorvertex[0];
2374   TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2375   ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2376                                               ycapacitorvertex);
2377   ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2378   ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
2379 //  TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2380 //                                          fSSDAir);
2381   TGeoVolumeAssembly* ssdhybridcapacitormother = new TGeoVolumeAssembly("SSDHybridCapacitorMother");
2382 ////////////////////////////
2383 // Connector
2384 ///////////////////////////
2385   const Int_t kssdconnectorlayernumber = 3;
2386   TGeoBBox* ssdconnectorshape[kssdconnectorlayernumber];
2387   Double_t ssdConnectorThickness[kssdconnectorlayernumber]={fgkSSDConnectorAlHeight,fgkSSDConnectorNiHeight,fgkSSDConnectorSnHeight};
2388   /*
2389   Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2390   Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2391                                    +  fgkSSDConnectorAlHeight};
2392   */
2393   Double_t ssdconnectororigin[3] = {0,0,0.5*fgkSSDStiffenerHeight};
2394   const char* ssdconnectorname[kssdconnectorlayernumber] = {"SSDConnectorAl","SSDConnectorNi","SSDConnectorSn"};
2395   TGeoMedium *ssdConnectorMedium[kssdconnectorlayernumber]={fSSDAlTraceFlexMedium,fSSDStiffenerConnectorMedium,fSSDSn};
2396   TGeoVolume* ssdconnector[kssdconnectorlayernumber];
2397   for(Int_t i=0; i<kssdconnectorlayernumber; i++){
2398     ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
2399       ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2400                                           0.5*fgkSSDConnectorWidth,
2401                                           0.5*ssdConnectorThickness[i],
2402                                           ssdconnectororigin);
2403       ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
2404       ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
2405                                        ssdConnectorMedium[i]);
2406       ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorNiSn);
2407   }
2408   const Int_t kssdconnectornumber = 4;
2409   TGeoTranslation* ssdconnectortrans[kssdconnectornumber];
2410   ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2411                        +  fgkSSDConnectorPosition[0]
2412                        -  fgkSSDConnectorSeparation
2413                        -  1.5*fgkSSDConnectorLength,
2414                           ssdstiffenerseparation+ssdstiffenershape->GetDY()
2415                        -  fgkSSDConnectorPosition[1]
2416                        -  ssdconnectorshape[0]->GetDY(),0.0);
2417   ssdconnectortrans[1] = new TGeoTranslation(
2418                        -  ssdstiffenershape->GetDX()
2419                        +  fgkSSDConnectorPosition[0]
2420                        -  0.5*fgkSSDConnectorLength,
2421                           ssdstiffenerseparation+ssdstiffenershape->GetDY()
2422                        -  fgkSSDConnectorPosition[1]
2423                        -  ssdconnectorshape[0]->GetDY(),0.0);
2424   ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2425                        -  fgkSSDConnectorPosition[0]
2426                        +  fgkSSDConnectorSeparation
2427                        +  1.5*fgkSSDConnectorLength,
2428                           -(ssdstiffenershape->GetDY()
2429                        -  fgkSSDConnectorPosition[1]
2430                        -  ssdconnectorshape[0]->GetDY()),0.0);
2431   ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2432                        -  fgkSSDConnectorPosition[0]
2433                        +  0.5*fgkSSDConnectorLength,
2434                           -(ssdstiffenershape->GetDY()
2435                        -  fgkSSDConnectorPosition[1]
2436                        -  ssdconnectorshape[0]->GetDY()),0.0);
2437   for(Int_t i=0; i<kssdconnectornumber; i++) {
2438     Int_t nlay = kssdconnectorlayernumber - 1;
2439     if (i == 1 || i == 2)
2440       nlay++;
2441     for(Int_t j=0; j<nlay; j++)
2442       ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2443   }
2444 ////////////////////////////
2445 // Capacitor 1812-330 nF
2446 ///////////////////////////
2447 //  Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
2448   TGeoBBox* capacitor1812shape =  new TGeoBBox("Capacitor1812Shape",
2449                                                                                          0.5*fgkSSDCapacitor1812Length,
2450                                                                                          0.5*fgkSSDCapacitor1812Width,
2451                                                0.5*fgkSSDCapacitor1812Height);
2452   //            ssdcapacitor1812origin);
2453   TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2454                                              fSSDStiffener1812CapacitorMedium);
2455   capacitor1812->SetLineColor(fColorAl);
2456   TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2457                                         0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2458                                       - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2459   ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
2460
2461   TGeoBBox* capacitor1812capshape =  new TGeoBBox("Capacitor1812CapShape",
2462     0.5*fgkSSDCapacitor1812CapLength, 0.5*fgkSSDCapacitor1812Width,
2463     0.5*fgkSSDCapacitor1812Height);
2464   TGeoVolume* capacitor1812cap = new TGeoVolume("Capacitor1812Cap",capacitor1812capshape,
2465                                              fSSDStiffenerCapacitorCapMedium);
2466   capacitor1812cap->SetLineColor(fColorNiSn);
2467   TGeoTranslation* capacitor1812captrans1 = new TGeoTranslation(
2468         - capacitor1812shape->GetDX() - capacitor1812capshape->GetDX(),
2469         0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2470         - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2471         0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2472   ssdhybridcapacitormother->AddNode(capacitor1812cap,1,capacitor1812captrans1);
2473   TGeoTranslation* capacitor1812captrans2 = new TGeoTranslation(
2474         capacitor1812shape->GetDX() + capacitor1812capshape->GetDX(),
2475         0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2476         - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2477         0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2478   ssdhybridcapacitormother->AddNode(capacitor1812cap,2,capacitor1812captrans2);
2479
2480 ////////////////////////////
2481 //Hybrid Wire
2482 ////////////////////////////
2483   Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
2484                                  - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2485                                  - fgkSSDConnectorSeparation;
2486   Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
2487                                  - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
2488   Double_t ssdwireradius = TMath::Sqrt(wirex*wirex+wirey*wirey);
2489
2490   Double_t wireangle = TMath::ATan(wirex/wirey);
2491   TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2492                                                 fgkSSDWireRadius, 0.5*ssdwireradius);
2493   TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2494                                              fSSDStiffenerHybridWireMedium);
2495   hybridwire->SetLineColor(fColorPhynox);
2496   TGeoCombiTrans* hybridwirecombitrans[2];
2497   hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
2498                    0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2499                                  + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
2500                    0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
2501                                  + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
2502                                    ssdstiffenershape->GetDZ()
2503                                  + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight+fgkSSDConnectorSnHeight,
2504                    new TGeoRotation("HybridWireRot1",0.,90.,0.));
2505   hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
2506                             0.0,
2507                           - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2508                             0.0,
2509                             new TGeoRotation("HybridWireRot2",
2510                           - wireangle*TMath::RadToDeg(),0.,0.));
2511   TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2512   hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2513   hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
2514   ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2515   ssdhybridlist->Add(ssdhybridcapacitormother);
2516   /////////////////////////////////////////////////////////////
2517   // Deallocating memory
2518   /////////////////////////////////////////////////////////////
2519   delete hybridwirecombitrans[0];
2520   delete hybridwirecombitrans[1];
2521   return ssdhybridlist;
2522   /////////////////////////////////////////////////////////////
2523 }
2524 ///////////////////////////////////////////////////////////////////////////////
2525 TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2526   /////////////////////////////////////////////////////////////
2527   // SSD Cooling Block System
2528   /////////////////////////////////////////////////////////////
2529   // SSD Cooling Block and Cooling Tube Transformations
2530   /////////////////////////////////////////////////////////////
2531   TGeoRotation* localcoolingblockrot = new TGeoRotation();
2532   localcoolingblockrot->SetAngles(0.,90.,0.);
2533   TGeoCombiTrans localcoolingblockmatrix(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
2534   TVector3* coolingblocktransvector;
2535   coolingblocktransvector = new TVector3(fgkCoolingTubeSeparation,
2536                                                                   fgkSSDSensorLength
2537                                                                 - 2.*fgkSSDModuleStiffenerPosition[1]
2538                                          - fgkSSDCoolingBlockWidth, 0);
2539   const Int_t kcoolingblocktransnumber = 2;
2540   const Int_t kcoolingblocknumber = 4;
2541   TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
2542   TGeoRotation* localcoolingtuberot = new TGeoRotation();
2543   localcoolingtuberot->SetAngles(0.0,90.0,0.0);
2544   for(Int_t i=0; i<kcoolingblocktransnumber; i++){
2545     for(Int_t j=0; j<kcoolingblocktransnumber; j++){
2546       TGeoTranslation localcoolingblocktrans(i*coolingblocktransvector->X(),//+2*coolingtubedistance,
2547                                              j*coolingblocktransvector->Y(),
2548                                              - 0.5*(fgkSSDCoolingBlockHoleCenter
2549                                                     + fgkCoolingTubeRmax));
2550       coolingblockmatrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingblockmatrix);
2551     }
2552   }
2553   TGeoVolume* coolingsystemother = new TGeoVolumeAssembly("CoolingBlockSystem");
2554   TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2555   /////////////////////////////////////////////////////////////
2556   // Adding Cooling block to mother volume
2557   /////////////////////////////////////////////////////////////
2558   for(Int_t i=0; i<kcoolingblocknumber; i++){
2559     coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
2560   }
2561   /////////////////////////////////////////////////////////////
2562   // Deallocating memory
2563   /////////////////////////////////////////////////////////////
2564   delete coolingblocktransvector;
2565   delete localcoolingblockrot;
2566
2567   return coolingsystemother;
2568 }
2569 /////////////////////////////////////////////////////////////////////////////////
2570 TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
2571   /////////////////////////////////////////////////////////////
2572   // SSD Flex
2573   /////////////////////////////////////////////////////////////
2574   const Int_t kssdflexlayernumber = 2;
2575   TGeoXtru* ssdflexshape[kssdflexlayernumber];
2576   for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2577   const Int_t kmothervertexnumber = 17;
2578   Double_t xmothervertex[kmothervertexnumber];
2579   Double_t ymothervertex[kmothervertexnumber];
2580   /////////////////////////////////////////////
2581   // Auxiliary variables for vertex positioning
2582   /////////////////////////////////////////////
2583   const Int_t kssdflexboxnumber = 5;
2584   Double_t ssdflexboxlength[kssdflexboxnumber];
2585   ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
2586                                           *     fgkSSDChipLength+(fgkSSDChipNumber-1)
2587                                           *     fgkSSDChipSeparationLength
2588                                           - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2589                                           - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
2590   ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2591   ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
2592                                           -     fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
2593   ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2594   ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2595                                           -     ssdflexboxlength[1];
2596   Double_t ssdflexboxwidth[kssdflexboxnumber];
2597   ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2598   ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2599   ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2600   ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2601   ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
2602   ///////////////////////
2603   // Setting the vertices
2604   ///////////////////////
2605   xmothervertex[0]  = 0.0;
2606   xmothervertex[1]  = xmothervertex[0];
2607   xmothervertex[2]  = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2608   xmothervertex[3]  = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2609                                         + ssdflexboxlength[4];
2610   xmothervertex[4]  = xmothervertex[3];
2611   xmothervertex[5]  = xmothervertex[4]-ssdflexboxlength[4];
2612   xmothervertex[6]  = xmothervertex[5];
2613   xmothervertex[7]  = xmothervertex[6]-fgkSSDFlexHoleLength;
2614   xmothervertex[8]  = xmothervertex[7];
2615   xmothervertex[9]  = xmothervertex[8]-ssdflexboxlength[2];
2616   xmothervertex[10] = xmothervertex[9];
2617   xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2618   xmothervertex[12] = xmothervertex[11];
2619   xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2620   xmothervertex[14] = xmothervertex[13];
2621   xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2622   xmothervertex[16] = xmothervertex[15];
2623   ymothervertex[0]  = 0.0;
2624   ymothervertex[1]  = fgkSSDFlexWidth[1];
2625   ymothervertex[2]  = fgkSSDFlexWidth[0];
2626   ymothervertex[3]  = ymothervertex[2];
2627   ymothervertex[4]  = ymothervertex[0];
2628   ymothervertex[5]  = ymothervertex[4];
2629   ymothervertex[6]  = ssdflexboxwidth[2];
2630   ymothervertex[7]  = ymothervertex[6];
2631   ymothervertex[8]  = ymothervertex[0];
2632   ymothervertex[9]  = ymothervertex[8];
2633   ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2634   ymothervertex[11] = ymothervertex[10];
2635   ymothervertex[12] = ymothervertex[0];
2636   ymothervertex[13] = ymothervertex[12];
2637   ymothervertex[14] = ymothervertex[7];
2638   ymothervertex[15] = ymothervertex[14];
2639   ymothervertex[16] = ymothervertex[0];
2640   /////////////////////////////////////////////////////////////
2641   // First Mother Volume containing SSDFlex
2642   /////////////////////////////////////////////////////////////
2643   TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2644   ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2645                                                                     ymothervertex);
2646   ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2647   ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
2648   TGeoVolumeAssembly* ssdflexmother = new TGeoVolumeAssembly("SSDFlexMother");
2649 //  TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2650 //                                                                                       fSSDAir);
2651   /////////////////////////////////////////////////////////////
2652   // SSDFlex Layer Shapes
2653   /////////////////////////////////////////////////////////////
2654   for(Int_t i=0; i<kssdflexlayernumber; i++){
2655         ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2656                                                                    ymothervertex);
2657     ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2658         ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2659   }
2660   /////////////////////////////////////
2661   // Setting Layers into Mother Volume
2662   /////////////////////////////////////
2663   Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2664   TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2665                                                                                                  fSSDKaptonFlexMedium};
2666   const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2667                                                                                                         "AlFlexLay2","KaptonFlexLay2"};
2668   TGeoVolume* ssdflex[2*kssdflexlayernumber];
2669   TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2670   for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2671         ssdflex[i] = new TGeoVolume(ssdflexname[i],
2672                                                                 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2673                                                                 i%2==0 ? ssdflexmed[0]   : ssdflexmed[1]);
2674         ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2675     ssdflextrans[i]  = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2676                                          +                                         fgkSSDFlexHeight[1]));
2677     ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2678   }
2679   return ssdflexmother;
2680 }
2681 /////////////////////////////////////////////////////////////////////////////////
2682 TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
2683   /////////////////////////////////////////////////////////////
2684   // Method generating SSD End Flex
2685   /////////////////////////////////////////
2686   Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2687                                                         /  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2688   Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2689                                                 * TMath::DegToRad()*ssdflexradiusmax
2690                                                 - fgkSSDFlexLength[2]-TMath::Pi()
2691                                                 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
2692                                                         - 0.1*fgkSSDFlexFullLength;
2693   const Int_t knedges = 20;
2694   const Int_t karcnumber = 2;
2695   TVector3* vertexposition[karcnumber*(knedges+1)];
2696   Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2697   Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2698   Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2699   Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2700                                                                                  - 90.0*TMath::DegToRad()};
2701   TVector3* referencetrans[karcnumber];
2702   referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2703                                         +                          radius[0]*SinD(2.*fgkSSDFlexAngle),
2704                                    radius[0], 0);
2705   referencetrans[1] = new TVector3(referencetrans[0]->X()
2706                                         +              fgkSSDFlexLength[2],
2707                                    -              fgkSSDStiffenerHeight, 0);
2708 for(Int_t i=0; i<karcnumber; i++){
2709         for(Int_t j=0; j<knedges+1; j++){
2710                 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2711                                                          radius[i]*SinD(angle[i]), 0);
2712                 angle[i] +=  deltangle[i]*(1.0-2.0*i);
2713         }
2714   }
2715   ///////////////////////
2716   // Setting the vertices
2717   ///////////////////////
2718   const Int_t kendflexlayernumber = 4;
2719   const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2720   TVector3** vertex[kendflexlayernumber];
2721   for(Int_t i=0; i<kendflexlayernumber; i++)
2722                                         vertex[i] = new TVector3*[kendflexvertexnumber];
2723   TVector3* transvector[kendflexlayernumber+1];
2724   TVector3* deltatransvector = new TVector3();
2725   for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2726   transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2727                                 +                radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2728   for(Int_t i=1; i<kendflexlayernumber+1; i++){
2729         deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2730                                         *                 CosD(fgkSSDFlexAngle),
2731                                                           (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2732                                         *         SinD(fgkSSDFlexAngle),0.0);
2733         *transvector[i] = *transvector[i-1]+*deltatransvector;
2734   }
2735   Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2736   ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2737   for(Int_t i=0; i<karcnumber; i++){
2738         for(Int_t j=1; j<kendflexlayernumber+1; j++){
2739                 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2740                                                   * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2741                                               /radius[i];
2742         }
2743   }
2744   for(Int_t i=0; i<kendflexlayernumber; i++){
2745     vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y(),0);
2746     vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y(),0);
2747         for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2748                 if(j<(knedges+1)){
2749                         vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2750                                                 vertexposition[j]->Y()*ratioradius[0][i+1], 0);
2751                         vertex[i][j+2]->RotateZ(referenceangle[0]);
2752                         *vertex[i][j+2] += *referencetrans[0];
2753                         vertex[i][4*(knedges+1)-j+1] =
2754                                                          new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2755                                  vertexposition[j]->Y()*ratioradius[0][i], 0);
2756                         vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2757                         *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2758                 }
2759                 else{
2760
2761                         vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2762                                                 vertexposition[j]->Y()*ratioradius[1][i+1],0);
2763                         vertex[i][j+2]->RotateZ(referenceangle[1]);
2764                         *vertex[i][j+2] += *referencetrans[1];
2765                         vertex[i][4*(knedges+1)-j+1] =
2766                                                          new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2767                                        vertexposition[j]->Y()*ratioradius[1][i],
2768                                        0);
2769                         vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2770                         *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2771            }
2772         }
2773   }
2774   /////////////////////////////////////////////////////////////
2775   // First Mother Volume containing SSDEndFlex
2776   /////////////////////////////////////////////////////////////
2777   TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2778   Double_t xmothervertex[kendflexvertexnumber];
2779   Double_t ymothervertex[kendflexvertexnumber];
2780   xmothervertex[0] = vertex[0][0]->X();
2781   ymothervertex[0] = vertex[0][0]->Y();
2782   for(Int_t i=1; i<kendflexvertexnumber; i++){
2783         if(i<2*(knedges+1)+2){
2784                 xmothervertex[i] = vertex[3][i]->X();
2785                 ymothervertex[i] = vertex[3][i]->Y();
2786         }
2787         else{
2788                 xmothervertex[i] = vertex[0][i]->X();
2789                 ymothervertex[i] = vertex[0][i]->Y();
2790         }
2791   }
2792   ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2793                                                                            xmothervertex,ymothervertex);
2794   ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2795   ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2796 //  TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2797 //                                                               ssdendflexmothershape,fSSDAir);
2798   TGeoVolumeAssembly* ssdendflexmother = new TGeoVolumeAssembly("SSDEndFlexMother");
2799   //////////////////////////////////////
2800   // End Flex TGeoXtru Layer Definition
2801   //////////////////////////////////////
2802   TGeoXtru* ssdendflexshape[kendflexlayernumber];
2803   TGeoVolume* ssdendflex[kendflexlayernumber];
2804   for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2805   Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2806   Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2807   Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2808   TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2809                                                                                                         fSSDKaptonFlexMedium};
2810   const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2811                                                                                                          "AlEndFlexLay2","KaptonEndFlexLay2"};
2812   for(Int_t i=0; i<kendflexlayernumber; i++){
2813         for(Int_t j=0; j<4*(knedges+1)+2; j++){
2814                 xvertex[i][j] = vertex[i][j]->X();
2815                 yvertex[i][j] = vertex[i][j]->Y();
2816         }
2817   ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2818   ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2819   ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2820   ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2821                                                                  i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2822   ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2823   ssdendflexmother->AddNode(ssdendflex[i],1);
2824   }
2825   /////////////////////////////////////////////////////////////
2826   // Deallocating memory
2827   /////////////////////////////////////////////////////////////
2828   for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2829   for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2830   for(Int_t i=0; i<kendflexlayernumber; i++){
2831         for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2832         delete [] vertex[i];
2833   }
2834   for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2835   delete deltatransvector;
2836   /////////////////////////////////////////////////////////////
2837   //ssdendflexmother->CheckOverlaps(0.01);
2838   return ssdendflexmother;
2839 }
2840 ///////////////////////////////////////////////////////////////////////////////
2841 TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
2842   /////////////////////////////////////////////////////////////
2843   // Method generating the Mounting Block
2844   /////////////////////////////////////////////////////////////
2845   const Int_t kvertexnumber = 8;
2846   Double_t xvertex[kvertexnumber];
2847   Double_t yvertex[kvertexnumber];
2848   xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2849   xvertex[1] = xvertex[0];
2850   xvertex[2] = -xvertex[0];
2851   xvertex[3] = xvertex[2];
2852   xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2853                          -                                 fgkSSDMountingBlockLength[2]);
2854   xvertex[5] = xvertex[4];
2855   xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2856                          - 0.5*fgkSSDMountingBlockScrewHoleEdge
2857                          -     fgkSSDMountingBlockScrewHoleRadius[0];
2858   xvertex[7] = xvertex[6];
2859   yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
2860                          +      fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
2861   yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2862   yvertex[2] = yvertex[1];
2863   yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2864   yvertex[4] = yvertex[3];
2865   yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2866                          - fgkSSDMountingBlockHeight[0];
2867   yvertex[6] = yvertex[5];
2868   yvertex[7] = yvertex[0];
2869
2870   ///////////////////////////////////////////////////////////////////////
2871   // TGeoXTru Volume definition for Mounting Block Part
2872   ///////////////////////////////////////////////////////////////////////
2873   TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2874   ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2875   ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2876   ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
2877   TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
2878                                                                           ssdmountingblockshape,
2879                                                                                   fSSDMountingBlockMedium);
2880   ssdmountingblock->SetLineColor(fColorG10);
2881   TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
2882   mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
2883   TGeoRotation* mountingblockrot = new TGeoRotation();
2884   mountingblockrot->SetAngles(90.,180.,-90.);
2885   mountingblockcombitrans->SetRotation(*mountingblockrot);
2886   /////////////////////////////////////////////////////////////
2887   // Generating the Mounting Block Screw Vertices
2888   /////////////////////////////////////////////////////////////
2889   const Int_t kscrewvertexnumber = 15;
2890   Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
2891                                  -                                      fgkSSDMountingBlockScrewHoleEdge)
2892                                  /                              fgkSSDMountingBlockScrewHoleRadius[0])
2893                                  * TMath::RadToDeg();
2894   Double_t phi0 = 90.+alpha;
2895   Double_t phi = 270.-2*alpha;
2896   Double_t deltaphi = phi/kscrewvertexnumber;
2897   TVector3* screwvertex[kscrewvertexnumber+1];
2898   for(Int_t i=0; i<kscrewvertexnumber+1; i++)
2899         screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
2900                                    *CosD(phi0+i*deltaphi),
2901                                    fgkSSDMountingBlockScrewHoleRadius[0]
2902                                       *SinD(phi0+i*deltaphi), 0);
2903   Double_t xscrewvertex[kscrewvertexnumber+6];
2904   Double_t yscrewvertex[kscrewvertexnumber+6];
2905   xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
2906   yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
2907                                   -               fgkSSDMountingBlockScrewHoleEdge);
2908   xscrewvertex[1] = xscrewvertex[0];
2909   yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2910   xscrewvertex[2] = screwvertex[0]->X();
2911   yscrewvertex[2] = yscrewvertex[1];
2912   for(Int_t i=0; i<kscrewvertexnumber+1; i++){
2913         xscrewvertex[i+3] = screwvertex[i]->X();
2914         yscrewvertex[i+3] = screwvertex[i]->Y();
2915   }
2916   xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2917   yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
2918   xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
2919   yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
2920   TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
2921   ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
2922   ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
2923   ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
2924                                                         +                                  fgkSSDMountingBlockHeight[2]);
2925   TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
2926                                                                                 ssdmountingblockscrewshape,
2927                                                                                             fSSDMountingBlockMedium);
2928   ssdmountingblockscrew->SetLineColor(fColorG10);
2929   TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
2930   for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
2931   ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2932                                                                         -                                yscrewvertex[1],
2933                                                                                                          0.5*fgkSSDMountingBlockHeight[0]
2934                                                                         -                                fgkSSDMountingBlockHeight[2]
2935                                                                         +                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2936                                                                         +                                fgkSSDMountingBlockHeight[2]
2937                                                                         -                                yvertex[0]));
2938   ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2939                                                                                                         -0.5*fgkSSDMountingBlockScrewHoleEdge,
2940                                                                                                                  yscrewvertex[1]
2941                                                                                                         -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2942                                                                                                          +fgkSSDMountingBlockHeight[2]
2943                                                                                                          -yvertex[0]));
2944   ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2945                                                                                                           yscrewvertex[1],
2946                                                                         -                                 0.5*fgkSSDMountingBlockHeight[0]
2947                                                                         +                                 fgkSSDMountingBlockHeight[2]
2948                                                                         -                                 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2949                                                                         +                                 fgkSSDMountingBlockHeight[2]
2950                                                                         -                                 yvertex[0]));
2951   ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2952                                                                                                          yscrewvertex[1],
2953                                                                         -                                yscrewvertex[1]
2954                                                                         +                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2955                                                                         +                                fgkSSDMountingBlockHeight[2]
2956                                                                         -                                yvertex[0]));
2957   TGeoRotation* ssdmountingblockscrewrot[4];
2958   for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
2959         ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
2960     ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
2961     ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
2962   for(Int_t i=1; i<4; i++)
2963         ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
2964   TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
2965   ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
2966   TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
2967   ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
2968                                                          +                                xvertex[0],yscrewvertex[1]
2969                                                          -                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2970                                                          +                                fgkSSDMountingBlockHeight[2]
2971                                                          -                                yvertex[0]),0.);
2972   TGeoHMatrix* ssdmountingblockscrewmatrix[4];
2973   for(Int_t i=0; i<4; i++){
2974         ssdmountingblockscrewmatrix[i] =
2975                 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
2976         ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
2977   }
2978   ///////////////////////////////////////////////////////////////////////
2979   // TGeoXtru for Mother Volume
2980   ///////////////////////////////////////////////////////////////////////
2981   const Int_t kvertexmothernumber = 12;
2982   Double_t xmothervertex[kvertexmothernumber];
2983   Double_t ymothervertex[kvertexmothernumber];
2984   for(Int_t i=0; i<6; i++){
2985         xmothervertex[i] = xvertex[i];
2986         ymothervertex[i] = yvertex[i];
2987   }
2988   xmothervertex[6]  = xvertex[5]+fgkSSDMountingBlockLength[2];
2989   ymothervertex[6]  = ymothervertex[5];
2990   xmothervertex[7]  = xmothervertex[6];
2991   ymothervertex[7]  = ymothervertex[4] - fgkSSDTolerance;
2992   xmothervertex[8]  = xmothervertex[7]
2993                                         + 0.5*(fgkSSDMountingBlockLength[1]
2994                                         -          fgkSSDMountingBlockLength[2]);
2995   ymothervertex[8]  = ymothervertex[7];
2996   xmothervertex[9]  = xmothervertex[8];
2997   ymothervertex[9]  = ymothervertex[2];
2998   xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
2999   ymothervertex[10] = ymothervertex[1];
3000   xmothervertex[11] = xmothervertex[10];
3001   ymothervertex[11] = ymothervertex[0];
3002   TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3003   ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3004   ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3005   ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3006   TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3007                                                                           ssdmountingblockmothershape,
3008                                                                                   fSSDAir);
3009   /////////////////////////////////////////////////////////////
3010   // Placing the Volumes into Mother Volume
3011   /////////////////////////////////////////////////////////////
3012   ssdmountingblockmother->AddNode(ssdmountingblock,1);
3013   ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3014   for(Int_t i=0; i<4; i++)
3015         ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3016                                                                         ssdmountingblockscrewmatrix[i]);
3017   /////////////////////////////////////////////////////////////
3018   // Deallocating memory
3019   /////////////////////////////////////////////////////////////
3020   delete mountingblockrot;
3021   for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3022   delete ssdmountingblockglobalrot;
3023   delete ssdmountingblockglobaltrans;
3024   /////////////////////////////////////////////////////////////
3025   return ssdmountingblockmother;
3026 }
3027 ///////////////////////////////////////////////////////////////////////////////
3028  TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3029   /////////////////////////////////////////////////////////////
3030   // Method generating the Mounting Block Clip
3031   /////////////////////////////////////////////////////////////
3032   const Int_t kmothervertexnumber = 10;
3033   Double_t xmothervertex[kmothervertexnumber];
3034   Double_t ymothervertex[kmothervertexnumber];
3035   xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3036                                    - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3037   xmothervertex[1] = xmothervertex[0];
3038   xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3039                                    - fgkMountingBlockClibScrewRadius);
3040   xmothervertex[3] = xmothervertex[2];
3041   xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3042   xmothervertex[5] = xmothervertex[4];
3043   xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3044   xmothervertex[7] = xmothervertex[6];
3045   xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3046   xmothervertex[9] = xmothervertex[8];
3047   ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
3048                                + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
3049   ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3050   ymothervertex[2] = ymothervertex[1];
3051   ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3052                                    - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3053                                    - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3054   ymothervertex[4] = ymothervertex[3];
3055   ymothervertex[5] = ymothervertex[2];
3056   ymothervertex[6] = ymothervertex[5];
3057   ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3058   ymothervertex[8] = ymothervertex[7];
3059   ymothervertex[9] = ymothervertex[0];
3060
3061   ///////////////////////////////////////////////////////////////////////
3062   // TGeoXTru Volume definition for Mounting Block Clip Part
3063   ///////////////////////////////////////////////////////////////////////
3064   TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3065   ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3066   ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3067   ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3068   TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3069                                                                           ssdmountingblockclipshape,fSSDAir);
3070   ssdmountingblockclip->SetLineColor(4);
3071   ///////////////////////////////////////////////////////////////////////
3072   // TGeoXTru Volume definition for Clip
3073   ///////////////////////////////////////////////////////////////////////
3074   const Int_t kclipvertexnumber = 6;
3075   Double_t xclipvertex[kclipvertexnumber];
3076   Double_t yclipvertex[kclipvertexnumber];
3077   xclipvertex[0] = xmothervertex[0];
3078   xclipvertex[1] = xclipvertex[0];
3079   xclipvertex[2] = xmothervertex[6];
3080   xclipvertex[3] = xclipvertex[2];
3081   xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3082   xclipvertex[5] = xclipvertex[4];
3083   yclipvertex[0] = ymothervertex[0];
3084   yclipvertex[1] = ymothervertex[1];
3085   yclipvertex[2] = yclipvertex[1];
3086   yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3087   yclipvertex[4] = yclipvertex[3];
3088   yclipvertex[5] = yclipvertex[0];
3089   TGeoXtru* clipshape = new TGeoXtru(2);
3090   clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3091   clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3092   clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3093                                                          +   fgkMountingBlockClibWidth);
3094   TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3095   clip->SetLineColor(18);
3096   ///////////////////////////////////////////////////////////////////////
3097   // Ladder Support Piece
3098   ///////////////////////////////////////////////////////////////////////
3099   const Int_t ksupportvertexnumber = 4;
3100   Double_t xsupportvertex[ksupportvertexnumber];
3101   Double_t ysupportvertex[ksupportvertexnumber];
3102   xsupportvertex[0] = xclipvertex[5];
3103   xsupportvertex[1] = xsupportvertex[0];
3104   xsupportvertex[2] = xmothervertex[9];
3105   xsupportvertex[3] = xsupportvertex[2];
3106   ysupportvertex[0] = yclipvertex[0];
3107   ysupportvertex[1] = yclipvertex[3];
3108   ysupportvertex[2] = ysupportvertex[1];
3109   ysupportvertex[3] = ysupportvertex[0];
3110   TGeoXtru* supportshape = new TGeoXtru(2);
3111   supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3112   supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3113   supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3114   TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3115   support->SetLineColor(9);
3116   ///////////////////////////////////////////////////////////////////////
3117   // TGeoXTru Volume definition for Screw
3118   ///////////////////////////////////////////////////////////////////////
3119   Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3120                                                 0.5*fgkMountingBlockClibScrewRadius};
3121   Int_t edgesnumber[2] = {50,6};
3122   Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3123                                                  +0.5*(ymothervertex[3]-ymothervertex[2])};
3124   TGeoShape* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
3125   TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3126   clipscrew->SetLineColor(12);
3127   TGeoRotation* screwrot = new TGeoRotation();
3128   screwrot->SetAngles(0.,90.,0.);
3129   TGeoTranslation* screwtrans = new TGeoTranslation();
3130   screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3131                                                          0.5*(ymothervertex[3]+ymothervertex[2]),
3132                                                          0.5*fgkSSDMountingBlockWidth+
3133                                                         -0.5*fgkMountingBlockSupportWidth[0]);
3134   TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3135   ///////////////////////////////////////////////////////////////////////
3136   // Placing the Volumes
3137   ///////////////////////////////////////////////////////////////////////
3138   ssdmountingblockclip->AddNode(clip,1);
3139   ssdmountingblockclip->AddNode(support,1);
3140   ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3141   /////////////////////////////////////////////////////////////
3142   // Deallocating memory
3143   /////////////////////////////////////////////////////////////
3144   delete screwtrans;
3145   delete screwrot;
3146   /////////////////////////////////////////////////////////////
3147   return ssdmountingblockclip;
3148 }
3149 ///////////////////////////////////////////////////////////////////////////////
3150 void AliITSv11GeometrySSD::CreateCoolingTubes() {
3151   /////////////////////////////////////////////////////////////
3152   // Method generating the Cooling Tube
3153   // sets fcoolingtube and returns list for endladdercoolingtube
3154   /////////////////////////////////////////////////////////////
3155   TGeoTube *coolingtubeshape[2];
3156   // Ladder Cooling Tubes
3157
3158   // MvL: Simplified cooling tubes
3159   coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,0.5*fgkCoolingTubeLength);
3160   coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,coolingtubeshape[0]->GetDz());
3161
3162   // End Ladder Cooling Tubes
3163   TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3164   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3165     endladdercoolingtubeshape[i] = new  TGeoTube*[2];
3166
3167   Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
3168   endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3169                                                  0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0] - sensZshift));
3170   endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3171                                                  endladdercoolingtubeshape[0][0]->GetDz());
3172   endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3173                                                  0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1] + sensZshift));
3174   endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3175                                                  endladdercoolingtubeshape[1][0]->GetDz()-0.5*fgkSSDTolerance);
3176   // Ladder Cooling Tubes
3177   TGeoVolume* coolingtube[2];
3178   coolingtube[0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0], fSSDCoolingTubePhynox);
3179   coolingtube[1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[1], fSSDCoolingTubeWater);
3180   coolingtube[0]->SetLineColor(fColorPhynox);
3181   coolingtube[1]->SetLineColor(fColorWater);
3182
3183   // End Ladder Cooling Tubes
3184   TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3185   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3186     endladdercoolingtube[i] = new TGeoVolume*[2];
3187   endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3188                                               endladdercoolingtubeshape[0][0],
3189                                               fSSDCoolingTubePhynox);
3190   endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3191                                               endladdercoolingtubeshape[0][1],
3192                                               fSSDCoolingTubeWater);
3193   endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3194                                               endladdercoolingtubeshape[1][0],
3195                                               fSSDCoolingTubePhynox);
3196   endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3197                                               endladdercoolingtubeshape[1][1],
3198                                               fSSDCoolingTubeWater);
3199   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3200     endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3201     endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3202   }
3203
3204   /////////////////////////////////////////////////////////////
3205   // Virtual Volume containing Cooling Tubes
3206   /////////////////////////////////////////////////////////////
3207   // Ladder Cooling Tubes
3208   TGeoTube* virtualcoolingtubeshape = new TGeoTube(coolingtubeshape[1]->GetRmin(),
3209                                                    coolingtubeshape[0]->GetRmax(),
3210                                                    coolingtubeshape[0]->GetDz());
3211   fcoolingtube = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape, fSSDAir);
3212   fcoolingtube->AddNode(coolingtube[0],1);
3213   fcoolingtube->AddNode(coolingtube[1],1);
3214
3215   // End Ladder Cooling Tubes
3216   TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3217   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3218     endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3219                                                        endladdercoolingtubeshape[i][0]->GetRmax(),
3220                                                        endladdercoolingtubeshape[i][0]->GetDz());
3221   fendladdercoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3222                                             endladdervirtualcoolingtubeshape[0],
3223                                             fSSDAir);
3224   fendladdercoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3225                                             endladdervirtualcoolingtubeshape[1],
3226                                             fSSDAir);
3227   fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3228   fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3229   fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3230   fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
3231 }
3232 ///////////////////////////////////////////////////////////////////////////////
3233 TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
3234   /////////////////////////////////////////////////////////////
3235   // Method generating SSD Cooling Block
3236   /////////////////////////////////////////////////////////////
3237   const Int_t kvertexnumber = 8;
3238   ///////////////////////////////////////
3239   // Vertex Positioning for TGeoXTru
3240   ///////////////////////////////////////
3241   TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3242   vertexposition[0] = new TVector3(0.0,0.0, 0.);
3243   vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1],0);
3244   vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3245                                    vertexposition[1]->Y(),0);
3246   vertexposition[3] = new TVector3(vertexposition[2]->X(),
3247                                    vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2],0);
3248   vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y(),0);
3249   vertexposition[5] = new TVector3(vertexposition[4]->X(),
3250                                    + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1],0);
3251   vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3252                                           vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3253                                         - fgkSSDCoolingBlockHoleLength[0]
3254                                         - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3255                                           fgkSSDCoolingBlockHeight[0]
3256                                         - fgkSSDCoolingBlockHoleRadius[1],
3257                                                 fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0], 0);
3258   vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3259                                         - fgkSSDCoolingBlockHoleLength[0]),
3260                                    vertexposition[6]->Y(), 0);
3261   Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3262                            / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3263   Double_t phi = 180.-alpha;
3264   Double_t psi = 180.+2.*alpha;
3265   Double_t deltapsi = psi/nedges;
3266   Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3267   TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3268                                        fgkSSDCoolingBlockHoleCenter, 0);
3269   for(Int_t i=0; i<nedges+1; i++){
3270         vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3271                                                    radius*SinD(phi+i*deltapsi),
3272                                                    0);
3273    *vertexposition[kvertexnumber+i] += (*transvector);
3274   }
3275   Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3276   for(Int_t i=0; i<kvertexnumber; i++)
3277     vertexposition[kvertexnumber+nedges+1+i] =
3278                                                 GetReflection(vertexposition[kvertexnumber-1-i],param);
3279   ///////////////////////////////////////////////////////////////////////
3280   // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3281   ///////////////////////////////////////////////////////////////////////
3282   TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3283   Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3284   Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3285   for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3286         xvertexpoints[i] = vertexposition[i]->X();
3287         yvertexpoints[i] = vertexposition[i]->Y();
3288   }
3289   ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3290                                                                                         yvertexpoints);
3291   ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3292   ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3293   TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3294                                                                           ssdcoolingblockshape,
3295                                                                                   fSSDAlCoolBlockMedium);
3296   ssdcoolingblock->SetLineColor(fColorAl);
3297   /////////////////////////////////////////////////////////////
3298   // Deallocating memory
3299   /////////////////////////////////////////////////////////////
3300   delete [] vertexposition;
3301   delete [] xvertexpoints;
3302   delete [] yvertexpoints;
3303   /////////////////////////////////////////////////////////////
3304   return ssdcoolingblock;
3305 }
3306 /////////////////////////////////////////////////////////////////////////////////
3307 void AliITSv11GeometrySSD::GetSSDChipCables(TGeoVolume *&cableL, TGeoVolume *&cableR, Double_t SSDChipCablesHeight, Int_t nedges){
3308   ///////////////////////////////////////////////////////
3309   static const Int_t kssdchipcablesnumber    = 2;  // Number of cables: left and right
3310   static const Int_t kssdchipcableslaynumber = 2;  // Number of layers: Al and Kapton
3311   static const Int_t kvertexnumber                        = 4*(nedges+1)+4;
3312   Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3313   Double_t ssdchipcablesradius[kssdchipcableslaynumber];
3314   ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeight
3315                                                  -  fgkSSDChipCablesHeight[0]
3316                                                  -  fgkSSDChipCablesHeight[1]);
3317   ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3318   Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3319   ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3320                                                           - 2.*TMath::Pi()*ssdchipcablesradius[0]
3321                                                           - ssdchipcablesradius[0]
3322                                                           - fgkSSDChipCablesWidth[1]
3323                                                           - fgkSSDChipCablesWidth[2]);
3324   ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3325                                                           - 0.5*(fgkSSDModuleStiffenerPosition[1]
3326                                                           +      fgkSSDChipCablesHeight[1]
3327                                                           +      fgkSSDSensorHeight);
3328   ///////////////////////////////////////////////////////
3329   // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3330   ///////////////////////////////////////////////////////
3331   TVector3** vertexposition[kssdchipcableslaynumber];
3332   for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3333                                                                                                   new TVector3*[4*(nedges+1)+4];
3334   Double_t ratio[4];
3335   ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3336   ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3337                    /  ssdchipcablesradius[0];
3338   ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3339                    /  ssdchipcablesradius[0];
3340   ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3341                    +  fgkSSDChipCablesHeight[1])
3342                    /  ssdchipcablesradius[0];
3343   Double_t phi = 180.;
3344   Double_t deltaphi = 180./nedges;
3345   Double_t angle = 0.0;
3346
3347   Double_t xvertexpoints[kssdchipcableslaynumber][kvertexnumber];
3348   Double_t yvertexpoints[kssdchipcableslaynumber][kvertexnumber];
3349
3350   TVector3* vertex = new TVector3();
3351   TVector3* transvector[kssdchipcableslaynumber];
3352   transvector[0] = new TVector3(fgkSSDChipWidth,
3353                                 SSDChipCablesHeight-ssdchipcablesradius[0], 0);
3354   transvector[1] = new TVector3();
3355   TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcablesnumber];
3356   TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcablesnumber];
3357   const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcablesnumber] =
3358                 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3359                  "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3360   for(Int_t k=0; k<kssdchipcablesnumber; k++){
3361         transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3362         transvector[1]->SetY(ssdchipcablesradius[0]
3363                                  +               fgkSSDChipCablesHeight[0]
3364                                  +               fgkSSDChipCablesHeight[1]);
3365         for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3366                 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeight
3367                                               - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1], 0);
3368                 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeight
3369                                                     - i*fgkSSDChipCablesHeight[0], 0);
3370                 vertexposition[i][2*(nedges+1)+2] =
3371                                         new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3372                                 +                                fgkSSDChipCablesWidth[1]
3373                                 +                                fgkSSDChipCablesWidth[2],
3374                                                                 ((1.-i)*fgkSSDChipCablesHeight[i]
3375                                 + fgkSSDChipCablesHeight[1]), 0);
3376         vertexposition[i][2*(nedges+1)+3] =
3377                                         new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3378                                                                  vertexposition[i][2*(nedges+1)+2]->Y()
3379                        - fgkSSDChipCablesHeight[i], 0);
3380             for(Int_t j=0; j<nedges+1; j++){
3381                     angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3382                         vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3383                         vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3384                         vertexposition[0][(nedges+1)*i+j+2] =
3385                                                 new TVector3(*vertex+*transvector[i]);
3386                         vertexposition[1][(nedges+1)*i+j+2] =
3387                                                 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3388                                        vertex->Y()*ratio[2*i]+transvector[i]->Y(), 0);
3389                         vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3390                                                 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3391                         vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3392                                                 new TVector3(vertex->X()*ratio[2*i+1]
3393                                                         +                        transvector[i]->X(),
3394                                                                                  vertex->Y()*ratio[2*i+1]
3395                                        + transvector[i]->Y(), 0);
3396                 }
3397         }
3398         for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3399                 for(Int_t j=0; j<kvertexnumber; j++){
3400                         xvertexpoints[i][j] = vertexposition[i][j]->X();
3401                         yvertexpoints[i][j] = vertexposition[i][j]->Y();
3402                 }
3403                 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3404                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3405                                                                                 xvertexpoints[i],yvertexpoints[i]);
3406                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3407                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3408                 ssdchipcable[kssdchipcablesnumber*k+i] =
3409                                 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3410                                                            ssdchipcableshape[kssdchipcablesnumber*k+i],
3411                                                           (kssdchipcablesnumber*k+i)%2==0?
3412                                                            fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3413                 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3414         }
3415         for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3416                 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3417   }
3418   /////////////////////////////////////////////////////////////
3419   // Mother Volume definition
3420   /////////////////////////////////////////////////////////////
3421   static const Int_t kmothervertexnumber = 8;
3422   Double_t xmothervertex[kmothervertexnumber];
3423   Double_t ymothervertex[kmothervertexnumber];
3424   xmothervertex[0] = xvertexpoints[0][1];
3425   ymothervertex[0] = yvertexpoints[0][1];
3426   xmothervertex[1] = xvertexpoints[0][2+nedges/2];
3427   ymothervertex[1] = yvertexpoints[0][1];
3428   xmothervertex[2] = xvertexpoints[0][2+nedges/2];
3429   ymothervertex[2] = yvertexpoints[0][2+nedges];
3430   xmothervertex[3] = xvertexpoints[0][3+nedges];
3431   ymothervertex[3] = yvertexpoints[0][3+nedges];
3432   xmothervertex[4] = xvertexpoints[0][3+2*nedges];
3433   ymothervertex[4] = yvertexpoints[0][3+2*nedges]+fgkSSDTolerance;
3434   xmothervertex[5] = xvertexpoints[0][4+2*nedges];
3435   ymothervertex[5] = yvertexpoints[0][4+2*nedges]+fgkSSDTolerance;
3436   xmothervertex[6] = xvertexpoints[1][5+2*nedges];
3437   ymothervertex[6] = yvertexpoints[1][5+2*nedges];
3438   xmothervertex[7] = xvertexpoints[0][1];
3439   ymothervertex[7] = yvertexpoints[1][5+2*nedges];
3440   TGeoXtru *ssdchipcablemothershape = new TGeoXtru(2);
3441   ssdchipcablemothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3442   ssdchipcablemothershape->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3443   ssdchipcablemothershape->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3444
3445   cableL = new TGeoVolume("SSDChipCableMotherLeft",ssdchipcablemothershape,fSSDAir);
3446   cableR = new TGeoVolume("SSDChipCableMotherRight",ssdchipcablemothershape,fSSDAir);
3447
3448   cableL->AddNode(ssdchipcable[0],1);
3449   cableL->AddNode(ssdchipcable[1],1);
3450   cableR->AddNode(ssdchipcable[2],1);
3451   cableR->AddNode(ssdchipcable[3],1);
3452
3453   /////////////////////////////////////////////////////////////
3454   // Deallocating memory
3455   /////////////////////////////////////////////////////////////
3456   for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3457   for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3458   delete vertex;
3459   /////////////////////////////////////////////////////////////
3460 }
3461 //_____________________________________________________________________________
3462 TGeoVolume* AliITSv11GeometrySSD::GetSSDChip() const{
3463   /////////////////////////////////////////////////////////////
3464   // SSD Chip Assembly Generation
3465   /////////////////////////////////////////////////////////////
3466   TGeoBBox* ssdchipcompshape[2];
3467   ssdchipcompshape[0] =  new TGeoBBox("SSDChipCompShape",
3468                                                                                 0.5*fgkSSDChipLength,
3469                                                                                 0.5*fgkSSDChipWidth,
3470                                                                                 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3471   ssdchipcompshape[1] =  new TGeoBBox("SSDChipGlueCompShape",
3472                                                                                 0.5*fgkSSDChipLength,
3473                                                                                 0.5*fgkSSDChipWidth,
3474                                                                                 0.5*fgkSSDChipGlueHeight);
3475   TGeoVolume* ssdchipcomp[2];
3476   ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3477   ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3478                                                                   fSSDChipGlueMedium);
3479   ssdchipcomp[0]->SetLineColor(fColorSilicon);
3480   ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3481   TGeoTranslation* ssdchipcomptrans[2];
3482   ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3483   ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3484   /////////////////////////////////////////////////////////////
3485   // Virtual Volume containing SSDChip
3486   /////////////////////////////////////////////////////////////
3487   TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3488                                                                                                                  0.5*fgkSSDChipWidth,
3489                                                                                                                  0.5*fgkSSDChipHeight);
3490   TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
3491   /////////////////////////////////////////////////////////////
3492   for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3493   return ssdchip;
3494 }
3495 /////////////////////////////////////////////////////////////////////////////////
3496 TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
3497   /////////////////////////////////////////////////////////////
3498   // Method returning a List containing pointers to Ladder Cable Volumes
3499   //
3500   // Return list contains 3 assemblies: cable box, cable arb shape and the end part of the cable
3501   //                                    each contains 2 volumes, one for polyamide and one for aluminium
3502   /////////////////////////////////////////////////////////////
3503   const Int_t kladdercablesegmentnumber = 2;
3504   /////////////////////////////////////////
3505   // LadderSegmentBBox Volume
3506   /////////////////////////////////////////
3507   static TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber] = {0,0};
3508   const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3509                                 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
3510
3511
3512   const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3513                                                   {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3514   static TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3515
3516   static TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber] = {
3517                                                    new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3518                                                                                            0.5*fgkSSDFlexWidth[0],
3519                                                                                            0.5*fgkSSDLadderCableWidth,
3520                                                                        0.5*fgkSSDLadderCableHeight[0]),
3521                                                    new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3522                                                                                            0.5*fgkSSDFlexWidth[0],
3523                                                                                            0.5*fgkSSDLadderCableWidth,
3524                                                                                            fgkSSDLadderCableHeight[0]
3525                                                                                            +0.5*fgkSSDLadderCableHeight[1])
3526                                                                                    };
3527   static TGeoVolume* laddercablesegmentbboxassembly =                                              new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly") ;
3528   static TGeoVolume* laddercablesegmentarbassembly =
3529                                                    new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3530
3531   static TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3532   static TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3533
3534   if (laddercablesegmentbboxshape[0] == 0) {
3535     // Initialise static shapes and volumes
3536   for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3537                                                   new TGeoBBox(laddercablesegmentbboxshapename[i],
3538                                                                            0.5*fgkSSDFlexWidth[0],
3539                                                                            0.5*fgkSSDLadderCableWidth,
3540                                                                            0.5*fgkSSDLadderCableHeight[i]);
3541
3542   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3543                         laddercablesegmentbbox[i] =
3544                                                   new TGeoVolume(laddercablesegmentbboxname[i],
3545                                                                                  laddercablesegmentbboxshape[i],
3546                                                                                  (i==0?fSSDAlTraceLadderCableMedium:
3547             fSSDKaptonLadderCableMedium));
3548                         laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3549                                                                                                                    fColorPolyhamide);
3550   }
3551
3552   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3553                 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3554                                                                                             laddercablesegmentbboxtrans[i]);
3555 /////////////////////////////////////////
3556 // LadderSegmentArb8 Volume
3557 /////////////////////////////////////////
3558   const Int_t kvertexnumber = 4;
3559   TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3560   for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3561                                                                                                   new TVector3*[kvertexnumber];
3562 //Shape Vertex Positioning
3563   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3564     laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0], 0);
3565         laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3566                                                               i*fgkSSDFlexHeight[0], 0);
3567         laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3568                                                                                    +                         fgkSSDFlexHeight[1]
3569                                                               + i*fgkSSDFlexHeight[0], 0);
3570         laddercablesegmentvertexposition[i][3] =
3571                                                    new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3572                                                                 laddercablesegmentvertexposition[i][2]->Y(), 0);
3573   }
3574   Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3575                                                                             {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
3576   const char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
3577                                         {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
3578
3579   for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3580                                         GetArbShape(laddercablesegmentvertexposition[i],
3581                                                                 laddercablesegmentwidth[i],
3582                                                                 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3583                                                                 laddercablesegmentarbshapename[i]);
3584   const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3585                                                   {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
3586
3587   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3588                          laddercablesegmentarb[i] =
3589                                                    new TGeoVolume(laddercablesegmentarbname[i],
3590                                                                                   laddercablesegmentarbshape[i],
3591                                                                                   (i==0?fSSDAlTraceLadderCableMedium:
3592             fSSDKaptonLadderCableMedium));
3593                          laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3594                                                                                                                    fColorPolyhamide);
3595 }
3596   TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3597   laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3598                                                                                                  90.,90,-90.);
3599   laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3600                                                                                                   0.,90.,0.);
3601   TGeoCombiTrans* laddercablesegmentarbcombitrans =
3602                                                    new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3603                                                            0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3604                                                          + fgkSSDFlexWidth[0],0.,0.,
3605                                                    new TGeoRotation((*laddercablesegmentarbrot[1])
3606                                                      *(*laddercablesegmentarbrot[0])));
3607   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3608   laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3609                                                                                    laddercablesegmentarbcombitrans);
3610   }  // End of static initialisations
3611 /////////////////////////////////////////
3612 // End Ladder Cable Volume
3613 // Note: this part depends explicitly on the length passed as an argument to the function
3614 /////////////////////////////////////////
3615   TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3616   const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3617                                 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3618   for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3619                                                   new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3620                                                                            0.5*ssdendladdercablelength,
3621                                                                            0.5*fgkSSDLadderCableWidth,
3622                                                                            0.5*fgkSSDLadderCableHeight[i]);
3623   const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3624                                                   {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
3625   TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
3626   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3627                         ladderendcablesegmentbbox[i] =
3628                                                   new TGeoVolume(ladderendcablesegmentbboxname[i],
3629                                                                                  ladderendcablesegmentbboxshape[i],
3630                                                                                  (i==0?fSSDAlTraceLadderCableMedium:
3631             fSSDKaptonLadderCableMedium));
3632                         ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3633                                                                                                                    fColorPolyhamide);
3634   }
3635   TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
3636   ladderendcablesegmentbboxtrans[0] =
3637                                                    new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
3638                                                                                            0.5*ssdendladdercablelength,
3639                                                                                            0.5*fgkSSDLadderCableWidth,
3640                                                                                            0.5*fgkSSDLadderCableHeight[0]);
3641   ladderendcablesegmentbboxtrans[1] =
3642                                                    new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
3643                                                                                            0.5*ssdendladdercablelength,
3644                                                                                            0.5*fgkSSDLadderCableWidth,
3645                                                                                            fgkSSDLadderCableHeight[0]
3646                                                                                            +0.5*fgkSSDLadderCableHeight[1]);
3647   TGeoVolume* ladderendcablesegmentbboxassembly =
3648                                                    new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
3649   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3650                 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
3651                                                                                             ladderendcablesegmentbboxtrans[i]);
3652 /////////////////////////////////////////
3653   TList* laddercablesegmentlist = new TList();
3654   laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
3655   laddercablesegmentlist->Add(laddercablesegmentarbassembly);
3656   laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
3657   return laddercablesegmentlist;
3658 }
3659
3660 /////////////////////////////////////////////////////////////////////////////////
3661 TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
3662   /////////////////////////////////////////////////////////////
3663   // Method generating Ladder Cable of given length (n modules + end)
3664   // Called by GetLadderCableAssembly
3665   /////////////////////////////////////////////////////////////
3666   TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
3667   TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
3668   for(Int_t i=0; i<n; i++){
3669          TGeoTranslation* laddercabletrans = new TGeoTranslation(
3670                                                         i*(fgkCarbonFiberJunctionWidth),
3671                                                         fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
3672                                                         i*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
3673     laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
3674     if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
3675
3676   }
3677   TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
3678                                           (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
3679                                                              fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
3680                                                              (n-1)*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
3681   laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
3682   return laddercable;
3683 }
3684 /////////////////////////////////////////////////////////////////////////////////
3685 TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
3686   ///////////////////////////////////////////////////////////////////
3687   // Main method generating Ladder Cable bundles containing n cables
3688   ///////////////////////////////////////////////////////////////////
3689   Double_t totalLength = ssdendladdercablelength+(n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0];
3690   Double_t cableOrig[3] = {0.5*totalLength,1.5*fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1])};
3691   TGeoBBox *laddercableshape = new TGeoBBox(0.5*totalLength,0.5*fgkSSDLadderCableWidth,0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]),cableOrig);
3692   TGeoVolume* laddercable = new TGeoVolume("LadderCableMother", laddercableshape, fSSDAir);
3693   char laddercabletransname[100];
3694   for(Int_t i=0; i<n; i++){
3695     snprintf(laddercabletransname,100,"LadderCableTrans%i",i+1);
3696     laddercable->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
3697                          new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0,0));
3698   }
3699   return laddercable;
3700 }
3701 /////////////////////////////////////////////////////////////////////////////////
3702 TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
3703   /////////////////////////////////////////////////////////////
3704   // Method generating Ladder Cable List Assemblies
3705   // containing two cables bundles, i.e. P+N readout for one endcap
3706   /////////////////////////////////////////////////////////////
3707   const Int_t kladdercableassemblynumber = 2;
3708   TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
3709   TGeoVolume* ladderCable[kladdercableassemblynumber];
3710   char laddercableassemblyname[100];
3711   TList* laddercableassemblylist = new TList();
3712   for(Int_t i=0; i<kladdercableassemblynumber; i++){
3713     snprintf(laddercableassemblyname,100,"LadderCableAssembly%i",i+1);
3714         ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
3715         ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
3716                                          new TGeoCombiTrans((n-1)
3717                                          *       fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
3718                                              2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
3719                                                                                         0.,new TGeoRotation("",180,0.,0.)));
3720         laddercableassemblylist->Add(ladderCable[i]);
3721 }
3722   return laddercableassemblylist;
3723 }
3724 ///////////////////////////////////////////////////////////////////////////////
3725 void AliITSv11GeometrySSD::SetLadderSegment(){
3726   /////////////////////////////////////////////////////////////
3727   // Method Generating Ladder Segment Array
3728   /////////////////////////////////////////////////////////////
3729   fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
3730   fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
3731
3732   /* MvL: tried to create mother volume. Requires changes in all rotations, bc xtru is always along z-axis
3733   TGeoXtru *laddersegmentshape = new TGeoXtru(2);
3734   static const Int_t ntrianglevtx = 3;
3735   Double_t xtrianglevtx[ntrianglevtx]={-0.5*fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength, 0};
3736   Double_t ytrianglevtx[ntrianglevtx]={0, 0, fgkCarbonFiberTriangleLength * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
3737   laddersegmentshape->DefinePolygon(ntrianglevtx,xtrianglevtx,ytrianglevtx);
3738   laddersegmentshape->DefineSection(0,0);
3739   laddersegmentshape->DefineSection(1,fgkCarbonFiberJunctionWidth);  // MVL
3740   fladdersegment[0] = new TGeoVolume("LadderSegment1",laddersegmentshape,fSSDAir);
3741   fladdersegment[1] = new TGeoVolume("LadderSegment2",laddersegmentshape,fSSDAir);
3742   */
3743
3744   if(!fCreateMaterials) CreateMaterials();
3745   if(!fTransformationMatrices) CreateTransformationMatrices();
3746   if(!fBasicObjects) CreateBasicObjects();
3747   for(Int_t i=0; i<fgkladdersegmentnumber; i++){
3748   // Placing Carbon Fiber Support
3749         for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
3750                 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3751                                                                                         fcarbonfibersupportmatrix[j]);
3752                 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3753                                                                                         fcarbonfibersupportmatrix[j]);
3754   }
3755   // Placing Carbon Fiber Junction
3756         for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++) {
3757         fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
3758                                                                    fcarbonfiberjunctionmatrix[j]);
3759   }
3760   // Placing Carbon Fiber Lower Support
3761     for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++) {
3762                 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
3763                                                            fcarbonfiberlowersupportrans[j]);
3764     }
3765   // Placing SSD Sensor Support
3766     for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
3767         fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
3768                                                                      fssdsensorsupport[1][i],
3769                                                            j+1,fssdsensorsupportmatrix[j]);
3770   // Placing SSD Cooling Tube Support
3771         for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
3772                 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3773                                                                    fcoolingtubesupportmatrix[j]);
3774   // Placing SSD Cooling Tube
3775         fladdersegment[i]->AddNode(fcoolingtube,1,fcoolingtubematrix[0]);
3776         fladdersegment[i]->AddNode(fcoolingtube,2,fcoolingtubematrix[1]);
3777   // Placing SSD Hybrid
3778     switch(i){
3779         case 0:
3780                 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
3781                 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3782                 break;
3783     case 1:
3784                 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
3785                 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3786                 break;
3787         }
3788         // Placing Cooling Block System
3789       fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
3790         // Placing SSD Flex
3791       for(Int_t j=0; j<fgkflexnumber; j++){
3792         fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
3793         fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
3794       }
3795    }
3796 }
3797 ///////////////////////////////////////////////////////////////////////////////
3798 void AliITSv11GeometrySSD::SetEndLadderSegment(){
3799   /////////////////////////////////////////////////////////////
3800   // Method Generating End Ladder
3801   /////////////////////////////////////////////////////////////
3802   // End Ladder Carbon Fiber Junction
3803   /////////////////////////////////////////////////////////////
3804   fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
3805   fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
3806   if(!fCreateMaterials) CreateMaterials();
3807   if(!fTransformationMatrices) CreateTransformationMatrices();
3808   if(!fBasicObjects) CreateBasicObjects();
3809   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
3810         for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++)
3811                 fendladdersegment[i]->AddNode(j==2 ?
3812                                                         fendladdercarbonfiberjunction[i][1] :
3813                                                         fendladdercarbonfiberjunction[i][0],
3814                                                         j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
3815   }
3816   /////////////////////////////////////////////////////////////
3817   // End Ladder Carbon Fiber Support
3818   /////////////////////////////////////////////////////////////
3819   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
3820       for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
3821                   fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3822                   fendladdercarbonfibermatrix[i][j]);
3823           fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3824                   fendladdercarbonfibermatrix[i][j]);
3825       }
3826   /////////////////////////////////////////////////////////////
3827   // End Ladder Mounting Block
3828   /////////////////////////////////////////////////////////////
3829   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3830        fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
3831                                      fendladdermountingblockcombitrans[i]);
3832   /////////////////////////////////////////////////////////////
3833   // End Ladder Mounting Block Clip
3834   /////////////////////////////////////////////////////////////
3835   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3836         for(Int_t j=0; j<2; j++)
3837                 fendladdersegment[i]->AddNode(fendladdermountingblockclip,j+1,
3838                                               fendladdermountingblockclipmatrix[i][j]);
3839   /////////////////////////////////////////////////////////////
3840   // End Ladder Lower Supports
3841   /////////////////////////////////////////////////////////////
3842   fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
3843                                 fendladderlowersupptrans[0]);
3844   fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
3845                                 fendladderlowersupptrans[1]);
3846   fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
3847                                 fendladderlowersupptrans[2]);
3848   /////////////////////////////////////////////////////////////
3849   // End Ladder Cooling Tube Support
3850   /////////////////////////////////////////////////////////////
3851   for(Int_t i=0; i<2; i++)
3852         for(Int_t j=0; j<(i==0?4:2); j++)
3853                 fendladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3854                                               fendladdercoolingtubesupportmatrix[i][j]);
3855   /////////////////////////////////////////////////////////////
3856   // End Ladder Cooling Tube Support
3857   /////////////////////////////////////////////////////////////
3858   fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
3859   fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
3860   fendladdersegment[1]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[1][0]);
3861   fendladdersegment[1]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[1][1]);
3862 }
3863 ///////////////////////////////////////////////////////////////////////////////
3864 void AliITSv11GeometrySSD::SetLadder(){
3865   /////////////////////////////////////////////////////////////
3866   // Method Generating Ladder of Layer 5 and 6
3867   /////////////////////////////////////////////////////////////
3868   Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
3869                                                                                                 fgkSSDLay6SensorsNumber};
3870   /////////////////////////////////////////////////////////////////////////////
3871   /// Generating Ladder Mother Volume Containing Ladder
3872   /////////////////////////////////////////////////////////////////////////////
3873   TGeoXtru* laddershape[fgkladdernumber];
3874   for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
3875   const Int_t kmothervertexnumber = 8;
3876   Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
3877   Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
3878   ///////////////////////
3879   // Setting the vertices
3880   ///////////////////////
3881   Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
3882                                                                 * (fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]);
3883   xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
3884   ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
3885   xmothervertex[0][1] = xmothervertex[0][0];
3886   ymothervertex[0][1] = -0.5*fgkCoolingTubeSupportHeight; // 0.0; MvL 20-apr-2010
3887   xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
3888                                                 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
3889   ymothervertex[0][2] = ymothervertex[0][1];
3890   ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
3891   xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
3892   xmothervertex[0][4] = -xmothervertex[0][3];
3893   ymothervertex[0][4] = ymothervertex[0][3];
3894   xmothervertex[0][5] = -xmothervertex[0][2];
3895   ymothervertex[0][5] = ymothervertex[0][2];
3896   xmothervertex[0][6] = -xmothervertex[0][1];
3897   ymothervertex[0][6] = ymothervertex[0][1];
3898   xmothervertex[0][7] = -xmothervertex[0][0];
3899   ymothervertex[0][7] = ymothervertex[0][0];
3900   for(Int_t i=0; i<kmothervertexnumber; i++){
3901         xmothervertex[1][i] = xmothervertex[0][i];
3902         ymothervertex[1][i] = ymothervertex[0][i];
3903   }
3904 ///////////////////////////////////////////////////////////////////////////
3905 // Disalignement Mother Volume corrections 25/08/08
3906 ///////////////////////////////////////////////////////////////////////////
3907   TGeoXtru* leftladdershape1[fgkladdernumber];
3908   TGeoXtru* leftladdershape2[fgkladdernumber];
3909   TGeoXtru* centersensorladdershape[fgkladdernumber];
3910   TGeoXtru* rightladdershape1[fgkladdernumber];
3911   TGeoXtru* rightladdershape2[fgkladdernumber];
3912   for(Int_t i=0; i<fgkladdernumber; i++){
3913     leftladdershape1[i] = new TGeoXtru(2);
3914     leftladdershape2[i] = new TGeoXtru(2);
3915     centersensorladdershape[i] = new TGeoXtru(2);
3916     rightladdershape1[i] = new TGeoXtru(2);
3917     rightladdershape2[i] = new TGeoXtru(2);
3918   }
3919   //////////////////////////////////////
3920   // Setting the names for shapes
3921   //////////////////////////////////////
3922   leftladdershape1[0]->SetName("Lay5Left1LadderSegmentContainer");
3923   leftladdershape2[0]->SetName("Lay5Left2LadderSegmentContainer");
3924   leftladdershape1[1]->SetName("Lay6Left1LadderSegmentContainer");
3925   leftladdershape2[1]->SetName("Lay6Left2LadderSegmentContainer");
3926   centersensorladdershape[0]->SetName("Lay5CenterSensorContainer");
3927   centersensorladdershape[1]->SetName("Lay6CenterSensorContainer");
3928   rightladdershape1[0]->SetName("Lay5Right1LadderSegmentContainer");
3929   rightladdershape2[0]->SetName("Lay5Right2LadderSegmentContainer");
3930   rightladdershape1[1]->SetName("Lay6Right1LadderSegmentContainer");
3931   rightladdershape2[1]->SetName("Lay6Right2LadderSegmentContainer");
3932   //////////////////////////////////////
3933   Double_t xend1laddervertex[fgkladdernumber][kmothervertexnumber];
3934   Double_t yend1laddervertex[fgkladdernumber][kmothervertexnumber];
3935   Double_t xcentersensorvertex[fgkladdernumber][kmothervertexnumber];
3936   Double_t ycentersensorvertex[fgkladdernumber][kmothervertexnumber];
3937   Double_t xend2laddervertex[fgkladdernumber][kmothervertexnumber];
3938   Double_t yend2laddervertex[fgkladdernumber][kmothervertexnumber];
3939   for(Int_t i=0; i<fgkladdernumber; i++) {
3940     for(Int_t j=0; j<kmothervertexnumber; j++){
3941       xcentersensorvertex[i][j] = xmothervertex[i][j];
3942       ycentersensorvertex[i][j] = ymothervertex[i][j];
3943       xend1laddervertex[i][j] = xmothervertex[i][j];
3944       yend1laddervertex[i][j] = ymothervertex[i][j];
3945       xend2laddervertex[i][j] = xmothervertex[i][j];
3946       yend2laddervertex[i][j] = ymothervertex[i][j];
3947     }
3948     // Add some space around sensors to accommodate misalignments
3949     xcentersensorvertex[i][0] -= fgkSSDModuleSideDisalignment;
3950     xcentersensorvertex[i][1] =  xcentersensorvertex[0][0];
3951     xcentersensorvertex[i][6] = -xcentersensorvertex[0][1];
3952     xcentersensorvertex[i][7] = -xcentersensorvertex[0][0];
3953
3954     ycentersensorvertex[i][0] -= fgkSSDModuleVerticalDisalignment;
3955     ycentersensorvertex[i][7] = ycentersensorvertex[0][0];
3956
3957     // Center Ladder Piece
3958     centersensorladdershape[i]->DefinePolygon(kmothervertexnumber,xcentersensorvertex[i],
3959                                               ycentersensorvertex[i]);
3960     centersensorladdershape[i]->DefineSection(0, - fgkEndLadderCarbonFiberLowerJunctionLength[1]
3961                                                  + 1.45*fgkSSDMountingBlockWidth);
3962     centersensorladdershape[i]->DefineSection(1,   ssdlaysensorsnumber[i] * fgkCarbonFiberJunctionWidth
3963                                                  + fgkEndLadderCarbonFiberLowerJunctionLength[0]
3964                                                  - 2.4*fgkSSDMountingBlockWidth);
3965
3966     // Left and Right Ladder Pieces: Mother volumes around ladder mounting areas
3967
3968     // Cuts off first corner (neg x)
3969     xend1laddervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
3970     xend1laddervertex[i][1] = -0.5*fgkSSDMountingBlockLength[0];
3971     // Cuts off last part (pos x)
3972     xend2laddervertex[i][6] = 0.5*fgkSSDMountingBlockLength[0];
3973     xend2laddervertex[i][7] = 0.5*fgkSSDMountingBlockLength[0];
3974
3975     leftladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
3976                                        yend1laddervertex[i]);
3977     leftladdershape1[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
3978     leftladdershape1[i]->DefineSection(1,  fendladdersegmentmatrix[0][i]->GetTranslation()[2]
3979                                          - fgkEndLadderMountingBlockPosition[0]);
3980
3981     leftladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
3982                                        yend2laddervertex[i]);
3983     leftladdershape2[i]->DefineSection(0,  fendladdersegmentmatrix[0][i]->GetTranslation()[2]
3984                                          - fgkEndLadderMountingBlockPosition[0]);
3985     leftladdershape2[i]->DefineSection(1,- fgkEndLadderCarbonFiberLowerJunctionLength[1]
3986                                        + 1.45*fgkSSDMountingBlockWidth);  // connect to main volume at -1.6725 cm
3987
3988     rightladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
3989                                         yend1laddervertex[i]);
3990     rightladdershape1[i]->DefineSection(0,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
3991                                         +fgkEndLadderCarbonFiberLowerJunctionLength[0]
3992                                         -2.4*fgkSSDMountingBlockWidth);
3993     rightladdershape1[i]->DefineSection(1,fendladdersegmentmatrix[1][i]->GetTranslation()[2]
3994                                         + fgkEndLadderMountingBlockPosition[1]);
3995
3996     rightladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
3997                                         yend2laddervertex[i]);
3998     rightladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[1][i]->GetTranslation()[2]
3999                                            + fgkEndLadderMountingBlockPosition[1]);
4000     rightladdershape2[i]->DefineSection(1,  ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4001                                           + fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4002   }
4003   TGeoCompositeShape* laddershapecontainer[2];
4004   laddershapecontainer[0] = new TGeoCompositeShape("Lay5LadderCompositeShape",
4005                                                    "Lay5Left1LadderSegmentContainer+Lay5Left2LadderSegmentContainer"
4006                                                    "+Lay5CenterSensorContainer"
4007                                                    "+Lay5Right1LadderSegmentContainer+Lay5Right2LadderSegmentContainer");
4008   laddershapecontainer[1] = new TGeoCompositeShape("Lay6LadderCompositeShape",
4009                                                    "Lay6Left1LadderSegmentContainer+Lay6Left2LadderSegmentContainer"
4010                                                    "+Lay6CenterSensorContainer"
4011                                                    "+Lay6Right1LadderSegmentContainer+Lay6Right2LadderSegmentContainer");
4012   const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4013   for(Int_t i=0; i<fgkladdernumber; i++){
4014     fladder[i] = new TGeoVolume(laddername[i],laddershapecontainer[i],fSSDAir);
4015     fladder[i]->SetLineColor(4);
4016   }
4017 ///////////////////////////////////////////////////////////////////////////
4018  if(!fCreateMaterials) CreateMaterials();
4019  if(!fTransformationMatrices) CreateTransformationMatrices();
4020  if(!fBasicObjects) CreateBasicObjects();
4021  SetLadderSegment();
4022  SetEndLadderSegment();
4023   for(Int_t i=0; i<fgkladdernumber; i++){
4024         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4025         //////////////////////////
4026         /// Placing Ladder Segment
4027         //////////////////////////
4028                 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4029                                                                      fladdersegment[i==0 ? 1 : 0],
4030                                                                          ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4031         //////////////////////////
4032         /// Placing SSD Sensor
4033         //////////////////////////
4034         if(i==0&&ssdlaysensorsnumber[i]-j-1==13) fSSDSensor5->SetLineColor(kRed);
4035                 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4036                                                         fssdsensormatrix[i][j]);
4037         }
4038         ///////////////////////////////
4039         /// Placing End Ladder Segment
4040         ///////////////////////////////
4041         fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
4042         fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4043    }
4044 /////////////////////////////////////////////////////////////////////////////
4045 /// Placing Ladder Cables
4046 /////////////////////////////////////////////////////////////////////////////
4047   Int_t sidecablenumber[2][2];
4048   sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4049   sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4050   sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4051   sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4052   Double_t carbonfibertomoduleposition[3];
4053   carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4054   carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4055                          fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4056          +               0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4057          -               0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4058          -            fgkSSDSensorCenterSupportThickness[0]);
4059   carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4060                                                                  +   0.5*fgkCoolingTubeSupportHeight
4061          -         fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4062   const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
4063   Double_t ssdendladdercablelength[4];
4064   ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
4065                                                          + fgkSSDSensorLength
4066                                                          - fgkSSDModuleStiffenerPosition[1]
4067                                                          - fgkSSDStiffenerWidth
4068                                                          - fgkSSDFlexWidth[0]
4069                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
4070   ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
4071                                                          + fgkSSDModuleStiffenerPosition[1]
4072                                                          + fgkSSDStiffenerWidth
4073                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
4074   ssdendladdercablelength[2] = ssdendladdercablelength[1]
4075                                                          - fgkEndLadderCarbonFiberLowerJunctionLength[1]
4076                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4077                                                          - kendladdercablecorrection;
4078   ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4079                                                          + carbonfibertomoduleposition[1]
4080                                                          - fgkSSDModuleStiffenerPosition[1]
4081                                                          - fgkSSDStiffenerWidth)
4082                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
4083
4084   TList* laddercableassemblylist[4];
4085   const Int_t kendladdercablesnumber = 4;
4086   TGeoRotation *laddercablerot = new TGeoRotation();
4087   laddercablerot->SetAngles(90.,60.,-90.);
4088   for(Int_t i=0; i<fgkladdercablesnumber; i++)
4089         for(Int_t j=0; j<kendladdercablesnumber; j++){
4090                 laddercableassemblylist[j] =
4091                 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4092                                                                    ssdendladdercablelength[j]);
4093                         fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4094                                                                         j<2?1:2,fladdercablematrix[i][j]);
4095   }
4096 }
4097 ////////////////////////////////////////////////////////////////////////////////
4098 void AliITSv11GeometrySSD::SetLayer(){
4099 ////////////////////////////////////////////////////////////////////////////////
4100   // Creating Ladder of Layer 5 and Layer 6
4101   /////////////////////////////////////////////////////////////
4102   if(!fCreateMaterials) CreateMaterials();
4103   if(!fTransformationMatrices) CreateTransformationMatrices();
4104   if(!fBasicObjects) CreateBasicObjects();
4105   SetLadder(); // Generating the ladder of Layer5 and Layer6
4106   const Int_t kssdlayladdernumber[fgklayernumber] =
4107                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4108   /////////////////////////////////////////////////////////////
4109   // Generating mother volumes for Layer5 and Layer6
4110   /////////////////////////////////////////////////////////////
4111   fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
4112   fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
4113   Int_t *ladderindex[fgklayernumber];
4114   Int_t index[fgklayernumber] = {8,9};
4115   for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4116   for(Int_t i=0; i<fgklayernumber; i++)
4117         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4118                 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4119                                                           j+index[i] : j+index[i]-kssdlayladdernumber[i];
4120                 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4121                         fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4122         }
4123   /////////////////////////////////////////////////////////////
4124   // Deallocating memory
4125   /////////////////////////////////////////////////////////////
4126   for(Int_t i=0; i<fgklayernumber; i++) delete [] ladderindex[i];
4127 }
4128 ////////////////////////////////////////////////////////////////////////////////
4129 void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
4130   /////////////////////////////////////////////////////////////
4131   // Insert the layer 5 in the mother volume.
4132   /////////////////////////////////////////////////////////////
4133   if (! moth) {
4134     AliError("Can't insert layer5, mother is null!\n");
4135     return;
4136   };
4137   if(!fSSDLayer5) SetLayer();
4138   fMotherVol = moth;
4139   TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4140                                                                                 + fgkLay5CenterITSPosition);
4141   moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
4142  }
4143 ////////////////////////////////////////////////////////////////////////////////
4144 void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
4145   /////////////////////////////////////////////////////////////
4146   // Insert the layer 6 in the mother volume.
4147   /////////////////////////////////////////////////////////////
4148   if (! moth) {
4149     AliError("AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
4150     return;
4151   };
4152   if(!fSSDLayer6) SetLayer();
4153   fMotherVol = moth;
4154   TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4155                                                                                 + fgkLay6CenterITSPosition);
4156   moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
4157  }
4158  ////////////////////////////////////////////////////////////////////////////////
4159  TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4160   /////////////////////////////////////////////////////////////
4161   // Method generating the Arc structure of Ladder Support
4162   /////////////////////////////////////////////////////////////
4163   const Int_t kssdlayladdernumber[fgklayernumber] =
4164                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4165   Double_t mountingsupportedge[fgklayernumber];
4166   Double_t mountingblockratio[fgklayernumber];
4167   Double_t theta[fgklayernumber];
4168   Double_t phi[fgklayernumber];
4169   Double_t psi0[fgklayernumber];
4170   Double_t deltapsi[fgklayernumber];
4171   TVector3* mountingsupportedgevector[fgklayernumber];
4172   for(Int_t i=0; i<fgklayernumber; i++){
4173         mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4174     mountingsupportedge[i]    = 0.5*fgkMountingBlockSupportRadius[i]
4175                                                           * (TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
4176                                                           * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4177                                                           - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4178                                                           / kssdlayladdernumber[i])));
4179     theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4180     phi[i]   = TMath::ASin(0.5*mountingblockratio[i]);
4181         mountingsupportedgevector[i] = new TVector3();
4182         mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4183         mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(
4184                                                         (1.-mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])*
4185                                                         (1.+mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])));
4186     psi0[i] = 0.5*TMath::Pi()-phi[i];
4187     deltapsi[i] = (theta[i]+phi[i])/nedges;
4188   }
4189   TVector3** vertex[fgklayernumber];
4190   TList* vertexlist[fgklayernumber];
4191   Int_t indexedge[fgklayernumber] = {0,0};
4192   for(Int_t i=0; i<fgklayernumber; i++){
4193         vertex[i] = new TVector3*[nedges+1];
4194         vertexlist[i] = new TList();
4195   }
4196   for(Int_t i=0; i<fgklayernumber; i++){
4197         for(Int_t j=0; j<nedges+1; j++){
4198                 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
4199                                             fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]), 0);
4200                 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4201                 vertexlist[i]->Add(vertex[i][j]);
4202         }
4203         vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4204   }
4205   Double_t** xsidevertex = new Double_t*[fgklayernumber];
4206   Double_t** ysidevertex = new Double_t*[fgklayernumber];
4207   Double_t** xcentervertex = new Double_t*[fgklayernumber];
4208   Double_t** ycentervertex = new Double_t*[fgklayernumber];
4209   Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4210   Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4211   Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4212   Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4213   for(Int_t i=0; i<fgklayernumber; i++){
4214     xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4215     ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4216     xcentervertex[i] = new Double_t[indexedge[i]+3];
4217     ycentervertex[i] = new Double_t[indexedge[i]+3];
4218         xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4219         ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4220         xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4221         ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4222         for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4223                 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4224                                                                                 ((TVector3*)vertexlist[i]->At(j))->X();
4225                 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4226                                                                                 ((TVector3*)vertexlist[i]->At(j))->Y();
4227                 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4228                 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4229                 if(j<indexedge[i]+1){
4230                         xcentervertex[i][j!=indexedge[i]?j+3:0] =
4231                                                                                 ((TVector3*)vertexlist[i]->At(j))->X();
4232                         ycentervertex[i][j!=indexedge[i]?j+3:0] =
4233                                                                                 ((TVector3*)vertexlist[i]->At(j))->Y();
4234                         xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4235                         ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4236                 }
4237         }
4238         xsidevertex[i][1] = xsidevertex[i][0];
4239         ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4240         xsidevertex[i][2] = xsidevertex[i][3];
4241         ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4242         xcentervertex[i][1] = xcentervertex[i][0];
4243         ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4244         xcentervertex[i][2] = xcentervertex[i][3];
4245         ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4246         xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4247         ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4248         xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4249         ycenterlowervertex[i][0] = ysidevertex[i][0];
4250         xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4251         ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4252   }
4253   /////////////////////////////////////////////////////////////
4254   // Building the Arc Structure of Ladder Supports
4255   /////////////////////////////////////////////////////////////
4256   TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4257   TGeoXtru* centermountingsupportshape[fgklayernumber];
4258   TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4259   TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4260   TGeoVolume* sidemountingblocksupport[fgklayernumber];
4261   TGeoVolume* centermountingblocksupport[fgklayernumber];
4262   TGeoVolume* sideladdersupportpiece[fgklayernumber];
4263   TGeoVolume* centerladdersupportpiece[fgklayernumber];
4264   char sidemountingblockname[100];
4265   char centermountingblockname[100];
4266   char sideladdersupportpiecename[100];
4267   char centerladdersupportpiecename[100];
4268   for(Int_t i=0; i<fgklayernumber; i++){
4269     snprintf(sidemountingblockname,100,"MountingBlockSupportSideLay%dArc",i+5);
4270     snprintf(centermountingblockname,100,"MountingBlockSupportCenterLay%dArc",i+5);
4271     snprintf(sideladdersupportpiecename,100,"SideLadderSupportPieceLay%d",i+5);
4272     snprintf(centerladdersupportpiecename,100,"CenterLadderSupportPieceLay%d",i+5);
4273     sidemountingblocksupportshape[i] = new TGeoXtru(2);
4274     sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4275                                                                                                 xsidevertex[i],ysidevertex[i]);
4276     sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4277                                                                                                          -fgkMountingBlockSupportWidth[0]);
4278     sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4279     sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4280                                                                           sidemountingblocksupportshape[i],
4281                                                                                   fSSDAlCoolBlockMedium);
4282         sidemountingblocksupport[i]->SetLineColor(9);
4283         centermountingsupportshape[i] = new TGeoXtru(2);
4284     centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4285                                                                                                 xcentervertex[i],ycentervertex[i]);
4286         centermountingsupportshape[i]->DefineSection(0,0.);
4287     centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4288                                                                                                   -fgkMountingBlockSupportWidth[0]);
4289
4290     centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4291                                                                           centermountingsupportshape[i],
4292                                                                                   fSSDAlCoolBlockMedium);
4293         centermountingblocksupport[i]->SetLineColor(9);
4294         sideladdersupportpieceshape[i] = new TGeoXtru(2);
4295     sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4296                                                                                                 xsidelowervertex[i],ysidelowervertex[i]);
4297         sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4298                                                                                                          -fgkMountingBlockSupportWidth[0]);
4299     sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4300     sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4301                                                                           sideladdersupportpieceshape[i],
4302                                                                                   fSSDCarbonFiberMedium);
4303         sideladdersupportpiece[i]->SetLineColor(fColorAl);
4304         centerladdersupportpieceshape[i] = new TGeoXtru(2);
4305     centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4306                                                                                                 xcenterlowervertex[i],ycenterlowervertex[i]);
4307         centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4308     centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4309                                                                                                   -fgkMountingBlockSupportWidth[0]);
4310     centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4311                                                                           centerladdersupportpieceshape[i],
4312                                                                                   fSSDCarbonFiberMedium);
4313         centerladdersupportpiece[i]->SetLineColor(fColorAl);
4314   }
4315   /////////////////////////////////////////////////////////////
4316   // Building the Up Structure of Ladder Supports
4317   /////////////////////////////////////////////////////////////
4318   TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4319   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4320   TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4321   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4322   TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4323   //////////////////////////////////////////////////////////
4324   // Setting the volume for TGeoXtru Mounting Block Piece
4325   //////////////////////////////////////////////////////////
4326   TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4327   TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4328   TGeoVolume* mountingblockpiecedown[fgklayernumber];
4329   TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4330   TGeoVolume* mountingblockpieceup[fgklayernumber];
4331   Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4332   Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4333   Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4334   Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
4335   char mountingblockpiecedownname[100];
4336   char mountingblockpieceupname[100];
4337   for(Int_t i=0; i<fgklayernumber; i++){
4338     ///////////////////////////
4339     // Mounting Block Down Vertex
4340     ///////////////////////////
4341         mountingblockpiecedownshape[i] = new TGeoXtru(2);
4342         snprintf(mountingblockpiecedownname,100,"MountingBlockPieceDownLay%d",i+5);
4343         mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4344         mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4345                                               + fgkMountingBlockSupportDownHeight
4346                                               - fgkSSDLadderVerticalDisalignment;
4347         mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4348         mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4349                                                                                 + fgkSSDMountingBlockHeight[1]
4350                                                                                 - 0.5*fgkCoolingTubeSupportHeight
4351                                                                                 - fgkSSDModuleCoolingBlockToSensor;
4352         mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4353         mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4354         mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4355         mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4356         mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4357         mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4358         mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4359         mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4360                                                                                 + fgkSSDMountingBlockHeight[2]
4361                                                                                 - fgkSSDMountingBlockHeight[0];
4362         mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4363         mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4364         mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4365         mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4366         mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4367                                                                                                          mountingblockpiecedownyvertex[i]);
4368         mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4369         mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4370         mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
4371                                                                  mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
4372         mountingblockpiecedown[i]->SetLineColor(fColorG10);
4373
4374     ///////////////////////////
4375     // Mounting Block Up Vertex
4376     ///////////////////////////
4377         mountingblockpieceupshape[i] = new TGeoXtru(2);
4378         snprintf(mountingblockpieceupname,100,"MountingBlockPieceUpLay%d",i+5);
4379         mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4380         mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4381                                                                                 + fgkMountingBlockSupportUpHeight[i]
4382                                               - fgkSSDLadderVerticalDisalignment;
4383         mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4384         mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4385                                                                                 + fgkSSDMountingBlockHeight[1]
4386                                                                                 - 0.5*fgkCoolingTubeSupportHeight
4387                                                                                 - fgkSSDModuleCoolingBlockToSensor;
4388         mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4389         mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4390         mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4391         mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4392         mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4393         mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4394         mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4395         mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4396                                                                                 + fgkSSDMountingBlockHeight[2]
4397                                                                                 - fgkSSDMountingBlockHeight[0];
4398         mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4399         mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4400         mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4401         mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
4402
4403         mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4404                                                                                                          mountingblockpieceupyvertex[i]);
4405         mountingblockpieceupshape[i]->DefineSection(0,0.0);
4406         mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4407         mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
4408                                                                 mountingblockpieceupshape[i],fSSDMountingBlockMedium);
4409         mountingblockpieceup[i]->SetLineColor(fColorG10);
4410  }
4411   ///////////////////////////////////////////////////////////////////
4412   // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4413   ///////////////////////////////////////////////////////////////////
4414   TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4415   TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4416   TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4417   TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4418   Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4419   Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4420   Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4421   Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
4422   char mountingblocksupportrapezoidowname[100];
4423   char mountingblocksupportrapezoidupname[100];
4424   Double_t scalefactor = 3./4.;
4425   for(Int_t i=0; i<fgklayernumber; i++){
4426   ////////////////////////////////////////////
4427   // Mounting Block Support Down Trapezoid Vertex
4428   ////////////////////////////////////////////
4429         mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4430         mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4431                                                                                                  - mountingsupportedge[i];
4432         mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4433         mountingblocksupportrapezoidownxvertex[i][1] =
4434                                                                                 mountingblocksupportrapezoidownxvertex[i][0];
4435         mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4436                                                                                                  + scalefactor*(mountingblockpiecedownyvertex[i][1]
4437                                                                                              - mountingblockpiecedownyvertex[i][0]);
4438         mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4439         mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4440         mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4441         mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4442         mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4443         mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
4444
4445         mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4446                                                                                                                mountingblocksupportrapezoidownyvertex[i]);
4447         mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4448                                                                                                                         -fgkMountingBlockSupportWidth[0]);
4449         mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4450         snprintf(mountingblocksupportrapezoidowname,100,"MountingBlockSuppTrapezoidDownLay%d",i+5);
4451         mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
4452                                                                 mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
4453         mountingblocksupportrapezoidown[i]->SetLineColor(9);
4454   ////////////////////////////////////////////
4455   // Mounting Block Support Up Trapezoid Vertex
4456   ////////////////////////////////////////////
4457         mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4458         mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4459                                                                                                  - mountingsupportedge[i];
4460         mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4461         mountingblocksupportrapezoidupxvertex[i][1] =
4462                                                                                 mountingblocksupportrapezoidupxvertex[i][0];
4463         mountingblocksupportrapezoidupyvertex[i][1] =
4464                                                                                                mountingblockpieceupyvertex[i][0]
4465                                                                                                  + scalefactor*(mountingblockpieceupyvertex[i][1]
4466                                                                                              - mountingblockpieceupyvertex[i][0]);
4467         mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4468         mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4469         mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4470         mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4471         mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4472         mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
4473
4474         mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4475                                                                                                                mountingblocksupportrapezoidupyvertex[i]);
4476         mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4477                                                                                                                         -fgkMountingBlockSupportWidth[0]);
4478         mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4479         snprintf(mountingblocksupportrapezoidupname,100,"MountingBlockSuppTrapezoidUpLay%d",i+5);
4480         mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
4481                                                                 mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
4482         mountingblocksupportrapezoidup[i]->SetLineColor(9);
4483   }
4484   ///////////////////////////////////////////////////////////////////
4485   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4486   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4487   Double_t boxoriginup[fgklayernumber][2][3];
4488   Double_t boxorigindown[fgklayernumber][2][3];
4489   char mountingblocksupportboxdownname[100];
4490   char mountingblocksupportboxupname[100];
4491   TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4492   mountingblocksupportrot->SetAngles(90.,180.,-90);
4493   TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4494   globalrefladdersupportrot->SetAngles(0.,90.,0.);
4495   TGeoHMatrix* laddersupportmatrix[2];
4496   laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4497   laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4498   /////////////////////////////////////////////////////////////
4499   // Creating Mother Volume for Containment
4500   /////////////////////////////////////////////////////////////
4501   Double_t *xmothervertex[fgklayernumber];
4502   Double_t *ymothervertex[fgklayernumber];
4503   for(Int_t i=0; i<fgklayernumber; i++){
4504         xmothervertex[i] = new Double_t[8];
4505         ymothervertex[i] = new Double_t[8];
4506   }
4507   TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4508   TGeoVolume* downmotherladdersupport[fgklayernumber];
4509   TGeoXtru* upmotherladdersupportshape[fgklayernumber];
4510   TGeoVolume* upmotherladdersupport[fgklayernumber];
4511   char upmotheladdersupportname[100];
4512   char downmotheladdersupportname[100];
4513   for(Int_t i=0; i<fgklayernumber; i++){
4514         xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4515                                                     -  mountingsupportedge[i];
4516         ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4517         xmothervertex[i][1] = xmothervertex[i][0];
4518         ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4519                                                         + fgkMountingBlockSupportWidth[0];
4520         xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4521         ymothervertex[i][2] = ymothervertex[i][1];
4522         xmothervertex[i][3] = xmothervertex[i][2];
4523         ymothervertex[i][3] = -ymothervertex[i][0];
4524         xmothervertex[i][4] = -xmothervertex[i][0];
4525         ymothervertex[i][4] = ymothervertex[i][3];
4526         xmothervertex[i][5] = xmothervertex[i][4];
4527         ymothervertex[i][5] = -ymothervertex[i][1];
4528         xmothervertex[i][6] = -xmothervertex[i][2];
4529         ymothervertex[i][6] = ymothervertex[i][5];
4530         xmothervertex[i][7] = xmothervertex[i][6];
4531         ymothervertex[i][7] = ymothervertex[i][0];
4532
4533         snprintf(downmotheladdersupportname,100,"LadderSupportDownLay%d",i+5);
4534         snprintf(upmotheladdersupportname,100,"LadderSupportUpLay%d",i+5);
4535
4536         downmotherladdersupportshape[i] = new TGeoXtru(2);
4537         downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4538         downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4539         downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4540                                                                    +                       fgkMountingBlockSupportDownHeight
4541                                                                    +                       fgkSSDMountingBlockHeight[1]
4542                                                                    -                       0.5*fgkCoolingTubeSupportHeight
4543                                                                    -                       fgkSSDModuleCoolingBlockToSensor
4544                                                        - fgkSSDLadderVerticalDisalignment);
4545
4546 //                                                 - fgkSSDModuleVerticalDisalignment);
4547         //downmotherladdersupport[i] = new TGeoVolumeAssembly(downmotheladdersupportname);
4548
4549         downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4550                                                                           downmotherladdersupportshape[i],fSSDAir);
4551     upmotherladdersupportshape[i] = new TGeoXtru(2);
4552         upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4553         upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4554     upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4555                                                                    +                       fgkMountingBlockSupportUpHeight[i]
4556                                                                    +                       fgkSSDMountingBlockHeight[1]
4557                                                                    -                       0.5*fgkCoolingTubeSupportHeight
4558                                                                    -                       fgkSSDModuleCoolingBlockToSensor
4559                                                  - fgkSSDLadderVerticalDisalignment);
4560
4561      upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4562                                                                                           upmotherladdersupportshape[i],fSSDAir);
4563   }
4564   for(Int_t i=0; i<fgklayernumber; i++){
4565         /////////////////////////
4566         // Setting the box origin
4567         /////////////////////////
4568         boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4569         boxorigindown[i][0][1] =  fgkMountingBlockSupportRadius[i]
4570                                                    +  0.5*fgkMountingBlockSupportDownHeight
4571                                   - 0.5*fgkSSDLadderVerticalDisalignment;
4572         boxorigindown[i][0][2] =  fgkMountingBlockSupportWidth[1]
4573                                                    -  0.5*fgkMountingBlockSupportWidth[0];
4574
4575         boxorigindown[i][1][0] = 0.0;
4576         boxorigindown[i][1][1] = boxorigindown[i][0][1];
4577         boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4578                                                    -      fgkMountingBlockSupportWidth[0]);
4579
4580         boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4581         boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
4582                                + 0.5*fgkMountingBlockSupportUpHeight[i]
4583                                - 0.5*fgkSSDLadderVerticalDisalignment;
4584         boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4585                                                  - 0.5*fgkMountingBlockSupportWidth[0];
4586
4587         boxoriginup[i][1][0] = 0.0;
4588         boxoriginup[i][1][1] = boxoriginup[i][0][1];
4589         boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4590                                                  - fgkMountingBlockSupportWidth[0]);
4591
4592         /////////////////////////
4593     // Setting the boxes
4594         /////////////////////////
4595         mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4596                                                                                  +  fgkSSDMountingBlockLength[0]),
4597                                                                                         0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
4598                                                                                         0.5*fgkMountingBlockSupportWidth[0],
4599                                                                                         boxorigindown[i][0]);
4600         mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4601                                                                                         0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
4602                                                                                         0.5*(fgkMountingBlockSupportWidth[1]
4603                                                                                  -  fgkMountingBlockSupportWidth[0]),
4604                                                                                         boxorigindown[i][1]);
4605
4606         mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4607                                                                                  +  fgkSSDMountingBlockLength[0]),
4608                                                                                         0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
4609                                                                                         0.5*fgkMountingBlockSupportWidth[0],
4610                                                                                         boxoriginup[i][0]);
4611
4612         mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4613                                                                                         0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
4614                                                                                         0.5*(fgkMountingBlockSupportWidth[1]
4615                                                                      -  fgkMountingBlockSupportWidth[0]),
4616                                                                                         boxoriginup[i][1]);
4617         ///////////////////////////////////////
4618         // Adding the Volumes to Mother Volume
4619         ///////////////////////////////////////
4620         for(Int_t j=0; j<2; j++){
4621           snprintf(mountingblocksupportboxdownname,100,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4622           snprintf(mountingblocksupportboxupname,100,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4623           mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4624                                                              mountingblocksupportboxdownshape[i][j],
4625                                                              fSSDCarbonFiberMedium);
4626           mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4627                                                            mountingblocksupportboxupshape[i][j],
4628                                                            fSSDCarbonFiberMedium);
4629                 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4630                 mountingblocksupportboxup[i][j]->SetLineColor(9);
4631                 for(Int_t k=0; k<2; k++){
4632                         downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
4633                         upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
4634                 }
4635         }
4636         for(Int_t k=0; k<2; k++){
4637                 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4638                 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4639                 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4640                 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4641                 downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
4642                 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4643                 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4644                 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4645                 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4646                 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4647                 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4648                 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
4649         }
4650   }
4651   TList* laddersupportlist = new TList();
4652   laddersupportlist->Add(downmotherladdersupport[0]);
4653   laddersupportlist->Add(upmotherladdersupport[0]);
4654   laddersupportlist->Add(downmotherladdersupport[1]);
4655   laddersupportlist->Add(upmotherladdersupport[1]);
4656   /////////////////////////////////////////////////////////////
4657   // Deallocating memory
4658   /////////////////////////////////////////////////////////////
4659   for(Int_t i=0; i<fgklayernumber; i++){
4660         for(Int_t j=0; j<nedges+1; j++)
4661                 delete vertex[i][j];
4662         delete mountingsupportedgevector[i];
4663         delete [] vertex[i];
4664         delete vertexlist[i];
4665         delete [] xsidevertex[i];
4666         delete [] ysidevertex[i];
4667         delete [] xcentervertex[i];
4668         delete [] ycentervertex[i];
4669         delete [] xsidelowervertex[i];
4670         delete [] ysidelowervertex[i];
4671         delete [] xcenterlowervertex[i];
4672         delete [] ycenterlowervertex[i];
4673         delete [] xmothervertex[i];
4674         delete [] ymothervertex[i];
4675   }
4676   delete [] xsidevertex;
4677   delete [] ysidevertex;
4678   delete [] xcentervertex;
4679   delete [] ycentervertex;
4680   delete [] xsidelowervertex;
4681   delete [] ysidelowervertex;
4682   delete [] xcenterlowervertex;
4683   delete [] ycenterlowervertex;
4684   delete globalrefladdersupportrot;
4685   delete mountingblocksupportrot;
4686   /////////////////////
4687   return laddersupportlist;
4688 }
4689  ////////////////////////////////////////////////////////////////////////////////
4690 void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4691 //////////////////////////////////////////
4692 // Method Generating Ladder Support Ring
4693 //////////////////////////////////////////
4694   if(!fCreateMaterials) CreateMaterials();
4695   if(!fTransformationMatrices) CreateTransformationMatrices();
4696   if(!fBasicObjects) CreateBasicObjects();
4697   fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4698   fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4699     const Int_t kssdlayladdernumber[fgklayernumber] =
4700                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4701   Double_t mountingsupportedge[fgklayernumber];
4702   Double_t mountingblockratio[fgklayernumber];
4703   Double_t theta[fgklayernumber];
4704   Double_t phi[fgklayernumber];
4705   for(Int_t i=0; i<fgklayernumber; i++){
4706         mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4707     mountingsupportedge[i]    = 0.5*fgkMountingBlockSupportRadius[i]
4708                                                           *(TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
4709                                                           * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4710                                                           - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4711                                                           / kssdlayladdernumber[i])));
4712     theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4713                          / fgkMountingBlockSupportRadius[i]);
4714     phi[i]   = TMath::ASin(0.5*mountingblockratio[i]);
4715   }
4716   TGeoRotation* globalrot = new TGeoRotation();
4717   globalrot->SetAngles(0.,-90.,0.);
4718   TGeoRotation** laddersupportrot[fgklayernumber];
4719   TGeoHMatrix**  laddersupportmatrix[fgklayernumber];
4720   for(Int_t i=0; i<fgklayernumber; i++){
4721         laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
4722         laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
4723         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4724                 laddersupportrot[i][j] = new TGeoRotation();
4725                 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
4726                 switch(i){
4727                         case 0: //Ladder of Layer5
4728                                 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4729                                 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
4730                                                                             laddersupportmatrix[i][j]);
4731                         break;
4732                         case 1: //Ladder of Layer6
4733                                 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4734                                 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
4735                                                                               laddersupportmatrix[i][j]);
4736                         break;
4737                 }
4738     }
4739   }
4740   /////////////////////////////////////////////////////////////
4741   // Creating Lower Ladder Support
4742   /////////////////////////////////////////////////////////////
4743   TVector3** ringsupportvertex[fgklayernumber];
4744   Double_t angle = 360./nedges;
4745   for(Int_t i=0; i<fgklayernumber; i++){
4746     ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
4747         ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
4748                                            * TMath::Cos(theta[i]), 0);
4749         ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
4750                                                         -                          mountingsupportedge[i],
4751                                                ringsupportvertex[i][0]->Y(), 0);
4752         ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
4753                                                ringsupportvertex[i][1]->Y(),0);
4754     ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
4755         for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4756            ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
4757            ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
4758            ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
4759            ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
4760         }
4761         ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
4762     for(Int_t j=0; j<nedges+1; j++){
4763                 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
4764                         new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*CosD(90.0-j*angle),
4765                                (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*SinD(90.0-j*angle), 0);
4766         }
4767   }
4768   Double_t **xmothervertex = new Double_t*[fgklayernumber];
4769   Double_t **ymothervertex = new Double_t*[fgklayernumber];
4770   for(Int_t i=0; i<fgklayernumber; i++){
4771         xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4772         ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4773         for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
4774                 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
4775                 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
4776         }
4777   }
4778 ////////////////////////////////////////////////////////////////////////////////
4779 // Start Corrections 13/06/08
4780 ////////////////////////////////////////////////////////////////////////////////
4781   char lowerladderpconsupportname[100];
4782   TGeoPcon* lowerladderpconsupportshape[fgklayernumber];
4783   TGeoVolume* lowerladderpconsupport[fgklayernumber];
4784   Double_t lowerladderpconezsection[2] = {0.,fgkMountingBlockSupportWidth[1]};
4785   Double_t lowerladderpconradiusmax[fgklayernumber];
4786   Double_t lowerladderpconradiusmin[fgklayernumber];
4787   TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4788   lowerladdersupportrot->SetAngles(90.,180.,-90);
4789   for(Int_t i=0; i<fgklayernumber; i++){
4790         lowerladderpconradiusmax[i] = fgkMountingBlockSupportRadius[i]
4791                                                                 *                          TMath::Cos(theta[i]);
4792     lowerladderpconradiusmin[i] = lowerladderpconradiusmax[i]-fgkLadderSupportHeight;
4793   }
4794   for(Int_t i=0; i<fgklayernumber; i++){
4795 ///////////////////////////  Modified Version ?///////////////////
4796     lowerladderpconsupportshape[i] = new TGeoPcon(0.,360.,2);
4797         for(Int_t j=0; j<2; j++) lowerladderpconsupportshape[i]->DefineSection(j,
4798                                                          lowerladderpconezsection[j],lowerladderpconradiusmin[i],
4799                                                          lowerladderpconradiusmax[i]);
4800         snprintf(lowerladderpconsupportname,100,"LowerLadderPConSupportNameLay%d",i+5);
4801         lowerladderpconsupport[i] = new TGeoVolume(lowerladderpconsupportname,lowerladderpconsupportshape[i],fSSDSupportRingAl);
4802     lowerladderpconsupport[i]->SetLineColor(fColorAl);
4803         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],1);
4804         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],2,lowerladdersupportrot);
4805  }
4806 ////////////////////////////////////////////////////////////////////////////////
4807 // End Corrections 13/06/08
4808 ////////////////////////////////////////////////////////////////////////////////
4809   /*char lowerladdersupportname[30];
4810   TGeoXtru* lowerladdersupportshape[fgklayernumber];
4811   TGeoVolume* lowerladdersupport[fgklayernumber];
4812   TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4813   lowerladdersupportrot->SetAngles(90.,180.,-90);
4814   for(Int_t i=0; i<fgklayernumber; i++){
4815         lowerladdersupportshape[i] = new TGeoXtru(2);
4816         lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
4817                                                                                           xmothervertex[i],ymothervertex[i]);
4818         lowerladdersupportshape[i]->DefineSection(0,0.);
4819     lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4820         sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
4821     lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
4822                                                         lowerladdersupportshape[i],fSSDSupportRingAl);
4823         lowerladdersupport[i]->SetLineColor(fColorAl);
4824         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
4825         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
4826   }*/
4827   /////////////////////////////////////////////////////////////
4828   // Deallocating memory
4829   /////////////////////////////////////////////////////////////
4830   for(Int_t i=0; i<fgklayernumber; i++){
4831         for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
4832                 delete ringsupportvertex[i][j];
4833         delete [] ringsupportvertex[i];
4834   }
4835   for(Int_t i=0; i<fgklayernumber; i++){
4836         delete [] xmothervertex[i];
4837         delete [] ymothervertex[i];
4838   }
4839   delete [] xmothervertex;
4840   delete [] ymothervertex;
4841   delete globalrot;
4842   for(Int_t i=0; i<fgklayernumber; i++){
4843         for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
4844                 delete laddersupportrot[i][j];
4845         delete [] laddersupportrot[i];
4846   }
4847  }
4848  ////////////////////////////////////////////////////////////////////////////////
4849  TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
4850   /////////////////////////////////////////////////////////////
4851   // Method generating Endcap CoverPlate
4852   /////////////////////////////////////////////////////////////
4853   // Holes Definition
4854   ///////////////////
4855   Int_t nendcapcoverplateholedges = 30;
4856   const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
4857   Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
4858                                                           0.5*fgkEndCapCoverPlateThickness};
4859   TGeoShape* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
4860                                                                                                               nendcapcoverplateholedges,holesection);
4861   TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
4862                                                                                   endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
4863   endcapcoverplatesmallhole->SetLineColor(6);
4864   TGeoShape* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
4865                                                                                                               nendcapcoverplateholedges,holesection);
4866   TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
4867                                                                                   endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
4868   endcapcoverplatebighole->SetLineColor(6);
4869   //////////////////////////
4870   // Screw Piece Definition
4871   //////////////////////////
4872   Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
4873   TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
4874                                                                                                       CosD(0.5*smallscrewangle),
4875                                                                                                       0.5*fgkEndCapCoverPlateThickness);
4876   TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
4877                                                                                                 endcapsmallscrewpieceshape,
4878                                                                                                 fSSDCoolingTubePhynox);
4879   endcapsmallscrewpiece->SetLineColor(fColorPhynox);
4880   ///////////////////
4881   // Box Definition
4882   ///////////////////
4883   TGeoBBox* endcapcoverplateboxshape[4];
4884   TGeoVolume* endcapcoverplatebox[4];
4885   Double_t boxorigin[5][3];
4886   boxorigin[0][0] = 0.;
4887   boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
4888   boxorigin[0][2] = 0.;
4889
4890   boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
4891   boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
4892   boxorigin[1][2] = 0.;
4893
4894   boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
4895                                   + fgkEndCapCoverPlateSmallHoleSeparation[1];
4896   boxorigin[2][1] = boxorigin[1][1];
4897   boxorigin[2][2] = 0.;
4898
4899   boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
4900                                   + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
4901   boxorigin[3][1] = boxorigin[1][1];
4902   boxorigin[3][2] = 0.;
4903
4904   endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4905                                                                                 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
4906                                                  -              2.*fgkEndCapCoverPlateSmallHoleRadius),
4907                                                                             0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
4908
4909   endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4910                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
4911                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4912                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
4913                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
4914
4915   endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4916                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
4917                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4918                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
4919                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
4920
4921   endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
4922                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
4923                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4924                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
4925                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
4926
4927   endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
4928                                                                            fSSDAlCoolBlockMedium);
4929   endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
4930                                                                            fSSDAlCoolBlockMedium);
4931   endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
4932                                                                            fSSDAlCoolBlockMedium);
4933   endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
4934                                                                            fSSDAlCoolBlockMedium);
4935   endcapcoverplatebox[0]->SetLineColor(6);
4936   endcapcoverplatebox[1]->SetLineColor(6);
4937   endcapcoverplatebox[2]->SetLineColor(6);
4938   endcapcoverplatebox[3]->SetLineColor(6);
4939   Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
4940   TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4941                                                                                         fgkEndCapCoverPlateSmallHoleRadius,
4942                                                                                         0.5*fgkEndCapCoverPlateThickness,
4943                                                                                         endcapfillingboxorigin);
4944   TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
4945                                                                            fSSDAlCoolBlockMedium);
4946   endcapfillingbox->SetLineColor(6);
4947   ////////////////////////////
4948   // Contour shape Definition
4949   ////////////////////////////
4950   const Int_t kcontourvertexnumber = 10;
4951   Double_t xcontourvertex[kcontourvertexnumber];
4952   Double_t ycontourvertex[kcontourvertexnumber];
4953   xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
4954   xcontourvertex[1] = xcontourvertex[0];
4955   xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
4956   xcontourvertex[3] = xcontourvertex[2];
4957   xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
4958   xcontourvertex[5] = xcontourvertex[4];
4959   xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
4960   xcontourvertex[7] = xcontourvertex[6];
4961   xcontourvertex[8] = xcontourvertex[4];
4962   xcontourvertex[9] = xcontourvertex[8];
4963   ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
4964                                         - (kendcapcoverplatesmallholenumber[1]-1)
4965                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]);
4966   ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
4967                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
4968   ycontourvertex[2] = ycontourvertex[1];
4969   ycontourvertex[3] = ycontourvertex[0];
4970   ycontourvertex[4] = ycontourvertex[3];
4971   ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
4972   ycontourvertex[6] = ycontourvertex[5];
4973   ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
4974                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]
4975                                         + fgkEndCapCoverPlateSmallHoleRadius;
4976   ycontourvertex[8] = ycontourvertex[7];
4977   ycontourvertex[9] = ycontourvertex[0];
4978
4979   Double_t xboxin, dxboxin, yboxin, dyboxin;
4980   Double_t xboxout, dxboxout, yboxout, dyboxout;
4981   Double_t coordmin, coordmax;
4982   coordmin = -fgkEndCapCoverPlateLength[0];
4983   coordmax = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
4984   xboxout = 0.5*(coordmin+coordmax);
4985   dxboxout = 0.5*(coordmax-coordmin);
4986   coordmin = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
4987                                         - (kendcapcoverplatesmallholenumber[1]-1)
4988                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]);
4989   coordmax = (kendcapcoverplatesmallholenumber[1]-1)
4990                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
4991   yboxout = 0.5*(coordmin+coordmax);
4992   dyboxout = 0.5*(coordmax-coordmin);
4993   coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
4994   coordmax = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
4995   xboxin = 0.5*(coordmin+coordmax);
4996   dxboxin = 0.5*(coordmax-coordmin);
4997   coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
4998   coordmax = (kendcapcoverplatesmallholenumber[1]-1)
4999                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]
5000                                         + fgkEndCapCoverPlateSmallHoleRadius;
5001   yboxin = 0.5*(coordmin+coordmax);
5002   dyboxin = 0.5*(coordmax-coordmin);
5003   new TGeoBBox("EndCapCoverPlateContourBoxOut", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5004   TGeoTranslation *trendCapCoverPlateContourboxout = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut",
5005                                                          xboxout, yboxout, 0.);
5006   trendCapCoverPlateContourboxout->RegisterYourself();
5007   new TGeoBBox("EndCapCoverPlateContourBoxIn",  dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5008   TGeoTranslation *trendCapCoverPlateContourboxin = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn",
5009                                                          xboxin, yboxin, 0.);
5010   trendCapCoverPlateContourboxin->RegisterYourself();
5011   TGeoCompositeShape *contourshape = new TGeoCompositeShape("contourShape",
5012         "EndCapCoverPlateContourBoxOut:SSD_trEndCapCoverPlateContourBoxOut-EndCapCoverPlateContourBoxIn:SSD_trEndCapCoverPlateContourBoxIn");
5013
5014   TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5015                                                                            fSSDAlCoolBlockMedium);
5016   contour->SetLineColor(6);
5017   /////////////////////////////
5018   // Hole Contour Shape Definition
5019   ////////////////////////////
5020   coordmin = xcontourvertex[0];
5021   coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5022   xboxout = 0.5*(coordmin+coordmax);
5023   dxboxout = 0.5*(coordmax-coordmin);
5024   coordmin = ycontourvertex[1];
5025   coordmax = ycontourvertex[1]+fgkEndCapCoverPlateWidth[2];
5026   yboxout = 0.5*(coordmin+coordmax);
5027   dyboxout = 0.5*(coordmax-coordmin);
5028   coordmin = xcontourvertex[0]+ 0.5*(fgkEndCapCoverPlateLength[2]
5029                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5030   coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5031   xboxin = 0.5*(coordmin+coordmax);
5032   dxboxin = 0.5*(coordmax-coordmin);
5033   coordmin = ycontourvertex[1]+0.5*(fgkEndCapCoverPlateWidth[2]
5034                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);;
5035   coordmax = coordmin +2.*fgkEndCapCoverPlateBigHoleRadius;
5036   yboxin = 0.5*(coordmin+coordmax);
5037   dyboxin = 0.5*(coordmax-coordmin);
5038   new TGeoBBox("EndCapCoverPlateContourBoxOut1", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5039   TGeoTranslation *trendCapCoverPlateContourboxout1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut1",
5040                                                          xboxout, yboxout, 0.);
5041   trendCapCoverPlateContourboxout1->RegisterYourself();
5042   new TGeoBBox("EndCapCoverPlateContourBoxIn1",  dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5043   TGeoTranslation *trendCapCoverPlateContourboxin1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn1",
5044                                                          xboxin, yboxin, 0.);
5045   trendCapCoverPlateContourboxin1->RegisterYourself();
5046   TGeoCompositeShape *contourshape1 = new TGeoCompositeShape("contourShape1",
5047         "EndCapCoverPlateContourBoxOut1:SSD_trEndCapCoverPlateContourBoxOut1-EndCapCoverPlateContourBoxIn1:SSD_trEndCapCoverPlateContourBoxIn1");
5048
5049
5050   coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5051   coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5052   xboxout = 0.5*(coordmin+coordmax);
5053   dxboxout = 0.5*(coordmax-coordmin);
5054   coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5055                                                    - fgkEndCapCoverPlateWidth[0]);
5056   coordmax = ycontourvertex[0];
5057   yboxout = 0.5*(coordmin+coordmax);
5058   dyboxout = 0.5*(coordmax-coordmin);
5059   coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5]+ 0.5*(fgkEndCapCoverPlateLength[2]
5060                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5061   coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5062   xboxin = 0.5*(coordmin+coordmax);
5063   dxboxin = 0.5*(coordmax-coordmin);
5064   coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5065                                                    - fgkEndCapCoverPlateWidth[0])+0.5*(fgkEndCapCoverPlateWidth[1]
5066                                                    - fgkEndCapCoverPlateWidth[0]
5067                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5068   coordmax = coordmin+2.*fgkEndCapCoverPlateBigHoleRadius;
5069   yboxin = 0.5*(coordmin+coordmax);
5070   dyboxin = 0.5*(coordmax-coordmin);
5071   new TGeoBBox("EndCapCoverPlateContourBoxOut2", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5072   TGeoTranslation *trendCapCoverPlateContourboxout2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut2",
5073                                                          xboxout, yboxout, 0.);
5074   trendCapCoverPlateContourboxout2->RegisterYourself();
5075   new TGeoBBox("EndCapCoverPlateContourBoxIn2",  dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5076   TGeoTranslation *trendCapCoverPlateContourboxin2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn2",
5077                                                          xboxin, yboxin, 0.);
5078   trendCapCoverPlateContourboxin2->RegisterYourself();
5079   TGeoCompositeShape *contourshape2 = new TGeoCompositeShape("contourShape2",
5080         "EndCapCoverPlateContourBoxOut2:SSD_trEndCapCoverPlateContourBoxOut2-EndCapCoverPlateContourBoxIn2:SSD_trEndCapCoverPlateContourBoxIn2");
5081
5082 //  const Int_t kholecontourvertexnumber = 10;
5083
5084   Double_t xholecontourvertex[2][kcontourvertexnumber];
5085   Double_t yholecontourvertex[2][kcontourvertexnumber];
5086   xholecontourvertex[0][0] = xcontourvertex[0];
5087   xholecontourvertex[0][1] = xholecontourvertex[0][0];
5088   xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5089   xholecontourvertex[0][3] = xholecontourvertex[0][2];
5090   xholecontourvertex[0][4] = xholecontourvertex[0][0]
5091                                                    + 0.5*(fgkEndCapCoverPlateLength[2]
5092                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5093   xholecontourvertex[0][5] = xholecontourvertex[0][4];
5094   xholecontourvertex[0][6] = xholecontourvertex[0][5]
5095                                                    + 2.*fgkEndCapCoverPlateBigHoleRadius;
5096   xholecontourvertex[0][7] = xholecontourvertex[0][6];
5097   xholecontourvertex[0][8] = xholecontourvertex[0][4];
5098   xholecontourvertex[0][9] = xholecontourvertex[0][8];
5099
5100   yholecontourvertex[0][0] = ycontourvertex[1];
5101   yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5102   yholecontourvertex[0][2] = yholecontourvertex[0][1];
5103   yholecontourvertex[0][3] = yholecontourvertex[0][0];
5104   yholecontourvertex[0][4] = yholecontourvertex[0][3];
5105   yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5106                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5107   yholecontourvertex[0][6] = yholecontourvertex[0][5];
5108   yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5109   yholecontourvertex[0][8] = yholecontourvertex[0][7];
5110   yholecontourvertex[0][9] = yholecontourvertex[0][0];
5111
5112   xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5113   xholecontourvertex[1][1] = xholecontourvertex[1][0];
5114   xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5115   xholecontourvertex[1][3] = xholecontourvertex[1][2];
5116   xholecontourvertex[1][4] = xholecontourvertex[1][0]
5117                                                    + 0.5*(fgkEndCapCoverPlateLength[2]
5118                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5119   xholecontourvertex[1][5] = xholecontourvertex[1][4];
5120   xholecontourvertex[1][6] = xholecontourvertex[1][5]
5121                                                    + 2.*fgkEndCapCoverPlateBigHoleRadius;
5122   xholecontourvertex[1][7] = xholecontourvertex[1][6];
5123   xholecontourvertex[1][8] = xholecontourvertex[1][4];
5124   xholecontourvertex[1][9] = xholecontourvertex[1][8];
5125
5126   yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5127                                                    - fgkEndCapCoverPlateWidth[0]);
5128   yholecontourvertex[1][1] = ycontourvertex[0];
5129   yholecontourvertex[1][2] = yholecontourvertex[1][1];
5130   yholecontourvertex[1][3] = yholecontourvertex[1][0];
5131   yholecontourvertex[1][4] = yholecontourvertex[1][3];
5132   yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5133                                                    - fgkEndCapCoverPlateWidth[0]
5134                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5135   yholecontourvertex[1][6] = yholecontourvertex[1][5];
5136   yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5137   yholecontourvertex[1][8] = yholecontourvertex[1][7];
5138   yholecontourvertex[1][9] = yholecontourvertex[1][0];
5139
5140   TGeoVolume* holecontour[2];
5141   holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",contourshape1,
5142                                                                   fSSDAlCoolBlockMedium);
5143   holecontour[0]->SetLineColor(6);
5144   holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",contourshape2,
5145                                                                   fSSDAlCoolBlockMedium);
5146   holecontour[1]->SetLineColor(6);
5147   TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5148                                                                         +     fgkEndCapCoverPlateLength[2],0.,0.);
5149   TGeoTranslation*  bigholetrans[3];
5150   bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5151                                                                                 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5152   bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5153                                   +                     fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5154                                   -                                             fgkEndCapCoverPlateBigHoleRadius,0.0);
5155   bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5156                                                                                 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5157   /////////////////////////////////
5158   // Mother Volume Xtru Definition
5159   /////////////////////////////////
5160   const Int_t kmothervertexnumber = 12;
5161   Double_t xmothervertex[kmothervertexnumber];
5162   Double_t ymothervertex[kmothervertexnumber];
5163   xmothervertex[0]  = xcontourvertex[0];
5164   xmothervertex[1]  = xmothervertex[0];
5165   xmothervertex[2]  = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5166   xmothervertex[3]  = xmothervertex[2];
5167   xmothervertex[4]  = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5168   xmothervertex[5]  = xmothervertex[4];
5169   xmothervertex[6]  = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5170   xmothervertex[7]  = xmothervertex[6];
5171   xmothervertex[8]  = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5172                                         + fgkEndCapCoverPlateLength[2];
5173   xmothervertex[9]  = xmothervertex[8];
5174   xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5175   xmothervertex[11] = xmothervertex[10];
5176
5177   ymothervertex[0]  = ycontourvertex[0];
5178   ymothervertex[1]  = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5179   ymothervertex[2]  = ymothervertex[1];
5180   ymothervertex[3]  = ycontourvertex[1];
5181   ymothervertex[4]  = ymothervertex[3];
5182   ymothervertex[5]  = ymothervertex[1];
5183   ymothervertex[6]  = ymothervertex[5];
5184   ymothervertex[7]  = ymothervertex[0];
5185   ymothervertex[8]  = ymothervertex[7];
5186   ymothervertex[9]  = ymothervertex[8]
5187                                    - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5188   ymothervertex[10] = ymothervertex[9];
5189   ymothervertex[11] = ymothervertex[8];
5190   TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5191   mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5192   mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5193   mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5194   TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5195   ////////////////////////////////////////
5196   // Adding Nodes
5197   ////////////////////////////////////////
5198 //  TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5199   TGeoTranslation*** endcapcoverplatesmallholetrans;
5200   endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5201   Double_t transx[4] = {0,
5202                                                 fgkEndCapCoverPlateSmallHoleSeparation[0],
5203                                                 fgkEndCapCoverPlateSmallHoleSeparation[0]
5204                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1],
5205                                          2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5206                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1]};
5207   Int_t index = 0;
5208   for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5209         endcapcoverplatesmallholetrans[i] =
5210                                         new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5211     for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5212                 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5213             endcapcoverplatesmallholetrans[i][j] =
5214                 new TGeoTranslation(transx[i],
5215                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5216             if(index!=10){
5217                         mothercoverplate->AddNode(endcapcoverplatesmallhole,
5218                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5219                         mothercoverplate->AddNode(endcapsmallscrewpiece,
5220                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5221                 }
5222                 if(j<kendcapcoverplatesmallholenumber[1]-1)
5223                         mothercoverplate->AddNode(endcapcoverplatebox[0],
5224                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5225     }
5226   }
5227   mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5228   mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5229   mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5230   mothercoverplate->AddNode(endcapfillingbox,1);
5231   mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5232   mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5233   mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5234   mothercoverplate->AddNode(holecontour[0],1);
5235   mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5236   mothercoverplate->AddNode(holecontour[1],1);
5237   mothercoverplate->AddNode(contour,1);
5238
5239   for (Int_t i = 0; i < kendcapcoverplatesmallholenumber[0]; i++)
5240     delete [] endcapcoverplatesmallholetrans[i];
5241   delete [] endcapcoverplatesmallholetrans;
5242   /////////////////////////////////
5243   return mothercoverplate;
5244  }
5245  ////////////////////////////////////////////////////////////////////////////////
5246  TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5247   /////////////////////////////////////////////////////////////
5248   // Getting EndCap Cooling Tube
5249   /////////////////////////////////////////////////////////////
5250   TGeoTorus* endcapcoolingtubetorushape[5];
5251   TGeoVolume* endcapcoolingtubetorus[5];
5252   TGeoTube* endcapcoolingtubeshape[4];
5253   TGeoVolume* endcapcoolingtube[4];
5254   char endcapcoolingtubetorusname[100];
5255   char endcapcoolingtubename[100];
5256   TGeoTorus* endcapcoolingwatertubetorushape[5];
5257   TGeoVolume* endcapcoolingwatertubetorus[5];
5258   TGeoTube* endcapcoolingwatertubeshape[4];
5259   TGeoVolume* endcapcoolingwatertube[4];
5260   char endcapcoolingwatertubetorusname[100];
5261   char endcapcoolingwatertubename[100];
5262   for(Int_t i=0; i<5; i++){
5263     snprintf(endcapcoolingtubetorusname,100,"EndCapCoolingTubeTorus%d",i+1);
5264     snprintf(endcapcoolingtubename,100,"EndCapCoolingTube%d",i+1);
5265     snprintf(endcapcoolingwatertubetorusname,100,"EndCapCoolingWaterTubeTorus%d",i+1);
5266     snprintf(endcapcoolingwatertubename,100,"EndCapCoolingWaterTube%d",i+1);
5267     if(i==3){
5268       endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5269                                                     fgkEndCapCoolingTubeRadiusMin,
5270                                                     fgkEndCapCoolingTubeRadiusMax,
5271                                                     90.0,fgkEndCapCoolingTubeAngle[3]);
5272       endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5273                                                          0.,fgkEndCapCoolingTubeRadiusMin,
5274                                                          90.0,fgkEndCapCoolingTubeAngle[3]);
5275     }
5276     else{
5277       endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5278                                                     :fgkEndCapCoolingTubeAxialRadius[1],
5279                                                     fgkEndCapCoolingTubeRadiusMin,
5280                                                     fgkEndCapCoolingTubeRadiusMax,
5281                                                     0.,fgkEndCapCoolingTubeAngle[i]);
5282       endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5283                                                          :fgkEndCapCoolingTubeAxialRadius[1],
5284                                                          0.,fgkEndCapCoolingTubeRadiusMin,
5285                                                          0.,fgkEndCapCoolingTubeAngle[i]);
5286     }
5287         endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5288                                                                                            endcapcoolingtubetorushape[i],
5289                                                                                            fSSDCoolingTubePhynox);
5290         endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5291                                                                                                         endcapcoolingwatertubetorushape[i],
5292                                                                                                         fSSDCoolingTubeWater);
5293     endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5294     endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5295     if(i<4){
5296                 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5297                                                                   fgkEndCapCoolingTubeRadiusMax,
5298                                                           0.5*fgkEndCapCoolingTubeLength[i]);
5299                 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5300                                                           0.5*fgkEndCapCoolingTubeLength[i]);
5301         endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5302                                                          endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5303         endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5304                                                          endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5305                 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5306                 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5307         }
5308   }
5309   TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5310   /////////////////////////////////////////
5311   // Transformation for Volume Positioning
5312   /////////////////////////////////////////
5313   TGeoCombiTrans* coolingtubecombitrans[6];
5314   TGeoRotation* coolingtuberot[8];
5315   TGeoTranslation* coolingtubetrans[6];
5316   TGeoHMatrix* coolingtubematrix[4];
5317   TGeoCombiTrans* torustubecombitrans[4];
5318   TGeoRotation* torustuberot[7];
5319   TGeoTranslation* torustubetrans[4];
5320   TGeoHMatrix* torustubematrix[5];
5321   TGeoCombiTrans* coolingwatertubecombitrans[6];
5322   TGeoRotation* coolingwatertuberot[8];
5323   TGeoTranslation* coolingwatertubetrans[6];
5324   TGeoHMatrix* coolingwatertubematrix[4];
5325   TGeoCombiTrans* toruswatertubecombitrans[4];
5326   TGeoRotation* toruswatertuberot[7];
5327   TGeoTranslation* toruswatertubetrans[4];
5328   TGeoHMatrix* toruswatertubematrix[5];
5329   for(Int_t i=0; i<8; i++){
5330     if(i<6){
5331          coolingtubetrans[i] = new TGeoTranslation();
5332          coolingwatertubetrans[i] = new TGeoTranslation();
5333     }
5334     if(i<8){
5335          coolingtuberot[i] = new TGeoRotation();
5336          coolingwatertuberot[i] = new TGeoRotation();
5337     }
5338     if(i<4){
5339          torustubetrans[i] = new TGeoTranslation();
5340          toruswatertubetrans[i] = new TGeoTranslation();
5341     }
5342     if(i<7){
5343          torustuberot[i] = new TGeoRotation();
5344          toruswatertuberot[i] = new TGeoRotation();
5345         }
5346   }
5347   /////////////////////////////////////////
5348   // Transformation for Inox Volume Positioning
5349   /////////////////////////////////////////
5350   coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5351                                                                           -endcapcoolingtubeshape[0]->GetDz(),0.);
5352   coolingtuberot[0]->SetAngles(0.,90.,0.);
5353   coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5354                                                                                                 *coolingtuberot[0]);
5355
5356   coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5357   coolingtuberot[1]->SetAngles(0.,90.,0.);
5358   coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5359                                                                                                 *coolingtuberot[1]);
5360
5361   coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5362                                                                          *CosD(fgkEndCapCoolingTubeAngle[0]),
5363                                                                           fgkEndCapCoolingTubeAxialRadius[0]
5364                                                                          *SinD(fgkEndCapCoolingTubeAngle[0]),
5365                                                                           0.);
5366   coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5367   coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5368                                                                                                 *coolingtuberot[2]);
5369
5370   coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5371                                            *                             (*coolingtubecombitrans[1]));
5372
5373   torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5374                                                                          endcapcoolingtubeshape[1]->GetDz());
5375   torustuberot[0]->SetAngles(0.,90.,0.);
5376   torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5377
5378   torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5379
5380   coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5381                                                                           -endcapcoolingtubeshape[2]->GetDz(),0.);
5382   coolingtuberot[3]->SetAngles(0.,90.,0.);
5383   coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5384                                                                                                 *coolingtuberot[3]);
5385   coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5386   coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5387   coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5388
5389   torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5390                                                                         endcapcoolingtubeshape[2]->GetDz());
5391   torustuberot[1]->SetAngles(0.,90.,0.);
5392   torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5393   torustuberot[2]->SetAngles(180.,0.,0.);
5394   torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5395   torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5396
5397   torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5398                                                                         -fgkEndCapCoolingTubeAxialRadius[0]);
5399   torustuberot[3]->SetAngles(0.,90.,0.);
5400   torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5401   torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5402   torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5403   torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5404
5405   coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5406                                                                           fgkEndCapCoolingTubeAxialRadius[0],0.);
5407   coolingtuberot[5]->SetAngles(90.,90.,-90.);
5408   coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5409                                                                                                 *coolingtuberot[5]);
5410   coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5411   coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5412   coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5413
5414   torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5415                                                                         endcapcoolingtubeshape[0]->GetDz());
5416   torustuberot[5]->SetAngles(0.,90.,0.);
5417   torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5418   torustuberot[6]->SetAngles(-90.,0.,0.);
5419   torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5420   torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5421
5422   coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5423                                                                           endcapcoolingtubeshape[3]->GetDz(),0.);
5424   coolingtuberot[6]->SetAngles(0.,90.,0.);
5425   coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5426                                                                                                 *coolingtuberot[6]);
5427   coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5428   coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5429   coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5430     /////////////////////////////////////////
5431   // Transformation for Water Volume Positioning
5432   /////////////////////////////////////////
5433   coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5434                                                                           -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5435   coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5436   coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5437                                                                                                      *coolingwatertuberot[0]);
5438
5439   coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5440   coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5441   coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5442                                                                                                      *coolingwatertuberot[1]);
5443
5444   coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5445                                                                                   *CosD(fgkEndCapCoolingTubeAngle[0]),
5446                                                                                   fgkEndCapCoolingTubeAxialRadius[0]
5447                                                                                   *SinD(fgkEndCapCoolingTubeAngle[0]),
5448                                                                               0.);
5449   coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5450   coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5451                                                                                                     *coolingwatertuberot[2]);
5452
5453   coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5454                                            *                                 (*coolingwatertubecombitrans[1]));
5455
5456   toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5457                                                                          endcapcoolingwatertubeshape[1]->GetDz());
5458   toruswatertuberot[0]->SetAngles(0.,90.,0.);
5459   toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5460                                                                                                    *toruswatertuberot[0]);
5461
5462   toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5463                                                   *                                     (*toruswatertubecombitrans[0]));
5464
5465   coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5466                                                                           -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5467   coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5468   coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5469                                                                                                      *coolingwatertuberot[3]);
5470   coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5471   coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5472                                                         *                                 (*coolingwatertubecombitrans[3]));
5473   coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5474
5475   toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5476                                                                         endcapcoolingwatertubeshape[2]->GetDz());
5477   toruswatertuberot[1]->SetAngles(0.,90.,0.);
5478   toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5479                                                                                                    *toruswatertuberot[1]);
5480   toruswatertuberot[2]->SetAngles(180.,0.,0.);
5481   toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5482                                                   *                 (*toruswatertubecombitrans[1]));
5483   toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5484
5485   toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5486                                                                                    -fgkEndCapCoolingTubeAxialRadius[0]);
5487   toruswatertuberot[3]->SetAngles(0.,90.,0.);
5488   toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5489                                                                                                    *toruswatertuberot[3]);
5490   toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5491   toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5492                                                   *                                     (*toruswatertubecombitrans[2]));
5493   toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5494
5495   coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5496                                                                                 fgkEndCapCoolingTubeAxialRadius[0],0.);
5497   coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5498   coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5499                                                                                                      *coolingwatertuberot[5]);
5500   coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5501   coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5502                                                         *                                 (*coolingwatertubecombitrans[4]));
5503   coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5504
5505   toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5506                                                                               endcapcoolingwatertubeshape[0]->GetDz());
5507   toruswatertuberot[5]->SetAngles(0.,90.,0.);
5508   toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5509                                                                                                    *toruswatertuberot[5]);
5510   toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5511   toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5512                                                   *                 (*toruswatertubecombitrans[3]));
5513   toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5514
5515   coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5516                                                                           endcapcoolingwatertubeshape[3]->GetDz(),0.);
5517   coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5518   coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5519                                                                                                      *coolingwatertuberot[6]);
5520   coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5521   coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5522                                                         *                                 (*coolingwatertubecombitrans[5]));
5523   coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5524   /////////////////////////////////////////
5525   // Positioning Volumes
5526   /////////////////////////////////////////
5527   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5528   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5529
5530   endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5531   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5532
5533   endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5534   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5535
5536   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5537   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5538
5539   endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5540   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5541
5542   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5543   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5544
5545   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5546   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5547
5548   endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5549   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5550
5551   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5552   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5553
5554   endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5555   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5556   /////////////////////////////////////////////////////////////
5557   // Deallocating memory
5558   /////////////////////////////////////////////////////////////
5559   for(Int_t i=0; i<8; i++){
5560     if(i<6){
5561          delete coolingtubetrans[i];
5562          delete coolingwatertubetrans[i];
5563          if(i!=0){
5564           delete coolingtubecombitrans[i];
5565           delete coolingwatertubecombitrans[i];
5566          }
5567         }
5568     if(i<8){
5569           delete coolingtuberot[i];
5570           delete coolingwatertuberot[i];
5571     }
5572     if(i<4){
5573                 delete torustubetrans[i];
5574                 delete toruswatertubetrans[i];
5575                 delete torustubecombitrans[i];
5576                 delete toruswatertubecombitrans[i];
5577         }
5578     if(i<7){
5579          delete torustuberot[i];
5580          delete toruswatertuberot[i];
5581         }
5582   }
5583   /////////////////////////////////////////////////////////////
5584   return endcapcoolingtubemother;
5585  }
5586  ////////////////////////////////////////////////////////////////////////////////
5587  TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5588   /////////////////////////////////////////////////////////////
5589   // Getting EndCap Cover Side
5590   /////////////////////////////////////////////////////////////
5591   const Int_t kendcapcoverholenumber[2] = {7,5};
5592   const Int_t kvertexnumber = 15;
5593   Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5594   xvertex[0]  = 0.0;
5595   xvertex[1]  = xvertex[0];
5596   xvertex[2]  = fgkEndCapSideCoverLength[0];
5597   xvertex[3]  = fgkEndCapSideCoverLength[1];
5598   xvertex[4]  = xvertex[3];
5599   xvertex[5]  = fgkEndCapSideCoverLength[2];
5600   xvertex[6]  = xvertex[5];
5601   xvertex[7]  = xvertex[2];
5602   xvertex[8]  = xvertex[7];
5603   xvertex[9]  = xvertex[6]-fgkEndCapSideCoverLength[0];
5604   xvertex[10] = xvertex[9];
5605   xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5606                           * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5607                           * fgkEndCapSideCoverLength[4];
5608   xvertex[12] = xvertex[11];
5609   xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5610                           * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5611                           * fgkEndCapSideCoverLength[4];
5612   xvertex[14] = xvertex[13];
5613   yvertex[0]  = 0.0;
5614   yvertex[1]  = fgkEndCapSideCoverWidth[0];
5615   yvertex[2]  = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5616   yvertex[3]  = yvertex[2];
5617   yvertex[4]  = fgkEndCapSideCoverWidth[1];
5618   yvertex[5]  = yvertex[4];
5619   yvertex[6]  = yvertex[0];
5620   yvertex[7]  = yvertex[6];
5621   yvertex[8]  = fgkEndCapSideCoverWidth[6];
5622   yvertex[9]  = yvertex[8];
5623   yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5624   yvertex[11] = yvertex[10];
5625   yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5626   yvertex[13] = yvertex[12];
5627   yvertex[14] = yvertex[6];
5628   TGeoXtru* endcapsidecovershapeout = new TGeoXtru(2);
5629   endcapsidecovershapeout->SetName("endcapsidecovershapeout");
5630   endcapsidecovershapeout->DefinePolygon(7,xvertex,yvertex);
5631   endcapsidecovershapeout->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5632   endcapsidecovershapeout->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5633   TGeoXtru* endcapsidecovershapein = new TGeoXtru(2);
5634   endcapsidecovershapein->SetName("endcapsidecovershapein");
5635   endcapsidecovershapein->DefinePolygon(6,&xvertex[8],&yvertex[8]);
5636   endcapsidecovershapein->DefineSection(0,-0.5*fgkEndCapSideCoverThickness-0.01);
5637   endcapsidecovershapein->DefineSection(1,0.5*fgkEndCapSideCoverThickness+0.01);
5638
5639
5640   TGeoCompositeShape* endcapsidecovershape = new TGeoCompositeShape("endcapsidecovershape", "endcapsidecovershapeout-endcapsidecovershapein");
5641   TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5642                                                                 endcapsidecovershape,fSSDCoolingTubePhynox);
5643   endcapsidecover->SetLineColor(fColorPhynox);
5644   ////////////////////////////////////////////
5645   // Defininition of Mother Volume
5646   ////////////////////////////////////////////
5647   const Int_t kmothervertexnumber = 7;
5648   Double_t xmothervertex[kmothervertexnumber];
5649   Double_t ymothervertex[kmothervertexnumber];
5650   for(Int_t i=0; i<kmothervertexnumber; i++){
5651         xmothervertex[i] = xvertex[i];
5652         ymothervertex[i] = yvertex[i];
5653   }
5654   TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5655   endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5656   endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5657   endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5658   TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5659                                                                 endcapsidecovermothershape,fSSDAir);
5660   ////////////////////////////////////////////
5661   endcapsidecovermother->AddNode(endcapsidecover,1);
5662   TGeoBBox* endcapsidecoverboxshape[4];
5663   endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5664                                                          +     (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5665                                                                0.5*fgkEndCapSideCoverLength[4],
5666                                                                    0.5*fgkEndCapSideCoverThickness);
5667   endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5668                                                          +     (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5669                                                                0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5670                                                          -     fgkEndCapSideCoverLength[4]),
5671                                                                    0.5*fgkEndCapSideCoverThickness);
5672   endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5673                                                                0.5*fgkEndCapSideCoverLength[4],
5674                                                                    0.5*fgkEndCapSideCoverThickness);
5675   endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5676                                                                0.5*fgkEndCapSideCoverWidth[5],
5677                                                                    0.5*fgkEndCapSideCoverThickness);
5678   TGeoVolume* endcapsidecoverbox[4];
5679   endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5680   endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5681   endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5682   endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5683   for(Int_t i=0; i<4; i++)   endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5684 //  TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5685   TGeoTranslation** endcapsidecoverboxtrans;
5686   endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5687   endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5688                                                          +                                         fgkEndCapSideCoverLength[0],
5689                                                                                                    endcapsidecoverboxshape[0]->GetDY()
5690                                                          +                     yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5691   endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5692                                                          +                     xvertex[11],
5693                                                                                                    endcapsidecoverboxshape[1]->GetDY()
5694                                                          +                     yvertex[12],0.);
5695   endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5696                                                          +                     xvertex[11],
5697                                                                                                    endcapsidecoverboxshape[2]->GetDY()
5698                                                          +                     yvertex[12]
5699                                                          +                                         2.*endcapsidecoverboxshape[1]->GetDY()
5700                                                          +                     fgkEndCapSideCoverWidth[5],0.);
5701   endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5702   endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5703   endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5704   for(Int_t i=0; i<2; i++)
5705         for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5706                 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5707                         new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5708                                                                 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5709                                                                 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5710                                                                 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5711                 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5712                                                                 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5713         }
5714   for(Int_t i=0; i<2; i++)
5715         for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5716                 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5717                 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5718                                                         +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5719                                                         endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5720                                                         +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5721                                                         +fgkEndCapSideCoverLength[4]),0.0);
5722                 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5723                                                                 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5724                                                                 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5725                                                                 +i*(kendcapcoverholenumber[1]-1)+j]);
5726         }
5727   delete [] endcapsidecoverboxtrans;
5728   return endcapsidecovermother;
5729  }
5730  ////////////////////////////////////////////////////////////////////////////////
5731  TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5732  ////////////////////////////////////////////////////////////////////////////////
5733  // Method returning Interface Card A, Interface Card B, Supply Card
5734  ////////////////////////////////////////////////////////////////////////////////
5735  /////////////////////
5736  // Supply Card
5737  /////////////////////
5738  // Electronic Board Back Al Plane
5739  const Int_t kelectboardbackvertexnumber = 8;
5740  Double_t xelectboardback[kelectboardbackvertexnumber];
5741  Double_t yelectboardback[kelectboardbackvertexnumber];
5742  xelectboardback[0] = 0.0;
5743  xelectboardback[1] = xelectboardback[0];
5744  xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5745  xelectboardback[3] = xelectboardback[2];
5746  xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5747  xelectboardback[5] = xelectboardback[4];
5748  xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5749  xelectboardback[7] = xelectboardback[6];
5750
5751  yelectboardback[0] = 0.0;
5752  yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5753  yelectboardback[2] = yelectboardback[1];
5754  yelectboardback[3] = yelectboardback[0];
5755  yelectboardback[4] = yelectboardback[3];
5756  yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5757  yelectboardback[6] = yelectboardback[5];
5758  yelectboardback[7] = yelectboardback[4];
5759  TGeoXtru* electboardbackshape = new TGeoXtru(2);
5760  electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5761                                                                         xelectboardback,yelectboardback);
5762  electboardbackshape->DefineSection(0,0.0);
5763  electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5764  TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5765                                                                                          electboardbackshape,fSSDSupportRingAl);
5766  electboardback->SetLineColor(fColorAl);
5767  // Electronic Board Kapton Layer
5768  const Int_t kelectlayervertexnumber = 8;
5769  Double_t xelectlayer[kelectlayervertexnumber];
5770  Double_t yelectlayer[kelectlayervertexnumber];
5771  xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5772  xelectlayer[1] = xelectlayer[0];
5773  xelectlayer[2] = fgkEndCapCardElectBoardLength;
5774  xelectlayer[3] = xelectlayer[2];
5775  for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5776
5777  yelectlayer[0] = 0.0;
5778  yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5779  yelectlayer[2] = yelectlayer[1];
5780  yelectlayer[3] = yelectlayer[0];
5781  yelectlayer[4] = yelectlayer[3];
5782  yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5783  yelectlayer[6] = yelectlayer[5];
5784  yelectlayer[7] = yelectlayer[4];
5785  TGeoXtru* electlayershape = new TGeoXtru(2);
5786  electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5787  electlayershape->DefineSection(0,0.0);
5788  electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5789  TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5790                                                                                          electlayershape,fSSDKaptonFlexMedium);
5791  electlayer->SetLineColor(fColorKapton);
5792  // JMD Connector Female
5793  const Int_t kjmdconnectorvertexnumber = 6;
5794  Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5795  Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5796  xjmdconnectorvertex[0] = 0.0;
5797  xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5798  xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5799  xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5800  xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5801  xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5802
5803  yjmdconnectorvertex[0] = 0.0;
5804  yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5805  yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5806  yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5807  yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5808  yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5809  TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5810  jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5811                                                                   yjmdconnectorvertex);
5812  jmdconnectorshape->DefineSection(0,0.0);
5813  jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
5814  TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
5815                                                                                    jmdconnectorshape,fSSDMountingBlockMedium);
5816  jmdconnector->SetLineColor(fColorG10);
5817  // Top Cable Connector
5818  const Int_t kcableconnectorvertexnumber = 8;
5819  Double_t xconnectorvertex[kcableconnectorvertexnumber];
5820  Double_t yconnectorvertex[kcableconnectorvertexnumber];
5821  xconnectorvertex[0] = 0.0;
5822  xconnectorvertex[1] = xconnectorvertex[0];
5823  xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
5824  xconnectorvertex[3] = xconnectorvertex[2];
5825  xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
5826                                          - fgkEndCapCardCableConnectorLength[2];
5827  xconnectorvertex[5] = xconnectorvertex[4];
5828  xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
5829  xconnectorvertex[7] = xconnectorvertex[6];
5830
5831  yconnectorvertex[0] = 0.0;
5832  yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
5833  yconnectorvertex[2] = yconnectorvertex[1];
5834  yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
5835  yconnectorvertex[4] = yconnectorvertex[3];
5836  yconnectorvertex[5] = yconnectorvertex[1];
5837  yconnectorvertex[6] = yconnectorvertex[5];
5838  yconnectorvertex[7] = yconnectorvertex[0];
5839  TGeoXtru* cableconnectorshape = new TGeoXtru(2);
5840  cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
5841                                                                     yconnectorvertex);
5842  cableconnectorshape->DefineSection(0,0.0);
5843  cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
5844  TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
5845                                                                                    cableconnectorshape,fSSDMountingBlockMedium);
5846  cableconnector->SetLineColor(fColorG10);
5847  // Strip Connection
5848  TGeoBBox* endcapstripconnectionshape =
5849                                                                 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
5850                                                                                          0.5*fgkEndCapStripConnectionThickness,
5851                                                                                          0.5*fgkEndCapStripConnectionWidth);
5852  TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
5853                                                                                                         endcapstripconnectionshape,
5854                                                                                                         fSSDSupportRingAl);
5855  endcapstripconnection->SetLineColor(fColorAl);
5856  // Interface Card B
5857  const Int_t kcardBvertexnumber = 12;
5858  Double_t xcardBvertexnumber[kcardBvertexnumber];
5859  Double_t ycardBvertexnumber[kcardBvertexnumber];
5860
5861  xcardBvertexnumber[0]  = 0.0;
5862  xcardBvertexnumber[1]  = xcardBvertexnumber[0];
5863  xcardBvertexnumber[2]  = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
5864  xcardBvertexnumber[3]  = xcardBvertexnumber[2];
5865  xcardBvertexnumber[4]  = xcardBvertexnumber[1];
5866  xcardBvertexnumber[5]  = xcardBvertexnumber[4];
5867  xcardBvertexnumber[6]  = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
5868  xcardBvertexnumber[7]  = xcardBvertexnumber[6];
5869  xcardBvertexnumber[8]  = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
5870  xcardBvertexnumber[9]  = xcardBvertexnumber[8];
5871  xcardBvertexnumber[10] = xcardBvertexnumber[7];
5872  xcardBvertexnumber[11] = xcardBvertexnumber[10];
5873
5874  ycardBvertexnumber[0]  = 0.0;
5875  ycardBvertexnumber[1]  = fgkEndCapInterfaceCardBWidth[0];
5876  ycardBvertexnumber[2]  = ycardBvertexnumber[1];
5877  ycardBvertexnumber[3]  = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
5878  ycardBvertexnumber[4]  = ycardBvertexnumber[3];
5879  ycardBvertexnumber[5]  = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
5880  ycardBvertexnumber[6]  = ycardBvertexnumber[5];
5881  ycardBvertexnumber[7]  = ycardBvertexnumber[4];
5882  ycardBvertexnumber[8]  = ycardBvertexnumber[7];
5883  ycardBvertexnumber[9]  = ycardBvertexnumber[1];
5884  ycardBvertexnumber[10] = ycardBvertexnumber[9];
5885  ycardBvertexnumber[11] = ycardBvertexnumber[0];
5886
5887  TGeoXtru* interfacecardBshape = new TGeoXtru(2);
5888  interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
5889  interfacecardBshape->DefineSection(0,0.);
5890  interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
5891  TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
5892                                                                                          fSSDMountingBlockMedium);
5893  interfacecardB->SetLineColor(46);
5894  // Interface Card B Electronic Board
5895  const Int_t kelectboardcardBvertexnumber = 14;
5896  Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
5897  Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
5898
5899  xelectboardcardBvertex[0]  = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
5900  xelectboardcardBvertex[1]  = xelectboardcardBvertex[0];
5901  xelectboardcardBvertex[2]  = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
5902  xelectboardcardBvertex[3]  = xelectboardcardBvertex[2];
5903  xelectboardcardBvertex[4]  = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
5904  xelectboardcardBvertex[5]  = xelectboardcardBvertex[4];
5905  xelectboardcardBvertex[6]  = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
5906  xelectboardcardBvertex[7]  = xelectboardcardBvertex[6];
5907  xelectboardcardBvertex[8]  = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
5908  xelectboardcardBvertex[9]  = xelectboardcardBvertex[8];
5909  xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
5910  xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
5911  xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
5912  xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
5913
5914  yelectboardcardBvertex[0]  = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
5915  yelectboardcardBvertex[1]  = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
5916  yelectboardcardBvertex[2]  = yelectboardcardBvertex[1];
5917  yelectboardcardBvertex[3]  = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
5918  yelectboardcardBvertex[4]  = yelectboardcardBvertex[3];
5919  yelectboardcardBvertex[5]  = yelectboardcardBvertex[2];
5920  yelectboardcardBvertex[6]  = yelectboardcardBvertex[5];
5921  yelectboardcardBvertex[7]  = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
5922  yelectboardcardBvertex[8]  = yelectboardcardBvertex[7];
5923  yelectboardcardBvertex[9]  = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
5924  yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
5925  yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
5926  yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
5927  yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
5928
5929  TGeoXtru* electboardcardBshape = new TGeoXtru(2);
5930  electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
5931                                                                          xelectboardcardBvertex,yelectboardcardBvertex);
5932  electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
5933  electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
5934                                                                          + fgkEndCapInterfaceElectBoardCardBThickness);
5935  TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
5936                                                                                           fSSDSupportRingAl);
5937  electboardcardB->SetLineColor(fColorAl);
5938  // Generating Stiffener 2
5939  TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
5940                                                                                            0.5*fgkEndCapStiffenerThickness,
5941                                                                                            0.5*fgkEndCapStiffenerLength);
5942  TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
5943  endcapstiffener->SetLineColor(fColorAl);
5944  // Generating Mother Interface Card B Container
5945  const Int_t kinterfacecardBmothervertexnumber = 10;
5946  Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5947  Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5948
5949  xinterfacecardBmothervertex[0] = 0.0;
5950  xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
5951  xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
5952                                                                 + fgkEndCapInterfaceCardBThickness;
5953  xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
5954  xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
5955                                                                 + fgkEndCapInterfaceElectBoardCardBThickness;
5956  xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
5957  xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
5958  xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
5959  xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
5960                                                                 + fgkEndCapCardJMDConnectorLength[0];
5961  xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
5962
5963  yinterfacecardBmothervertex[0] = 0.0;
5964  yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
5965                                                                 + fgkEndCapInterfaceCardBWidth[1]
5966                                                                 + fgkEndCapInterfaceCardBWidth[2];
5967  yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
5968  yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
5969  yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
5970  yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
5971  yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
5972  yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
5973                                                                 + fgkEndCapCardJMDConnectorWidth[0]
5974                                                                 + fgkEndCapCardJMDConnectorWidth[1];
5975  yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
5976  yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
5977  TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
5978  interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
5979                                                                                   xinterfacecardBmothervertex,
5980                                                                                   yinterfacecardBmothervertex);
5981  interfacecardBmothershape->DefineSection(0,-1.e-15);
5982  interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
5983  TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
5984                                                                                                    interfacecardBmothershape,fSSDAir);
5985  electboardcardB->SetLineColor(fColorAl);
5986  // Positioning Volumes Mother Interface Card B Container
5987  TGeoRotation* interfacecardBrot = new TGeoRotation();
5988  TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
5989  interfacecardBrot->SetAngles(90.,-90.,-90.);
5990  interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
5991  TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
5992  TGeoRotation* electboardcardBrot = new TGeoRotation();
5993  TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
5994  electboardcardBrot->SetAngles(90.,90.,-90.);
5995  electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
5996  TGeoCombiTrans* electboardcardBcombitrans =
5997                                   new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
5998  interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
5999  interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6000  TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6001  jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6002  TGeoTranslation* jmdconnectorcardBtrans[3];
6003  TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6004  for(Int_t i=0; i<3; i++){
6005    jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6006                                                          + fgkEndCapCardJMDConnectorLength[0],
6007                                                            fgkEndCapCardElectBoardLayerWidth[1],
6008                                                            0.5*fgkEndCapCardJMDConnectorThickness
6009                                                          + 0.5*(fgkEndCapInterfaceCardBLength[1]
6010                                                          - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6011                                                          + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6012    jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6013                                                                                                            *jmdconnectorcardBrot);
6014    interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6015  }
6016  // Mother Supply Card Container
6017  TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6018  // Interface Card Container
6019  TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6020  // Placing Volumes in Mother Supply Card Container
6021  // JMD Connector Positioning
6022  TGeoTranslation* jmdconnectortrans[2];
6023  for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6024  jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6025                                                                                         fgkEndCapCardElectBoardBackLength[0]
6026                                           -                                             fgkEndCapCardJMDConnectorThickness
6027                                           -                                             fgkEndCapCardJMDConnectorToLayer);
6028  TGeoRotation* jmdconnectorot = new TGeoRotation();
6029  jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6030                                                                  + 2.*fgkEndCapCardJMDConnectorLength[0]
6031                                                                  + 2.*fgkEndCapCardElectBoardLayerThickness,
6032                                                                           fgkEndCapCardElectBoardLayerWidth[1],
6033                                                                       fgkEndCapCardJMDConnectorThickness
6034                                                                  +    fgkEndCapCardJMDConnectorToLayer);
6035  jmdconnectorot->SetAngles(90.,180.,-90);
6036  TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6037                                                                                 * jmdconnectorot);
6038  mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6039  mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6040  // Top Cable Connector Placing
6041  TGeoRotation* cableconnectorot[2];
6042  for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6043  TGeoTranslation* cableconnectortrans[3];
6044  for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6045  cableconnectorot[0]->SetAngles(90.,0.,0.);
6046  cableconnectorot[1]->SetAngles(0.,-90.,0.);
6047  cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6048  TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6049                                                                                                                            *cableconnectorot[0]);
6050  TGeoHMatrix* cableconnectormatrix[2];
6051  for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6052                                                         new TGeoHMatrix((*cableconnectorot[1])
6053                                                                                    *(*cableconnectorcombitrans));
6054  cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6055                                            -                               fgkEndCapCardCableConnectorThickness,
6056                                                                                 fgkEndCapCardCableConnectorLength[0]
6057                                            +                            fgkEndCapCardCableConnectorToLayer);
6058  cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6059                                            -                2.*fgkEndCapCardCableConnectorThickness
6060                                            -                            fgkEndCapCardCableConnectorDistance,
6061                                                                                 fgkEndCapCardCableConnectorLength[0]
6062                                            +                            fgkEndCapCardCableConnectorToLayer);
6063  for(Int_t i=0; i<2; i++){
6064         cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6065     mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6066  }
6067  TGeoRotation* electboardbackrot = new TGeoRotation();
6068  TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6069  electboardbackrot->SetAngles(90.,-90.,-90.);
6070  electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6071                                                         +                fgkEndCapCardJMDConnectorLength[0]
6072                                                         +                fgkEndCapCardElectBoardLayerThickness,0.,0.);
6073  TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6074                                                                                                                            *electboardbackrot);
6075  mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6076  // Electronic Board Kapton Layer Positioning
6077  TGeoRotation* electlayerrot = new TGeoRotation();
6078  TGeoTranslation* electlayertrans[2];
6079  TGeoCombiTrans* electlayercombitrans[2];
6080  for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6081  electlayerrot->SetAngles(90.,-90.,-90.);
6082  electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6083                                                                  + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6084  electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6085                                                                  + 2.*fgkEndCapCardElectBoardLayerThickness
6086                                                                  + fgkEndCapCardElectBoardBackThickness,0.,0.);
6087  for(Int_t i=0; i<2; i++){
6088         electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6089         mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6090  }
6091  // Placing Volumes in Mother Interface Card Container
6092  motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6093  motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6094  for(Int_t i=0; i<2; i++){
6095         motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6096  }
6097  /////////////////////////////////////////////////////////////
6098  // Generation of Card Interface Container
6099  /////////////////////////////////////////////////////////////
6100  Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6101                                                   - fgkEndCapCardJMDConnectorLength[0]
6102                                                   - fgkEndCapInterfaceCardBThickness
6103                                                   - 9.*fgkEndCapStripConnectionThickness
6104                                                   - 8.*fgkEndCapCardElectBoardBackThickness;
6105  const Int_t kcardinterfacecontainervertexnumber = 14;
6106  Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6107  Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6108  xcardinterfacecontainervertex[0]  =-6.5*fgkEndCapCardElectBoardBackThickness
6109                                                                    - 7.0*fgkEndCapStripConnectionThickness;
6110  xcardinterfacecontainervertex[1]  = xcardinterfacecontainervertex[0];
6111  xcardinterfacecontainervertex[2]  = xcardinterfacecontainervertex[1]
6112                                                                    + fgkEndCapStripConnectionThickness
6113                                                                    - fgkEndCapCardElectBoardLayerThickness
6114                                                                    - fgkEndCapCardCableConnectorWidth[0];
6115  xcardinterfacecontainervertex[3]  = xcardinterfacecontainervertex[2];
6116  xcardinterfacecontainervertex[4]  = xcardinterfacecontainervertex[1];
6117  xcardinterfacecontainervertex[5]  = xcardinterfacecontainervertex[4];
6118  xcardinterfacecontainervertex[6]  = 1.5*fgkEndCapCardElectBoardBackThickness
6119                                                                    + 2.0*fgkEndCapStripConnectionThickness;
6120  xcardinterfacecontainervertex[7]  = xcardinterfacecontainervertex[6];
6121  xcardinterfacecontainervertex[8]  = xcardinterfacecontainervertex[7]
6122                                                                    + fgkEndCapInterfaceCardBThickness;
6123  xcardinterfacecontainervertex[9]  = xcardinterfacecontainervertex[8];
6124  xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6125                                                                    + fgkEndCapInterfaceElectBoardCardBThickness;
6126  xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6127  xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6128                                    - fgkEndCapInterfaceElectBoardCardBThickness
6129                                                                    + fgkEndCapCardJMDConnectorLength[0]
6130                                                                    + stiffenertransx+fgkEndCapStiffenerWidth;
6131  xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6132
6133  ycardinterfacecontainervertex[0]  = 0.;
6134  ycardinterfacecontainervertex[1]  = fgkEndCapCardElectBoardLayerWidth[1]
6135                                                                    + fgkEndCapCardJMDConnectorWidth[0]
6136                                                                    + fgkEndCapCardJMDConnectorWidth[1];
6137  ycardinterfacecontainervertex[2]  = ycardinterfacecontainervertex[1];
6138  ycardinterfacecontainervertex[3]  = fgkEndCapCardElectBoardBackWidth[0]
6139                                                                    - fgkEndCapStripConnectionWidth;
6140  ycardinterfacecontainervertex[4]  = ycardinterfacecontainervertex[3];
6141  ycardinterfacecontainervertex[5]  = fgkEndCapCardElectBoardBackWidth[0];
6142  ycardinterfacecontainervertex[6]  = ycardinterfacecontainervertex[5];
6143  ycardinterfacecontainervertex[7]  = fgkEndCapInterfaceCardBWidth[0]
6144                                                                    + fgkEndCapInterfaceCardBWidth[1]
6145                                                                    + fgkEndCapInterfaceCardBWidth[2];
6146  ycardinterfacecontainervertex[8]  = ycardinterfacecontainervertex[7];
6147  ycardinterfacecontainervertex[9]  = yelectboardcardBvertex[3];
6148  ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6149  ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6150  ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6151  ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6152
6153  TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6154  interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6155                                                                                   xcardinterfacecontainervertex,
6156                                                                                   ycardinterfacecontainervertex);
6157  interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6158                                                                            -    fgkEndCapCardElectBoardBackLength[0]));
6159  interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6160                                                                            +    fgkEndCapCardElectBoardBackLength[0]));
6161  TGeoVolume** cardinterfacecontainer;
6162  cardinterfacecontainer = new TGeoVolume*[4];
6163  cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6164                                                                                         interfacecardmothershape,fSSDAir);
6165  cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6166                                                                                         interfacecardmothershape,fSSDAir);
6167  cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6168                                                                                         interfacecardmothershape,fSSDAir);
6169  cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6170                                                                                         interfacecardmothershape,fSSDAir);
6171  /////////////////////////////////
6172  // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6173  // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6174  // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6175  // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6176  /////////////////////////////////
6177  TGeoRotation* endcapstripconnectionrot[2];
6178  for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6179  endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6180  endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6181  TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6182                                                                         *                                 (*endcapstripconnectionrot[0]));
6183  TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6184  endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6185                                                                                         -0.5*fgkEndCapCardElectBoardBackThickness,
6186                                                                                          fgkEndCapCardElectBoardBackWidth[0]
6187                                                                                         -endcapstripconnectionshape->GetDZ(),
6188                                                                                          0.5*fgkEndCapCardElectBoardBackLength[0]);
6189  endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6190  TGeoTranslation* cardinterfacetrans[9];
6191  TGeoHMatrix* cardinterfacematrix[9];
6192  for(Int_t i=0; i<7; i++){
6193         cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6194                                                   +                                                     fgkEndCapCardElectBoardBackThickness),
6195                                                                                                 0.0,0.0);
6196         cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6197                                                    *                             (*endcapstripconnectionmatrix));
6198  }
6199  cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6200                                                   +                                             fgkEndCapCardElectBoardBackThickness),
6201                                                                                                 0.0,0.0);
6202  cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6203                                                 *                                 (*endcapstripconnectionmatrix));
6204  cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6205                                                   +                                             fgkEndCapCardElectBoardBackThickness),
6206                                                                                                 0.0,0.0);
6207  cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6208                                                 *                                 (*endcapstripconnectionmatrix));
6209
6210  for(Int_t i=0; i<4; i++){
6211         cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6212                                                                            cardinterfacematrix[7]);
6213         cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6214                                                                            cardinterfacematrix[8]);
6215  }
6216  TGeoTranslation* mothersupplycardtrans =
6217                                         new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6218                                                                                 + 2.*fgkEndCapCardJMDConnectorLength[0]
6219                                                                                 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6220  TGeoHMatrix* mothersupplycardmatrix[7];
6221  Int_t index[4] = {1,1,1,1};
6222  for(Int_t i=0; i<7; i++){
6223         mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6224                                                         *                                 (*mothersupplycardtrans));
6225         for(Int_t j=0; j<4; j++){
6226                 switch(j){
6227                         case 0: //Layer5 EndCap Left Side
6228                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6229                                                                                                    cardinterfacematrix[i]);
6230                                 if(i!=0){
6231                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6232                                                                                                            mothersupplycardmatrix[i]);
6233                                         index[j]++;
6234
6235                                 }
6236                         break;
6237                         case 1: //Layer5 EndCap Rigth Side
6238                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6239                                                                                                    cardinterfacematrix[i]);
6240                                 if(i>0&&i<6){
6241                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6242                                                                                                            mothersupplycardmatrix[i]);
6243                                         index[j]++;
6244                                 }
6245                         break;
6246                         case 2: //Layer6 EndCap Left Side
6247                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6248                                                                                                    cardinterfacematrix[i]);
6249                                 if(i!=6){
6250                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6251                                                                                                            mothersupplycardmatrix[i]);
6252                                         index[j]++;
6253                                 }
6254                         break;
6255                         case 3: //Layer6 EndCap Right Side
6256                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6257                                                                                                    cardinterfacematrix[i]);
6258                                 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6259                                                                                                    mothersupplycardmatrix[i]);
6260                                 index[j]++;
6261                         break;
6262                 }
6263         }
6264  }
6265  // Positioning Interface
6266  TGeoTranslation* motherinterfacecardtrans =
6267                 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6268                                                          +0.5*fgkEndCapCardElectBoardBackThickness
6269                                                          -fgkEndCapCardElectBoardLayerThickness
6270                                                          +fgkEndCapStripConnectionThickness,0.,0.);
6271  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6272                                         motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6273  // Positioning Interface Card B
6274  TGeoTranslation* interfacecardBmothertrans =
6275                                         new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6276                                                                                 + 2.*fgkEndCapStripConnectionThickness
6277                                                                                         + fgkEndCapCardElectBoardBackThickness,0.,
6278                                                                            -0.5 * (fgkEndCapInterfaceCardBLength[1]
6279                                                                                         -  fgkEndCapCardElectBoardBackLength[0]));
6280  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6281                                                                                                                          interfacecardBmothertrans);
6282  // Positioning Stiffener
6283  TGeoTranslation* endcapstiffenertrans =
6284                                                 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6285                                                                            +    2.0*fgkEndCapStripConnectionThickness
6286                                                                            +    fgkEndCapInterfaceCardBThickness
6287                                                                            +    fgkEndCapCardJMDConnectorLength[0]
6288                                                                            +    stiffenertransx
6289                                                                            +    endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6290                                                                                         endcapstiffenershape->GetDZ()
6291                                                                            -    0.5*(fgkEndCapStiffenerLength
6292                                                                            -    fgkEndCapCardElectBoardBackLength[0]));
6293  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6294  /////////////////////////////////////////////////////////////
6295  // Deallocating memory
6296  /////////////////////////////////////////////////////////////
6297  delete interfacecardBrot;
6298  delete interfacecardBtrans;
6299  delete electboardcardBtrans;
6300  delete electboardcardBrot;
6301  delete jmdconnectorcardBrot;
6302  for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6303  delete jmdconnectorot;
6304  delete jmdconnectortrans[1];
6305  for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6306  delete cableconnectorcombitrans;
6307  delete electboardbacktrans;
6308  delete electboardbackrot;
6309  delete electlayerrot;
6310  for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6311  for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6312  delete mothersupplycardtrans;
6313  for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6314  /////////////////////////////////////////////////////////////
6315  return cardinterfacecontainer;
6316  }
6317  ////////////////////////////////////////////////////////////////////////////////
6318  TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6319   /////////////////////////////////////////////////////////////
6320   // Method returning EndCap Mother Volume
6321   /////////////////////////////////////////////////////////////
6322   const Int_t kendcapcoverplatesmallholenumber = 9;
6323   Double_t endcapmotherorigin[3];
6324   endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6325                                                 +  0.5 *(fgkEndCapCoverPlateLength[3]
6326                                             +  2.0 * fgkEndCapCoverPlateLength[2]);
6327   endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6328                                           -                      fgkEndCapCoverPlateWidth[2]
6329                                           -       (kendcapcoverplatesmallholenumber-1)
6330                                           *        fgkEndCapCoverPlateSmallHoleSeparation[2])
6331                                           +  0.5*(fgkEndCapSideCoverLength[2]
6332                                           +               fgkEndCapCoverPlateWidth[1]
6333                                           -       fgkEndCapCoverPlateWidth[0])
6334                                           -      (fgkEndCapCoverPlateWidth[1]
6335                                           -       fgkEndCapCoverPlateWidth[0]);
6336   endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6337                                                 + 2.*fgkEndCapCoolingTubeRadiusMax
6338                                                 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6339                                                 +      fgkEndCapSideCoverWidth[1]
6340                                                 +      fgkEndCapSideCoverThickness
6341                                                 +      fgkEndCapKaptonFoilThickness);
6342   TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6343                                                           +                              2.0* fgkEndCapCoverPlateLength[2]
6344                                                           +              2.0* fgkEndCapSideCoverThickness),
6345                                                                          0.5* (fgkEndCapSideCoverLength[2]
6346                                                           +                    fgkEndCapCoverPlateWidth[1]
6347                                                           -                                        fgkEndCapCoverPlateWidth[0]),
6348                                                                                          0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6349                                                       +                                    fgkEndCapSideCoverWidth[1]
6350                                                           +                                       fgkEndCapSideCoverThickness
6351                                                       +                                   fgkEndCapKaptonFoilThickness),
6352                                                                                          endcapmotherorigin);
6353   TGeoVolume** endcapassembly;
6354   endcapassembly = new TGeoVolume*[4];
6355   endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6356                                                                                         endcapmothershape,fSSDAir);
6357   endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6358                                                                                         endcapmothershape,fSSDAir);
6359   endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6360                                                                                         endcapmothershape,fSSDAir);
6361   endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6362                                                                                         endcapmothershape,fSSDAir);
6363  /////////////////////////////////
6364  // endcapassembly[0]:  Container End Cap Layer 5 Bellegarde Side
6365  // endcapassembly[1]:  Container End Cap Layer 5 Gex Side
6366  // endcapassembly[2]:  Container End Cap Layer 6 Bellegarde Side
6367  // endcapassembly[3]:  Container End Cap Layer 6 Gex Side
6368  /////////////////////////////////
6369   /////////////////////////////////////////////////////
6370   // Placing Endcap Cover Plate
6371   /////////////////////////////////////////////////////
6372   TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6373   TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6374   endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6375   TGeoCombiTrans* endcapcoverplatecombitrans =
6376                                                   new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6377                                                                                          endcapcoverplaterot);
6378   TGeoTranslation* endcapcoverplatetrans =
6379                                                   new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6380   TGeoHMatrix* endcapcoverplatematrix =
6381                                                   new TGeoHMatrix((*endcapcoverplatetrans)
6382                                                                           *       (*endcapcoverplatecombitrans));
6383   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6384   /////////////////////////////////////////////////////
6385   // Placing Endcap Side Cover
6386   /////////////////////////////////////////////////////
6387   TGeoVolume* endcapsidecover = GetEndCapSideCover();
6388   TGeoRotation* endcapsidecoverot[2];
6389   TGeoCombiTrans* endcapsidecovercombitrans[3];
6390   for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6391   endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6392   endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6393                                                                                         - 0.5*(fgkEndCapCoverPlateWidth[0]
6394                                                                                         - fgkEndCapCoverPlateWidth[2]
6395                                                                                     - (kendcapcoverplatesmallholenumber-1)
6396                                                                                         * fgkEndCapCoverPlateSmallHoleSeparation[2])
6397                                                                                         + 0.*fgkEndCapCoverPlateWidth[0]
6398                                                                                         + fgkEndCapSideCoverLength[2],
6399                                                                                           0.5*(fgkEndCapSideCoverThickness
6400                                                                                         + fgkEndCapCoverPlateThickness)
6401                                                                                         - 0.5*fgkEndCapCoverPlateThickness,
6402                                                                                           endcapsidecoverot[0]);
6403   endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6404   endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6405                                                                                                         0.5*fgkEndCapCoverPlateThickness
6406                                                                                                         -fgkEndCapSideCoverWidth[1],
6407                                                                                                         endcapsidecoverot[1]);
6408   endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6409                                                                                                         +fgkEndCapCoverPlateLength[3]
6410                                                                                                         +2.*fgkEndCapCoverPlateLength[2]
6411                                                                                                         +fgkEndCapSideCoverThickness,0.0,
6412                                                                                                         0.5*fgkEndCapCoverPlateThickness
6413                                                                                                         -fgkEndCapSideCoverWidth[1],
6414                                                                                                         endcapsidecoverot[1]);
6415   TGeoHMatrix* endcapsidecovermatrix[2];
6416   for(Int_t i=0; i<2; i++){
6417    endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6418                                                         *                                 (*endcapsidecovercombitrans[0]));
6419         for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6420                                                                                                                 endcapsidecovermatrix[i]);
6421   }
6422   /////////////////////////////////////////////////////
6423   // Placing Endcap Cooling Tube
6424   /////////////////////////////////////////////////////
6425   TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6426   TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6427   endcapcoolingtuberot->SetAngles(0.,180.,0.);
6428   TGeoCombiTrans* endcapccolingtubecombitrans
6429                                                 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6430                                                 + fgkEndCapCoolingTubeAxialRadius[1])
6431                                                 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6432                                                 - fgkEndCapCoolingTubeToCoverSide,
6433                                                   fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6434                                                 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6435   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6436                                                                                                           endcapccolingtubecombitrans);
6437   /////////////////////////////////////////////////////
6438   // Placing Screws
6439   /////////////////////////////////////////////////////
6440   Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6441                                                                            fgkEndCapCoverPlateScrewRadiusMin};
6442   Int_t screwcoverplatedgesnumber[2] = {20,20};
6443   Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6444                                                                                 fgkEndCapCoverPlateThickness
6445                                                                          +  fgkEndCapCoolingTubeRadiusMax};
6446   TGeoShape* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
6447                                                                                                  screwcoverplatedgesnumber,
6448                                                                                                  screwcoverplatesection);
6449   TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6450                                                                                            screwcoverplateshape,
6451                                                                                            fSSDCoolingTubePhynox);
6452   screwcoverplate->SetLineColor(12);
6453   Double_t transx[4] = {0,
6454                                                 fgkEndCapCoverPlateSmallHoleSeparation[0],
6455                                                 fgkEndCapCoverPlateSmallHoleSeparation[0]
6456                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1],
6457                                          2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6458                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1]};
6459   const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6460 //  TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6461   TGeoTranslation*** endcapcoverplatescrewtrans;
6462   endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6463   Int_t index = 0;
6464   for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6465         endcapcoverplatescrewtrans[i] =
6466                                         new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6467     for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6468                 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6469         if(index==1||index==9||index==28||index==36){
6470                         endcapcoverplatescrewtrans[i][j] =
6471                                 new TGeoTranslation(transx[i],
6472                                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6473                                                                         fgkEndCapSideCoverThickness);
6474                 }
6475                 else{
6476                         endcapcoverplatescrewtrans[i][j] =
6477                                 new TGeoTranslation(transx[i],
6478                                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6479                                                                         0.);
6480                 }
6481             if(index!=19)
6482                 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6483                                                                                           endcapcoverplatescrewtrans[i][j]);
6484         }
6485   }
6486   /////////////////////////////////////////////////////
6487   // Placing Cover Plate Clips
6488   /////////////////////////////////////////////////////
6489   TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6490                                                                                                          0.5*fgkEndCapCoverPlateClipWidth,
6491                                                                                                          0.5*fgkEndCapSideCoverThickness);
6492   TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6493                                                                                                         endcapcoverplateclipshape,
6494                                                                                                         fSSDCoolingTubePhynox);
6495   TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6496                                                                                                          0.5*fgkEndCapCoverPlateDownClipWidth,
6497                                                                                                          0.5*fgkEndCapSideCoverThickness);
6498   TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6499                                                                                                         endcapcoverplatedownclipshape,
6500                                                                                                         fSSDCoolingTubePhynox);
6501   TGeoTranslation* endcapcoverplatecliptrans[4];
6502   endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6503                                                            -                     fgkEndCapCoverPlateLength[0]
6504                                                            -                     fgkEndCapSideCoverThickness,
6505                                                                                                          0.0,
6506                                                                                                  0.5*(fgkEndCapSideCoverThickness
6507                                                            +                                              fgkEndCapCoverPlateThickness));
6508   endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6509                                                            -                     fgkEndCapCoverPlateLength[0]
6510                                                            -                     fgkEndCapSideCoverThickness,
6511                                                                                                          (kendcapcoverplatescrewnumber[1]-1)
6512                                                            *                                     fgkEndCapSideCoverWidth[5],
6513                                                                                                  0.5*(fgkEndCapSideCoverThickness
6514                                                            +                                              fgkEndCapCoverPlateThickness));
6515   endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6516                                                            -                     fgkEndCapCoverPlateLength[0]
6517                                                            +                                     fgkEndCapCoverPlateLength[1]
6518                                                            +                              2.*fgkEndCapCoverPlateLength[0]
6519                                                            -                                     fgkEndCapCoverPlateClipLength
6520                                                            +                                 fgkEndCapSideCoverThickness,
6521                                                                                                          0.0,
6522                                                                                                  0.5*(fgkEndCapSideCoverThickness
6523                                                            +                                              fgkEndCapCoverPlateThickness));
6524   endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6525                                                            -                     fgkEndCapCoverPlateLength[0]
6526                                                            +                                     fgkEndCapCoverPlateLength[1]
6527                                                            +                              2.*fgkEndCapCoverPlateLength[0]
6528                                                            -                                     fgkEndCapCoverPlateClipLength
6529                                                            +                                 fgkEndCapSideCoverThickness,
6530                                                                                                          (kendcapcoverplatescrewnumber[1]-1)
6531                                                            *                                     fgkEndCapSideCoverWidth[5],
6532                                                                                                  0.5*(fgkEndCapSideCoverThickness
6533                                                            +                                              fgkEndCapCoverPlateThickness));
6534   endcapcoverplateclip->SetLineColor(fColorPhynox);
6535   endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6536   for(Int_t i=0; i<4; i++)
6537         for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6538                                                                                                    endcapcoverplatecliptrans[i]);
6539   TGeoTranslation* endcapcoverplatedowncliptrans[4];
6540   endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6541                                                                    -                     fgkEndCapCoverPlateLength[0]
6542                                                                    -                     fgkEndCapSideCoverThickness,
6543                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6544                                                                    -                                 fgkEndCapCoverPlateClipWidth),
6545                                                                                                         0.5*(fgkEndCapSideCoverThickness
6546                                                                +                                         fgkEndCapCoverPlateThickness)
6547                                                                    -                     fgkEndCapSideCoverWidth[1]
6548                                                                    -                                     fgkEndCapSideCoverThickness);
6549   endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6550                                                                    -                     fgkEndCapCoverPlateLength[0]
6551                                                                    -                     fgkEndCapSideCoverThickness,
6552                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6553                                                                    -                                 fgkEndCapCoverPlateClipWidth)
6554                                                                    +                            fgkEndCapSideCoverLength[2]
6555                                                                    -                            fgkEndCapCoverPlateDownClipWidth,
6556                                                                                                         0.5*(fgkEndCapSideCoverThickness
6557                                                                +                                         fgkEndCapCoverPlateThickness)
6558                                                                    -                     fgkEndCapSideCoverWidth[1]
6559                                                                    -                                     fgkEndCapSideCoverThickness);
6560   endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6561                                                                    -                     fgkEndCapCoverPlateLength[0]
6562                                                                    +                     fgkEndCapSideCoverThickness
6563                                                                    +                     fgkEndCapCoverPlateLength[1]
6564                                                                    +                 2.0*fgkEndCapCoverPlateLength[0]
6565                                                                    -                     fgkEndCapCoverPlateDownClipLength,
6566                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6567                                                                    -                                 fgkEndCapCoverPlateClipWidth),
6568                                                                                                         0.5*(fgkEndCapSideCoverThickness
6569                                                                +                                         fgkEndCapCoverPlateThickness)
6570                                                                    -                     fgkEndCapSideCoverWidth[1]
6571                                                                    -                                     fgkEndCapSideCoverThickness);
6572   endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6573                                                                    -                     fgkEndCapCoverPlateLength[0]
6574                                                                    +                     fgkEndCapSideCoverThickness
6575                                                                    +                     fgkEndCapCoverPlateLength[1]
6576                                                                    +                 2.0*fgkEndCapCoverPlateLength[0]
6577                                                                    -                     fgkEndCapCoverPlateDownClipLength,
6578                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6579                                                                    -                                 fgkEndCapCoverPlateClipWidth)
6580                                                                    +                                 fgkEndCapSideCoverLength[2]
6581                                                                    -                                 fgkEndCapCoverPlateDownClipWidth,
6582                                                                                                         0.5*(fgkEndCapSideCoverThickness
6583                                                                +                                         fgkEndCapCoverPlateThickness)
6584                                                                    -                     fgkEndCapSideCoverWidth[1]
6585                                                                    -                                     fgkEndCapSideCoverThickness);
6586   for(Int_t i=0; i<4; i++)
6587         for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6588                                                                                                    endcapcoverplatedowncliptrans[i]);
6589   /////////////////////////////////////////////////////
6590   // Placing Kapton Foil
6591   /////////////////////////////////////////////////////
6592   TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6593                                                                                                  0.5*fgkEndCapKaptonFoilWidth,
6594                                                                                                  0.5*fgkEndCapKaptonFoilThickness);
6595   TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6596                                                                                                 endcapkaptonfoilshape,
6597                                                                                                 fSSDKaptonFlexMedium);
6598   endcapkaptonfoil->SetLineColor(8);
6599   TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6600                                                                                                                            0.5*fgkEndCapKaptonFoilWidth
6601                                                                                  -                     0.5*fgkEndCapCoverPlateClipWidth,
6602                                                                                                                            0.5*fgkEndCapCoverPlateThickness
6603                                                                                  -                     0.5*fgkEndCapKaptonFoilThickness
6604                                                                              -                     fgkEndCapSideCoverWidth[1]
6605                                                                                  -                     fgkEndCapSideCoverThickness);
6606   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6607   /////////////////////////////////////////////////////////////
6608   // Placing Electronic Tubes
6609   /////////////////////////////////////////////////////////////
6610   Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6611                                                                              - fgkEndCapInterfaceCardBThickness
6612                                                                              - 9.*fgkEndCapStripConnectionThickness
6613                                                                              - 8.*fgkEndCapCardElectBoardBackThickness,
6614                                                                                fgkEndCapKaptonFoilWidth
6615                                                                              - fgkEndCapInterfaceCardBThickness
6616                                                                              - 9.*fgkEndCapStripConnectionThickness
6617                                                                              - 8.*fgkEndCapCardElectBoardBackThickness
6618                                                                                  - fgkEndCapInterfaceElectBoardCardBThickness};
6619   TGeoVolume* endcapeffectivecables[2];
6620   endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6621                                                                                          fgkEndCapEffectiveCableRadiusMax,
6622                                                                                          endcapeffectivecableswidth[0],
6623                                                                                          10,"EndCapEffectiveCables1");
6624   endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6625                                                                                          fgkEndCapEffectiveCableRadiusMax,
6626                                                                                          endcapeffectivecableswidth[1],
6627                                                                                          25,"EndCapEffectiveCables2");
6628   TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6629   TGeoTranslation* endcapeffectivecablestrans[2];
6630   endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6631                                           -                                                        0.5*endcapeffectivecableswidth[0]
6632                                           -                            0.5*(fgkEndCapCoverPlateWidth[0]
6633                                           -                                                               fgkEndCapCoverPlateWidth[2]
6634                                           -                                             (kendcapcoverplatesmallholenumber-1)
6635                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6636                                           +                                             fgkEndCapSideCoverLength[2],
6637                                           -                     0.5*fgkEndCapCoverPlateThickness
6638                                           -                                             (fgkEndCapCardElectBoardBackWidth[0]
6639                                           -                                              fgkEndCapInterfaceCardBWidth[0]
6640                                           -                                              fgkEndCapInterfaceCardBWidth[1]));
6641   endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6642                                           -                                                        0.5*endcapeffectivecableswidth[1]
6643                                           -                            0.5*(fgkEndCapCoverPlateWidth[0]
6644                                           -                                                               fgkEndCapCoverPlateWidth[2]
6645                                           -                                             (kendcapcoverplatesmallholenumber-1)
6646                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6647                                           +                                         fgkEndCapSideCoverLength[2],
6648                                           -                     0.5*fgkEndCapCoverPlateThickness
6649                                           -                                             (fgkEndCapCardElectBoardBackWidth[0]
6650                                           -                                              fgkEndCapInterfaceCardBWidth[0])
6651                                           -                     0.5*fgkEndCapInterfaceCardBWidth[2]);
6652   endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6653   TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6654   endcapeffectivecablescombitrans[0]  = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6655                                                                                                                    *endcapeffectivecablesrot);
6656   endcapeffectivecablescombitrans[1]  = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6657                                                                                                                    *endcapeffectivecablesrot);
6658 //  for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6659 //                                                                                                        endcapeffectivecablescombitrans[0]);
6660   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6661                                                                                                           endcapeffectivecablescombitrans[1]);
6662   /////////////////////////////////////////////////////////////
6663   // Placing End Cap Cards
6664   /////////////////////////////////////////////////////////////
6665   TGeoVolume** endcapcards = GetEndCapCards();
6666   TGeoRotation* endcapcardsrot[2];
6667   for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6668   endcapcardsrot[0]->SetAngles(90.,0.,0.);
6669   TGeoTranslation* endcapcardstrans[2];
6670   endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6671                                                                                         -  fgkEndCapCardElectBoardBackLength[0]));
6672   TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6673   endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6674   TGeoHMatrix* endcapcardsmatrix[2];
6675   endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6676   Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6677                                                   - fgkEndCapCardJMDConnectorLength[0]
6678                                                   - fgkEndCapInterfaceCardBThickness
6679                                                   - 9.*fgkEndCapStripConnectionThickness
6680                                                   - 8.*fgkEndCapCardElectBoardBackThickness;
6681   endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6682                                           -                                             fgkEndCapCoverPlateLength[0]
6683                                           + 0.5 *              (fgkEndCapCoverPlateLength[3]
6684                                           + 2.0 *                               fgkEndCapCoverPlateLength[2]),
6685                                           -                                                     stiffenertransx-fgkEndCapStiffenerWidth
6686                                           -                                                               fgkEndCapCardJMDConnectorLength[0]
6687                                           -                                                               fgkEndCapInterfaceCardBThickness
6688                                           -     2.0 *                                             fgkEndCapStripConnectionThickness
6689                                           - 1.5 *                                             fgkEndCapInterfaceCardBThickness
6690                                           - 0.5 *                                                (fgkEndCapCoverPlateWidth[0]
6691                                           -                                                               fgkEndCapCoverPlateWidth[2]
6692                                           -                                             (kendcapcoverplatesmallholenumber-1)
6693                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6694                                           +                     fgkEndCapKaptonFoilWidth,
6695                                                                                           0.5*fgkEndCapCoverPlateThickness
6696                                           -                                                     fgkEndCapSideCoverWidth[1]);
6697   endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6698   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6699    /////////////////////////////////////////////////////////////
6700   // Deallocating memory
6701   /////////////////////////////////////////////////////////////
6702   delete endcapcoverplaterot;
6703   delete endcapcoverplatecombitrans;
6704   delete endcapcoverplatetrans;
6705   for(Int_t i=0; i<3; i++){
6706    delete endcapsidecovercombitrans[i];
6707    if(i<2) delete endcapsidecoverot[i];
6708   }
6709   for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6710   for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6711   delete endcapcardsmatrix[0];
6712   return endcapassembly;
6713  }
6714  ////////////////////////////////////////////////////////////////////////////////
6715  TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6716                                                                                                                         Double_t radiusmax,
6717                                                                                                                         Double_t width,
6718                                                                                                                         Int_t ncables,
6719                                                                                                                         const char* volname){
6720   /////////////////////////////////////////////////////////////
6721   // Generating EndCap High Voltage Tubes
6722   /////////////////////////////////////////////////////////////
6723   Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
6724   Double_t effectiveouteradius = TMath::Sqrt(effectiveinneradius*effectiveinneradius+(radiusmax-radiusmin)*(radiusmax-radiusmin));
6725
6726   TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6727   TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6728                                                                                                    effectiveouteradius,0.5*width);
6729   TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6730                                                                                                 effectiveinnertubeshape,
6731                                                                                                 fSSDStiffenerConnectorMedium);
6732   effectiveinnertube->SetLineColor(41);
6733   TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6734                                                                                                 effectiveoutertubeshape,
6735                                                                                                 fSSDKaptonChipCableMedium);
6736   effectiveoutertube->SetLineColor(39);
6737   TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6738   TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6739   effectivemothertube->AddNode(effectiveinnertube,1);
6740   effectivemothertube->AddNode(effectiveoutertube,1);
6741   return effectivemothertube;
6742  }
6743  ////////////////////////////////////////////////////////////////////////////////
6744  TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6745   /////////////////////////////////////////////////////////////
6746   // Generating EndCap Support Layer 5 and Layer 6
6747   /////////////////////////////////////////////////////////////
6748   const Int_t knedges = 5;
6749   ///////////////////////////////////////////////
6750   // Setting the vertices for TGeoXtru Up Volume
6751   ///////////////////////////////////////////////
6752   const Int_t klayernumber = 2;
6753   Double_t xupvertex[klayernumber][knedges+3];
6754   Double_t yupvertex[klayernumber][knedges+3];
6755   Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6756   Double_t middledgeangle[klayernumber] = {0.0,0.0};
6757   Double_t middlepsi[klayernumber] = {0.0,0.0};
6758   for(Int_t i=0; i<klayernumber; i++){
6759         xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6760         xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6761         xupvertex[i][2] = -xupvertex[i][1];
6762         xupvertex[i][3] = -xupvertex[i][0];
6763
6764         yupvertex[i][0] =  fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6765         yupvertex[i][1] =  0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6766         yupvertex[i][2] =  yupvertex[i][1];
6767         yupvertex[i][3] =  yupvertex[i][0];
6768
6769     middledgeangle[i] = upedgeangle[i]/knedges;
6770     middlepsi[i] = 90.0-0.5*upedgeangle[i];
6771     for(Int_t j=1; j<knedges; j++){
6772                 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6773                 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6774         }
6775   }
6776   ////////////////////////////////////
6777   // Generating Up TGeoXtru
6778   ////////////////////////////////////
6779   TGeoXtru* upendcapsupportshape[klayernumber];
6780   TGeoVolume* upendcapsupport[klayernumber];
6781   char upendcapsupportname[100];
6782   for(Int_t i=0; i<klayernumber; i++){
6783    upendcapsupportshape[i] = new TGeoXtru(2);
6784    snprintf(upendcapsupportname,100,"UpEndCapSupportPieceLayer%i",i+5);
6785    upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6786    upendcapsupportshape[i]->DefineSection(0,0.);
6787    upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6788    upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
6789                                                                         fSSDSupportRingAl);
6790    upendcapsupport[i]->SetLineColor(5);
6791   }
6792   ///////////////////////////////////////////////
6793   // Setting the vertices for TGeoXtru Down Volume
6794   ///////////////////////////////////////////////
6795   Double_t xdownvertex[klayernumber][2*(knedges+1)];
6796   Double_t ydownvertex[klayernumber][2*(knedges+1)];
6797   for(Int_t i=0; i<klayernumber; i++){
6798         xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6799         xdownvertex[i][1] =  xupvertex[i][0];
6800         ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6801         ydownvertex[i][1] =  yupvertex[i][0];
6802         for(Int_t j=0; j<knedges; j++){
6803                 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6804                 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6805         }
6806         for(Int_t j=0; j<knedges; j++){
6807                 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6808                                                                         * CosD(middlepsi[i]+j*middledgeangle[i]);
6809                 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6810                                                                         * SinD(middlepsi[i]+j*middledgeangle[i]);
6811         }
6812   }
6813   ////////////////////////////////////
6814   // Generating Down TGeoXtru
6815   ////////////////////////////////////
6816   TGeoXtru* downendcapsupportshape[klayernumber];
6817   TGeoVolume* downendcapsupport[klayernumber];
6818   char downendcapsupportname[100];
6819   for(Int_t i=0; i<klayernumber; i++){
6820         downendcapsupportshape[i] = new TGeoXtru(2);
6821         snprintf(downendcapsupportname,100,"DownEndCapSupportPieceLayer%i",i+5);
6822         downendcapsupportshape[i] = new TGeoXtru(2);
6823         downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
6824     if(i==0){
6825                 downendcapsupportshape[i]->DefineSection(0,0.);
6826                 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
6827     }
6828         else{
6829                 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
6830                                                                  -                 fgkEndCapSupportLowWidth[i]);
6831                 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6832         }
6833     downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
6834                                                                 downendcapsupportshape[i],fSSDSupportRingAl);
6835         downendcapsupport[i]->SetLineColor(5);
6836   }
6837   ///////////////////////////////////////////////
6838   // Setting TGeoPgon Volume
6839   ///////////////////////////////////////////////
6840   const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6841                                                                                                    fgkSSDLay6LadderNumber};
6842   TGeoPgon* endcapsupportmothershape[klayernumber];
6843   TGeoVolume** endcapsupportmother;
6844   endcapsupportmother = new TGeoVolume*[klayernumber];
6845   char endcapsupportmothername[100];
6846   for(Int_t i=0; i<klayernumber; i++){
6847         endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6848         snprintf(endcapsupportmothername,100,"EndCapSupportMotherLayer%i",i+5);
6849         endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
6850     endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
6851                                                                                           ydownvertex[i][0],yupvertex[i][1]);
6852     endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
6853                                                                                         fSSDAir);
6854   }
6855   ////////////////////////////////////
6856   TGeoRotation** endcapsupportrot[klayernumber];
6857   for(Int_t i=0; i<2; i++){
6858         endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
6859         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6860            endcapsupportrot[i][j] = new TGeoRotation();
6861            endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
6862        endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
6863        endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
6864         }
6865   }
6866   return endcapsupportmother;
6867  }
6868  ////////////////////////////////////////////////////////////////////////////////
6869  void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
6870   /////////////////////////////////////////////////////////////
6871   // Setting End Cap Support Layer 5 and 6.
6872   /////////////////////////////////////////////////////////////
6873   const Int_t kendcapcoverplatesmallholenumber = 9;
6874   const Int_t klayernumber = 2;
6875   const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6876                                                                                                    fgkSSDLay6LadderNumber};
6877   Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
6878                                                                                 360.0/kssdlayladdernumber[1]};
6879   TGeoVolume** endcapsupport = EndCapSupport();
6880   TGeoVolume** endcapassembly = GetEndCapAssembly();
6881   TGeoPgon* endcapsupportshape[klayernumber];
6882   Double_t* radiusmin[klayernumber];
6883   Double_t* radiusmax[klayernumber];
6884   for(Int_t i=0; i<klayernumber; i++){
6885     endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
6886         radiusmin[i] = endcapsupportshape[i]->GetRmin();
6887         radiusmax[i] = endcapsupportshape[i]->GetRmax();
6888   }
6889   TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
6890   Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
6891                                                                           endcapassemblyshape->GetDY(),
6892                                                                           endcapassemblyshape->GetDZ()};
6893   ///////////////////////////////////////////////
6894   // Setting TGeoPgon Volume for Mother Container
6895   ///////////////////////////////////////////////
6896   TGeoPgon* endcapsupportsystemshape[klayernumber];
6897   char endcapsupportsystemothername[100];
6898   for(Int_t i=0; i<klayernumber; i++){
6899         endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6900         snprintf(endcapsupportsystemothername,100,"EndCapSupportSystemLayer%i",i+5);
6901         endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
6902                                                                                              - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
6903                                                                                           (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6904                                                                                            +2.*endcapassemblycenter[2])
6905                                                                                            /CosD(0.5*upedgeangle[i]));
6906     endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
6907                                                                                                  -(fgkEndCapCoverPlateWidth[1]
6908                                                                                              - fgkEndCapCoverPlateWidth[0]),
6909                                                                                            *radiusmin[i],
6910                                                                                           (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6911                                                                                            +2.*endcapassemblycenter[2])
6912                                                                                            /CosD(0.5*upedgeangle[i]));
6913   }
6914   fgkEndCapSupportSystem = new TGeoVolume*[4];
6915   fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
6916                                                                           endcapsupportsystemshape[0],fSSDAir);
6917   fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
6918                                                                           endcapsupportsystemshape[0],fSSDAir);
6919   fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
6920                                                                           endcapsupportsystemshape[1],fSSDAir);
6921   fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
6922                                                                           endcapsupportsystemshape[1],fSSDAir);
6923   ///////////////////////////////////////////////
6924   TGeoTranslation* endcapassemblytrans[klayernumber];
6925   for(Int_t i=0; i<klayernumber; i++)
6926         endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
6927                                                                            -  fgkEndCapSideCoverThickness
6928                                                                            +  endcapassemblycenter[0],
6929                                                                            -  0.5*fgkEndCapCoverPlateThickness
6930                                                                            -  2.0*fgkEndCapCoolingTubeRadiusMax
6931                                                                            +  2.0*endcapassemblycenter[2]
6932                                                                            +  0.5*fgkEndCapSupportLength[i]
6933                                                                            /  TanD(0.5*upedgeangle[i]),
6934                                                                                   0.5*(fgkEndCapCoverPlateWidth[0]
6935                                                                            -  fgkEndCapCoverPlateWidth[2]
6936                                                                            - (kendcapcoverplatesmallholenumber-1)
6937                                                                            *  fgkEndCapCoverPlateSmallHoleSeparation[2]));
6938   TGeoRotation** endcapassemblyrot[klayernumber];
6939   TGeoHMatrix** endcapassemblymatrix[klayernumber];
6940   for(Int_t i=0; i<klayernumber; i++){
6941    endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
6942    endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
6943    for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
6944    endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
6945    endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
6946    endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
6947    endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
6948    for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6949         endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
6950         endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
6951    }
6952   }
6953   TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
6954                                                         fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
6955   for(Int_t i=0; i<2*klayernumber; i++){
6956         for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
6957                 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
6958                                                                                                                                            endcapassemblymatrix[1][j+2]);
6959         }
6960         fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
6961   }
6962    /////////////////////////////////////////////////////////////
6963   // Deallocating memory
6964   /////////////////////////////////////////////////////////////
6965   for(Int_t i=0; i<klayernumber; i++){
6966         for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
6967                 delete endcapassemblyrot[i][j];
6968         }
6969         delete [] endcapassemblyrot[i];
6970         delete endcapassemblymatrix[i][0];
6971         delete endcapassemblymatrix[i][1];
6972   }
6973   /////////////////////////////////////////////////////////////
6974   }
6975   void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
6976   /////////////////////////////////////////////////////////////
6977   // Setting End Cap Support + End Cap Assembly of Layer 5.
6978   /////////////////////////////////////////////////////////////
6979   if (! moth) {
6980     AliError("Can't insert end cap support of layer5, mother is null!\n");
6981     return;
6982   };
6983   if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
6984   TGeoTranslation* endcapsupportsystemITSCentertrans[2];
6985   endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
6986                                                                                                 fgkEndCapSupportCenterLay5ITSPosition
6987                                                                            +            fgkEndCapSupportCenterLay5Position
6988                                                                            -            fgkEndCapSideCoverLength[2]);
6989   endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
6990                                                                                                 fgkEndCapSideCoverLength[2]
6991                                                                            -        fgkEndCapSupportCenterLay5Position
6992                                                                            -        fgkEndCapSupportCenterLay5ITSPosition);
6993   TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
6994   endcapsupportsystemrot->SetAngles(90.,180.,-90.);
6995   TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
6996         new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
6997   moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
6998   moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
6999    /////////////////////////////////////////////////////////////
7000   // Deallocating memory
7001   /////////////////////////////////////////////////////////////
7002   delete endcapsupportsystemrot;
7003   delete endcapsupportsystemITSCentertrans[1];
7004  }
7005   /////////////////////////////////////////////////////////////
7006   void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7007   /////////////////////////////////////////////////////////////
7008   // Setting End Cap Support + End Cap Assembly of Layer 6.
7009   /////////////////////////////////////////////////////////////
7010   if (! moth) {
7011     AliError("Can't insert end cap support of layer6, mother is null!\n");
7012     return;
7013   };
7014   if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
7015   TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7016   endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7017                                                                                                 fgkEndCapSupportCenterLay6ITSPosition
7018                                                                            +            fgkEndCapSupportCenterLay6Position
7019                                                                            -            fgkEndCapSideCoverLength[2]);
7020   endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7021                                                                                                 fgkEndCapSideCoverLength[2]
7022                                                                            -        fgkEndCapSupportCenterLay6Position
7023                                                                            -        fgkEndCapSupportCenterLay6ITSPosition);
7024   TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7025   endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7026   TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7027         new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7028   moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7029   moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7030    /////////////////////////////////////////////////////////////
7031   // Deallocating memory
7032   /////////////////////////////////////////////////////////////
7033   delete endcapsupportsystemrot;
7034   delete endcapsupportsystemITSCentertrans[1];
7035  }
7036  ////////////////////////////////////////////////////////////////////////////////
7037  void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7038   /////////////////////////////////////////////////////////////
7039   // Setting Ladder Support of Layer 5.
7040   /////////////////////////////////////////////////////////////
7041   if (! moth) {
7042     AliError("Can't insert ladder lupport of layer5, mother is null!\n");
7043     return;
7044   };
7045   if(!fLay5LadderSupportRing) SetLadderSupport(100);
7046   fMotherVol = moth;
7047   TGeoTranslation* centerITSRingSupportLay5trans[2];
7048   for(Int_t i=0; i<2; i++){
7049         centerITSRingSupportLay5trans[i] =
7050                 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7051     moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7052   }
7053  }
7054  ////////////////////////////////////////////////////////////////////////////////
7055  void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7056   /////////////////////////////////////////////////////////////
7057   // Setting Ladder Support of Layer 6.
7058   /////////////////////////////////////////////////////////////
7059   if (! moth) {
7060     AliError("Can't insert ladder lupport of layer6, mother is null!\n");
7061     return;
7062   };
7063   if(!fLay6LadderSupportRing) SetLadderSupport(100);
7064   fMotherVol = moth;
7065   TGeoTranslation* centerITSRingSupportLay6trans[2];
7066   for(Int_t i=0; i<2; i++){
7067         centerITSRingSupportLay6trans[i] =
7068                 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7069     moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7070   }
7071  }
7072  ////////////////////////////////////////////////////////////////////////////////
7073  void AliITSv11GeometrySSD::SSDCone(TGeoVolume* moth){
7074   /////////////////////////////////////////////////////////////
7075   // Setting Ladder Support of Layer 6.
7076   /////////////////////////////////////////////////////////////
7077   if (! moth) {
7078     AliError("Can't insert SSD Cone, mother is null!\n");
7079     return;
7080   };
7081   if(!fSSDCone) SetSSDCone();
7082   TGeoTranslation* ssdconetrans = new TGeoTranslation(0.,0.,0.5*fgkSSDCentralSupportLength
7083                                                                 +                                         fgkSSDCentralAL3SupportLength);
7084     moth->AddNode(fSSDCone,1,ssdconetrans);
7085 }
7086  ////////////////////////////////////////////////////////////////////////////////
7087  void AliITSv11GeometrySSD::SetSSDCone(){
7088   /////////////////////////////////////////////////////////////
7089   // Method generating SSDCone
7090   /////////////////////////////////////////////////////////////
7091   if(!fCreateMaterials) CreateMaterials();
7092   fSSDCone = new TGeoVolumeAssembly("ITSssdCone");
7093   Double_t ssdpconesectionradiusmax[16];
7094   Double_t ssdpconesectionradiusmin[16];
7095   Double_t ssdpconezsection[16];
7096   TGeoPcon* ssdpconelittleholeshape[8];
7097   TGeoVolume* ssdpconelittlehole[8];
7098   ssdpconezsection[0] = (fgkSSDPConeZLength[0]-fgkSSDPConeZLength[1]);
7099   ssdpconesectionradiusmin[0] = fgkSSDLowerPConeRadius;
7100   ssdpconesectionradiusmax[0] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7101                                                       / SinD(fgkSSDPConeAngle)
7102                                                           + ssdpconesectionradiusmin[0];
7103   ssdpconesectionradiusmin[1] = fgkSSDPConeLittleHoleRadius
7104                                                           - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7105                                                           / SinD(fgkSSDPConeAngle);
7106   ssdpconesectionradiusmax[1] = fgkSSDPConeLittleHoleRadius;
7107   ssdpconezsection[1] = (ssdpconesectionradiusmin[1]-ssdpconesectionradiusmin[0])
7108                                           * TanD(fgkSSDPConeAngle)+ssdpconezsection[0];
7109   ssdpconelittleholeshape[0] = new TGeoPcon(0.,360.,2);
7110   for(Int_t i=0; i<2;i++) ssdpconelittleholeshape[0]->DefineSection(i,ssdpconezsection[i],
7111                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7112   ssdpconelittlehole[0] = new TGeoVolume("SSDConeLittleHole1",ssdpconelittleholeshape[0],fSSDCarbonFiberMedium);
7113   ssdpconelittlehole[0]->SetLineColor(4);
7114   /////////////////////////////////////////////////////////////
7115   ssdpconezsection[2] = ssdpconezsection[1];
7116   ssdpconesectionradiusmin[2] = ssdpconesectionradiusmin[1];
7117   ssdpconesectionradiusmax[2] = ssdpconesectionradiusmax[1];
7118   ssdpconesectionradiusmin[3] = fgkSSDPConeLittleHoleRadius+fgkSSDPConeLittleHoleLength
7119                                                           - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7120                                                           / SinD(fgkSSDPConeAngle);
7121   ssdpconesectionradiusmax[3] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7122                                                           / SinD(fgkSSDPConeAngle)+ssdpconesectionradiusmin[3];
7123   ssdpconezsection[3] = (ssdpconesectionradiusmin[3]-ssdpconesectionradiusmin[2])
7124                                           * TanD(fgkSSDPConeAngle)+ssdpconezsection[2];
7125   Double_t ssdpconelittleholeangle = fgkSSDPConeLittleHoleLength/fgkSSDPConeLittleHoleRadius
7126                                                                    * TMath::RadToDeg();
7127   ssdpconelittleholeshape[1] = new TGeoPcon(30.+0.5*ssdpconelittleholeangle,
7128                                                                                                           60.-ssdpconelittleholeangle,2);
7129   for(Int_t i=2;i<4;i++) ssdpconelittleholeshape[1]->DefineSection(i-2,ssdpconezsection[i],
7130                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7131   ssdpconelittlehole[1] = new TGeoVolume("SSDConeLittleHole2",ssdpconelittleholeshape[1],fSSDCarbonFiberMedium);
7132   ssdpconelittlehole[1]->SetLineColor(4);
7133   TGeoRotation* ssdconelittleholerot[6];
7134   for(Int_t i=0; i<6; i++){
7135         ssdconelittleholerot[i] = new TGeoRotation();
7136     ssdconelittleholerot[i]->SetAngles(i*60,0.,0.);
7137   }
7138   /////////////////////////////////////////////////////////////
7139   ssdpconezsection[4] = ssdpconezsection[3];
7140   ssdpconesectionradiusmin[4] = ssdpconesectionradiusmin[3];
7141   ssdpconesectionradiusmax[4] = ssdpconesectionradiusmax[3];
7142   ssdpconesectionradiusmin[5] = fgkSSDConeMiddleRadius-ssdpconezsection[0]
7143                                                           * CosD(fgkSSDPConeAngle)
7144                                                           / SinD(fgkSSDPConeAngle);
7145   ssdpconesectionradiusmax[5] = fgkSSDConeMiddleRadius;
7146   ssdpconezsection[5] = (ssdpconesectionradiusmin[5]-ssdpconesectionradiusmin[4])
7147                                           * TanD(fgkSSDPConeAngle)+ssdpconezsection[4];
7148   ssdpconelittleholeshape[2] = new TGeoPcon(0.,360.,2);
7149   for(Int_t i=4; i<6;i++) ssdpconelittleholeshape[2]->DefineSection(i-4,ssdpconezsection[i],
7150                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7151   ssdpconelittlehole[2] = new TGeoVolume("SSDConeLittleHole3",ssdpconelittleholeshape[2],fSSDCarbonFiberMedium);
7152   ssdpconelittlehole[2]->SetLineColor(4);
7153   ///////////////////////////////////////////////////
7154   ssdpconezsection[6] = ssdpconezsection[5];
7155   ssdpconesectionradiusmin[6] = ssdpconesectionradiusmin[5];
7156   ssdpconesectionradiusmax[6] = ssdpconesectionradiusmax[5];
7157   ssdpconesectionradiusmin[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength
7158                                                           -ssdpconezsection[0]
7159                                                           * CosD(fgkSSDPConeAngle)
7160                                                           / SinD(fgkSSDPConeAngle);
7161   ssdpconesectionradiusmax[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength;
7162   ssdpconezsection[7] = (ssdpconesectionradiusmin[7]-ssdpconesectionradiusmin[6])
7163                                           * TanD(fgkSSDPConeAngle)+ssdpconezsection[6];
7164   Double_t ssdpconemiddleholeangle = fgkSSDPConeMiddleWidth/fgkSSDConeMiddleRadius
7165                                                                    * TMath::RadToDeg();
7166   ssdpconelittleholeshape[3] = new TGeoPcon(22.5+0.5*ssdpconemiddleholeangle,
7167                                                                                                           45.-ssdpconemiddleholeangle,2);
7168   for(Int_t i=6;i<8;i++) ssdpconelittleholeshape[3]->DefineSection(i-6,ssdpconezsection[i],
7169                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7170   ssdpconelittlehole[3] = new TGeoVolume("SSDConeLittleHole4",ssdpconelittleholeshape[3],fSSDCarbonFiberMedium);
7171   ssdpconelittlehole[3]->SetLineColor(4);
7172   TGeoRotation* ssdconemiddleholerot[8];
7173   for(Int_t i=0; i<8; i++){
7174         ssdconemiddleholerot[i] = new TGeoRotation();
7175     ssdconemiddleholerot[i]->SetAngles(i*45,0.,0.);
7176   }
7177   /////////////////////////////////////////////////////////////
7178   ssdpconezsection[8] = ssdpconezsection[7];
7179   ssdpconesectionradiusmin[8] = ssdpconesectionradiusmin[7];
7180   ssdpconesectionradiusmax[8] = ssdpconesectionradiusmax[7];
7181   ssdpconesectionradiusmin[9] = fgkSSDPConeUpRadius-ssdpconezsection[0]
7182                                                           * CosD(fgkSSDPConeAngle)
7183                                                           / SinD(fgkSSDPConeAngle);
7184   ssdpconesectionradiusmax[9] = fgkSSDPConeUpRadius;
7185   ssdpconezsection[9] = (ssdpconesectionradiusmin[9]-ssdpconesectionradiusmin[8])
7186                                           * TanD(fgkSSDPConeAngle)+ssdpconezsection[8];
7187   ssdpconelittleholeshape[4] = new TGeoPcon(0.,360.,2);
7188   for(Int_t i=8; i<10;i++) ssdpconelittleholeshape[4]->DefineSection(i-8,ssdpconezsection[i],
7189                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7190   ssdpconelittlehole[4] = new TGeoVolume("SSDConeLittleHole5",ssdpconelittleholeshape[4],fSSDCarbonFiberMedium);
7191   ssdpconelittlehole[4]->SetLineColor(4);
7192   /////////////////////////////////////////////////////////////
7193   Double_t ssdconetrapezoidheight = fgkSSDPConeUpMaxRadius-fgkSSDPConeUpRadius;
7194   Double_t ssdconetrapezoidbasis = fgkSSDPConeTrapezoidBasis-2.0
7195                                                                  * (0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)
7196                                                                  -  0.5*ssdconetrapezoidheight/(fgkSSDPConeUpMaxRadius
7197                                                                  -  0.5*ssdconetrapezoidheight)*(0.5*fgkSSDPConeTrapezoidBasis
7198                                                                  -  0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)));
7199   Double_t ssdconetrapezoidsection = (2.0*TMath::Pi()*fgkSSDPConeUpMaxRadius-8.0*ssdconetrapezoidbasis)/8.;
7200   Double_t ssdpconetrapezoidsectionangle = ssdconetrapezoidsection/fgkSSDPConeUpMaxRadius
7201                                                                                  * TMath::RadToDeg();
7202   ssdpconezsection[10] = ssdpconezsection[9];
7203   ssdpconesectionradiusmin[10] = ssdpconesectionradiusmin[9];
7204   ssdpconesectionradiusmax[10] = ssdpconesectionradiusmax[9];
7205   ssdpconesectionradiusmin[11] = fgkSSDPConeUpMaxRadius-ssdpconezsection[0]
7206                                                           * CosD(fgkSSDPConeAngle)
7207                                                           / SinD(fgkSSDPConeAngle);
7208   ssdpconesectionradiusmax[11] = fgkSSDPConeUpMaxRadius;
7209   ssdpconezsection[11] = (ssdpconesectionradiusmin[11]-ssdpconesectionradiusmin[10])
7210                                            * TanD(fgkSSDPConeAngle)+ssdpconezsection[10];
7211   ssdpconelittleholeshape[5] = new TGeoPcon(90.-0.5*ssdpconetrapezoidsectionangle,
7212                                                                                         ssdpconetrapezoidsectionangle,2);
7213   for(Int_t i=10;i<12;i++) ssdpconelittleholeshape[5]->DefineSection(i-10,ssdpconezsection[i],
7214                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7215   ssdpconelittlehole[5] = new TGeoVolume("SSDConeLittleHole6",ssdpconelittleholeshape[5],fSSDCarbonFiberMedium);
7216   ssdpconelittlehole[5]->SetLineColor(4);
7217   TGeoRotation* ssdconeupradiusrot[8];
7218   for(Int_t i=0; i<8; i++){
7219         ssdconeupradiusrot[i] = new TGeoRotation();
7220     ssdconeupradiusrot[i]->SetAngles(i*45,0.,0.);
7221   }
7222   /////////////////////////////////////////////////////////////
7223   ssdpconezsection[12] = ssdpconezsection[11];
7224   ssdpconezsection[13] = ssdpconezsection[12]+fgkSSDPConeRadiusWidth;
7225   ssdpconesectionradiusmin[12] = ssdpconesectionradiusmin[11];
7226   ssdpconesectionradiusmax[12] = fgkSSDPConeExternalRadius;
7227   ssdpconesectionradiusmin[13] = ssdpconesectionradiusmin[12];
7228   ssdpconesectionradiusmax[13] = fgkSSDPConeExternalRadius;
7229   ssdpconelittleholeshape[6] = new TGeoPcon(0.,360.,2);
7230   for(Int_t i=12; i<14;i++) ssdpconelittleholeshape[6]->DefineSection(i-12,ssdpconezsection[i],
7231                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7232   ssdpconelittlehole[6] = new TGeoVolume("SSDConeLittleHole7",ssdpconelittleholeshape[6],fSSDCarbonFiberMedium);
7233   ssdpconelittlehole[6]->SetLineColor(4);
7234   /////////////////////////////////////////////////////////////
7235   ssdpconezsection[14] = 0.0;
7236   ssdpconezsection[15] = ssdpconezsection[0];
7237   ssdpconesectionradiusmin[14] = ssdpconesectionradiusmin[0];
7238   ssdpconesectionradiusmax[14] = ssdpconesectionradiusmin[14];
7239   ssdpconesectionradiusmin[15] = ssdpconesectionradiusmin[0];
7240   ssdpconesectionradiusmax[15] = ssdpconesectionradiusmax[0];
7241   ssdpconelittleholeshape[7] = new TGeoPcon(0.,360.,2);
7242   for(Int_t i=14; i<16;i++) ssdpconelittleholeshape[7]->DefineSection(i-14,ssdpconezsection[i],
7243                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7244   ssdpconelittlehole[7] = new TGeoVolume("SSDConeLittleHole8",ssdpconelittleholeshape[7],fSSDCarbonFiberMedium);
7245   ssdpconelittlehole[7]->SetLineColor(4);
7246   /////////////////////////////////////////////////////////////
7247   TGeoTube* ssdtubeconeshape[2];
7248   TGeoVolume* ssdtubecone[2];
7249   TGeoTranslation* ssdtubeconetrans[2];
7250   ssdtubeconeshape[0] = new TGeoTube(fgkSSDPConeUpMiddleRadius,
7251                                                                            fgkSSDPConeExternalRadius,
7252                                                                            0.5*(fgkSSDPConeLength-ssdpconezsection[13]));
7253   ssdtubeconeshape[1] = new TGeoTube(fgkSSDPConeDownRadius,ssdpconesectionradiusmin[0],
7254                                                                            0.5*ssdpconezsection[0]);
7255   ssdtubecone[0] = new TGeoVolume("SSDConeTube1",ssdtubeconeshape[0],fSSDSupportRingAl);
7256   ssdtubecone[1] = new TGeoVolume("SSDConeTube2",ssdtubeconeshape[1],fSSDSupportRingAl);
7257   ssdtubeconetrans[0] = new TGeoTranslation(0.,0.,
7258                                                 0.5*(fgkSSDPConeLength-ssdpconezsection[13])
7259                                           + ssdpconezsection[13]);
7260   ssdtubeconetrans[1] = new TGeoTranslation(0.,0.,0.5*ssdpconezsection[0]);
7261   ssdtubecone[0]->SetLineColor(4);
7262   ssdtubecone[1]->SetLineColor(4);
7263   /////////////////////////////////////////////////////////////
7264   // Mother Volume Container
7265   /////////////////////////////////////////////////////////////
7266   Double_t ssdconemotherradiusmin[8];
7267   Double_t ssdconemotherradiusmax[8];
7268   Double_t ssdconemothersection[8];
7269   ssdconemotherradiusmin[0] = fgkSSDPConeDownRadius;
7270   ssdconemotherradiusmax[0] = ssdpconesectionradiusmin[0];
7271   ssdconemotherradiusmin[1] = fgkSSDPConeDownRadius;
7272   ssdconemotherradiusmax[1] = ssdpconesectionradiusmax[0];
7273   ssdconemotherradiusmin[2] = ssdpconesectionradiusmin[0];
7274   ssdconemotherradiusmax[2] = ssdpconesectionradiusmax[0];
7275   ssdconemotherradiusmin[3] = ssdpconesectionradiusmin[11];
7276   ssdconemotherradiusmax[3] = ssdpconesectionradiusmax[11];
7277   ssdconemotherradiusmin[4] = ssdpconesectionradiusmin[12];
7278   ssdconemotherradiusmax[4] = ssdpconesectionradiusmax[12];
7279   ssdconemotherradiusmin[5] = ssdpconesectionradiusmin[13];
7280   ssdconemotherradiusmax[5] = ssdpconesectionradiusmax[13];
7281   ssdconemotherradiusmin[6] = fgkSSDPConeUpMiddleRadius;
7282   ssdconemotherradiusmax[6] = fgkSSDPConeExternalRadius;
7283   ssdconemotherradiusmin[7] = fgkSSDPConeUpMiddleRadius;
7284   ssdconemotherradiusmax[7] = fgkSSDPConeExternalRadius;
7285   ssdconemothersection[0] = 0.0;
7286   ssdconemothersection[1] = ssdpconezsection[0];
7287   ssdconemothersection[2] = ssdpconezsection[0];
7288   ssdconemothersection[3] = ssdpconezsection[11];
7289   ssdconemothersection[4] = ssdpconezsection[11];
7290   ssdconemothersection[5] = ssdpconezsection[13];
7291   ssdconemothersection[6] = ssdpconezsection[13];
7292   ssdconemothersection[7] = fgkSSDPConeLength;
7293   TGeoPcon* ssdconemothershape = new TGeoPcon(0.,360,8);
7294   for(Int_t i=0; i<8; i++) ssdconemothershape->DefineSection(i,ssdconemothersection[i],
7295                                                                         ssdconemotherradiusmin[i],ssdconemotherradiusmax[i]);
7296   TGeoVolume* ssdconemother = new TGeoVolume("SSDMotherCone",ssdconemothershape,fSSDAir);
7297   /////////////////////////////////////////////////////////////
7298   //Placing the Volumes into Mother
7299   /////////////////////////////////////////////////////////////
7300   ssdconemother->AddNode(ssdpconelittlehole[0],1);
7301   for(Int_t i=0; i<6; i++){
7302         ssdconemother->AddNode(ssdpconelittlehole[1],i+1,ssdconelittleholerot[i]);
7303   }
7304   ssdconemother->AddNode(ssdpconelittlehole[2],1);
7305   for(Int_t i=0; i<8; i++){
7306     ssdconemother->AddNode(ssdpconelittlehole[3],i+1,ssdconemiddleholerot[i]);
7307   }
7308   ssdconemother->AddNode(ssdpconelittlehole[4],1);
7309   for(Int_t i=0; i<8; i++){
7310     ssdconemother->AddNode(ssdpconelittlehole[5],i+1,ssdconeupradiusrot[i]);
7311   }
7312   ssdconemother->AddNode(ssdpconelittlehole[6],1);
7313   ssdconemother->AddNode(ssdpconelittlehole[7],1);
7314   ssdconemother->AddNode(ssdtubecone[0],1,ssdtubeconetrans[0]);
7315   ssdconemother->AddNode(ssdtubecone[1],1,ssdtubeconetrans[1]);
7316   /////////////////////////////////////////////////////////////
7317   // ITS General Support
7318   /////////////////////////////////////////////////////////////
7319   TGeoTube* ssdcentralsupportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7320                                                                 fgkSSDCentralSupportRadius,0.5*fgkSSDCentralSupportLength);
7321   TGeoVolume* ssdcentralsupport = new TGeoVolume("SSDCentralSupport",ssdcentralsupportshape,fSSDRohaCellCone);
7322   TGeoTranslation* ssdcentralsupportrans = new TGeoTranslation(0.,0.,-0.5*fgkSSDCentralSupportLength
7323                                                                              - fgkSSDCentralAL3SupportLength);
7324   ssdcentralsupport->SetLineColor(4);
7325   fSSDCone->AddNode(ssdcentralsupport,1,ssdcentralsupportrans);
7326   TGeoTube* ssdcentralal3supportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7327                                                                 fgkSSDCentralSupportRadius,0.25*fgkSSDCentralAL3SupportLength);
7328   TGeoVolume* ssdcentralal3support = new TGeoVolume("SSDCentralAl3Support",ssdcentralal3supportshape,fSSDSupportRingAl);
7329   TGeoTranslation* ssdcentralal3supportrans[3];
7330   ssdcentralal3supportrans[0] = new TGeoTranslation(0.,0.,-0.75*fgkSSDCentralAL3SupportLength);
7331   ssdcentralal3supportrans[1] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7332                                                           - 1.25*fgkSSDCentralAL3SupportLength);
7333   ssdcentralal3support->SetLineColor(4);
7334   fSSDCone->AddNode(ssdcentralal3support,1,ssdcentralal3supportrans[0]);
7335   fSSDCone->AddNode(ssdcentralal3support,2,ssdcentralal3supportrans[1]);
7336   TGeoPcon* ssdpconcentralal3shape = new TGeoPcon(0.,360.,2);
7337   Double_t ssdpconcentralradiusmin[2];
7338   Double_t ssdpconcentralradiusmax[2];
7339   Double_t ssdpconcentralsection[2];
7340   ssdpconcentralradiusmin[0] = fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth;
7341   ssdpconcentralradiusmin[1] = fgkSSDCentralSupportRadius-fgkSSDCentralAL3SupportWidth;
7342   ssdpconcentralradiusmax[0] = fgkSSDCentralSupportRadius;
7343   ssdpconcentralradiusmax[1] = fgkSSDCentralSupportRadius;
7344   ssdpconcentralsection[0] = -0.5*fgkSSDCentralAL3SupportLength;
7345   ssdpconcentralsection[1] = 0.;
7346   for(Int_t i=0; i<2;i++) ssdpconcentralal3shape->DefineSection(i,ssdpconcentralsection[i],
7347                                                   ssdpconcentralradiusmin[i],ssdpconcentralradiusmax[i]);
7348   TGeoVolume* ssdpconcentralal3 = new TGeoVolume("SSDPConeCentralAl3",ssdpconcentralal3shape,fSSDSupportRingAl);
7349   ssdpconcentralal3->SetLineColor(4);
7350   fSSDCone->AddNode(ssdpconcentralal3,1);
7351   TGeoRotation* ssdcentralal3supportrot = new TGeoRotation();
7352   ssdcentralal3supportrot->SetAngles(90.,180,-90.);
7353   ssdcentralal3supportrans[2] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7354                                                                 -2.*fgkSSDCentralAL3SupportLength);
7355   TGeoCombiTrans* ssdcentralal3supporcombitrans = new TGeoCombiTrans(*ssdcentralal3supportrans[2],
7356                                                                                                                      *ssdcentralal3supportrot);
7357   fSSDCone->AddNode(ssdpconcentralal3,2,ssdcentralal3supporcombitrans);
7358   TGeoRotation* ssdconemotherot = new TGeoRotation();
7359   ssdconemotherot->SetAngles(90.,180.,-90.);
7360   TGeoTranslation* ssdconemothertrans = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7361                                                                                                                         -2.*fgkSSDCentralAL3SupportLength);
7362   TGeoCombiTrans* ssdconemothercombitrans = new TGeoCombiTrans(*ssdconemothertrans,*ssdconemotherot);
7363   fSSDCone->AddNode(ssdconemother,1);
7364   fSSDCone->AddNode(ssdconemother,2,ssdconemothercombitrans);
7365   /////////////////////////////////////////////////////////////
7366   // Deallocating memory
7367   /////////////////////////////////////////////////////////////
7368   delete ssdcentralal3supportrot;
7369   delete ssdcentralal3supportrans[2];
7370   delete ssdconemotherot;
7371   delete ssdconemothertrans;
7372   /////////////////////////////////////////////////////////////
7373  }
7374  ////////////////////////////////////////////////////////////////////////////////
7375  void AliITSv11GeometrySSD::SSDCables(TGeoVolume* moth){
7376   /////////////////////////////////////////////////////////////
7377   // Setting SSD Cables
7378   /////////////////////////////////////////////////////////////
7379   if (! moth) {
7380     AliError("Can't insert SSD Cables, mother is null!\n");
7381     return;
7382   };
7383   TGeoVolume* ssdcables = SetSSDCables();
7384   moth->AddNode(ssdcables,1);
7385 }
7386  ////////////////////////////////////////////////////////////////////////////////
7387  TGeoVolume* AliITSv11GeometrySSD::SetSSDCables(){
7388    /////////////////////////////////////////////////////////////
7389    // Method generating SSDCables
7390    /////////////////////////////////////////////////////////////
7391
7392    /////////////////////////////////////////////////////////////////////////////////
7393    // SSD Cables Parameters (lengths are in mm and angles in degrees)
7394    /////////////////////////////////////////////////////////////////////////////////
7395
7396    const Double_t kSSDCablesLay5TubeRadiusMin = 11.9*fgkmm;
7397    const Double_t kSSDCablesLay6TubeRadiusMin = 11.9*fgkmm;
7398
7399    // Cable thickness for rings at outer Z
7400    // Average: 9/2 = 4.5 cables per quadrant
7401    // Ideally 1/16 * 38(34) cables, but take factor to (1/8) to accomodate kinks and loops (there are only 2 different cable lengths); 21 mm^2 Cu each
7402
7403    const Double_t kSSDCablesLay5RingArea = 21.*34./8.*fgkmm*fgkmm;  // to be fixed in order to reproduce material budget
7404    const Double_t kSSDCablesLay6RingArea = 21.*38./8.*fgkmm*fgkmm;  // to be fixed in order to reproduce material budget
7405
7406
7407    const Double_t kSSDCablesHeight = 3.2*fgkmm;  // 3.2 mm*13 cm width = 18 cables, 185g/m each Add fudge factor of 2 to get to ~25 kg measured
7408
7409    const Double_t kSSDCableAngle = 22.5;
7410    // MvL: remove water?
7411    const Double_t kSSDCablesLay5RightSideWaterHeight = 2.5*fgkmm;  // to be fixed in order to reproduce material budget
7412    const Double_t kSSDCablesPatchPanel2RB26Angle[2] = {25.0,53.2};
7413    const Double_t kSSDCablesPatchPanel2RB24Angle[2] = {23.0,53.6};
7414    const Double_t kSSDPatchPanel2RB26ITSDistance = 975.0*fgkmm;
7415    const Double_t kSSDPatchPanel2RB24ITSDistance = 1020.0*fgkmm;
7416    const Double_t kSSDPatchPanel2RB26Radius = 451.3*fgkmm;
7417    const Double_t kSSDPatchPanel2RB24Radius = 451.3*fgkmm;
7418    const Double_t kSSDPatchPanelHeight = 87.5*fgkmm;
7419
7420    // SSD Layer 5 Cables
7421    //////////////////////////////////////////////////////////////////////////////////////////////////
7422    TGeoVolumeAssembly* ssdcablesmother = new TGeoVolumeAssembly("SSDCables");
7423    Double_t ssdcablelayvertical = 0.05; // Internal variables to control overlapping with SDD cables
7424    Double_t ssdcablelaylateral = 0.55;   // Internal variables to control overlapping with SDD cables
7425    //////////////////////////////////////////////////////////////////////////////////////////////////
7426   // Printf(Form("Cable ring: rad min: %g length %g thick %g", ssdcableslay5rigthsideradiusmin, ssdcablelay5rightsidelength, kSSDCablesLay5RingArea/ssdcablelay5rightsidelength));
7427
7428
7429
7430   ////////////////////////////////////
7431   //  Double_t cablescapacity[20];
7432   //  cablescapacity[0] = ssdcablelay5rightubeshape->Capacity();
7433   ////////////////////////////////////
7434   //ssdcablesmother->AddNode(ssdcablelay5righttube,1,ssdcablelay5rightrans);
7435   ////////////////////////////////////
7436   // TGeoPCone Volumes
7437   ///////////////////////////////////
7438   TGeoPcon* ssdcableslay5pconshape[3];
7439   TGeoVolume* ssdcableslay5pcon[3];
7440   ssdcableslay5pconshape[0] = new TGeoPcon(0.,360.,2);
7441   Double_t ssdcableslay5pconzsection[6];
7442   Double_t ssdcableslay5pconrmin[6];
7443   Double_t ssdcableslay5pconrmax[6];
7444   ssdcableslay5pconrmin[0] = fgkEndCapSupportMiddleRadius[0]+kSSDCablesLay5TubeRadiusMin;
7445   ssdcableslay5pconrmin[1] = fgkSSDPConeUpRadius*(1.0+ssdcablelayvertical);
7446
7447   ssdcableslay5pconzsection[0] = fgkEndCapSupportCenterLay5ITSPosition
7448                                  + fgkEndCapSupportCenterLay5Position;
7449                                 //+ 2.*ssdcablelay5rightsidelength;  // removing this generates overlap with the water ring
7450                                 // Keeping it generates overlap with the cones...
7451   // SSDCables/SSDCableLay5RightSideWaterTube_2 ovlp=0.0939792
7452   ssdcableslay5pconzsection[1] = 0.5*fgkSSDCentralSupportLength
7453                                                            + fgkSSDCentralAL3SupportLength
7454                                                            + (fgkSSDPConeUpRadius-fgkSSDLowerPConeRadius)
7455                                                            * TanD(fgkSSDPConeAngle);
7456   Double_t dz = ssdcableslay5pconzsection[1]-ssdcableslay5pconzsection[0];
7457   Double_t pconethickness = kSSDCablesLay5RingArea/TMath::Abs(dz);
7458   ssdcableslay5pconrmax[0] = ssdcableslay5pconrmin[0]+pconethickness;
7459   ssdcableslay5pconrmax[1] = ssdcableslay5pconrmin[1]+pconethickness;
7460   //Printf(Form("pcone: r1 %g  r2 %g z1 %g z2 %g thickness %g", ssdcableslay5pconrmax[0], ssdcableslay5pconrmax[1],
7461   //          ssdcableslay5pconzsection[0],ssdcableslay5pconzsection[1],pconethickness));
7462
7463   for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[0]->DefineSection(i,ssdcableslay5pconzsection[i],
7464                                                   ssdcableslay5pconrmin[i],ssdcableslay5pconrmax[i]);
7465   ssdcableslay5pcon[0] = new TGeoVolume("SSDCableLay5RightSidePCon1",
7466                                                            ssdcableslay5pconshape[0],fSSDCopper);
7467   ssdcableslay5pcon[0]->SetLineColor(9);
7468   ssdcablesmother->AddNode(ssdcableslay5pcon[0],1);
7469
7470   Double_t totvol = ssdcableslay5pcon[0]->Capacity();
7471   // Printf(Form("Cables, lay5, pCone,volume: %g", ssdcableslay5pcon[0]->Capacity()));
7472 ////////////////////////////////////
7473 //  cablescapacity[1] = ssdcableslay5pconshape[0]->Capacity();
7474 ////////////////////////////////////
7475
7476   //
7477   //   PCon 2 and 3 are cables going through/towards holes in supports
7478   //
7479   ssdcableslay5pconzsection[2] = ssdcableslay5pconzsection[1];
7480   ssdcableslay5pconzsection[3] = 0.5*fgkSSDCentralSupportLength
7481                                                            + fgkSSDCentralAL3SupportLength
7482                                                            + 0.25*TanD(fgkSSDPConeAngle)*(fgkSSDPConeUpMaxRadius
7483                                                            + 3.*fgkSSDPConeUpRadius-4.*fgkSSDLowerPConeRadius);
7484   Double_t ssdcableangle = (fgkSSDPConeTrapezoidBasis-2.*(fgkSSDPConeUpMaxRadius
7485                                              -  fgkSSDPConeUpRadius)/TanD(fgkSSDPConeTrapezoidAngle))
7486                                                  /  fgkSSDPConeUpRadius*TMath::RadToDeg()*2;
7487   ssdcableslay5pconshape[1] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7488                                                                                    ssdcableangle,2);
7489   // Printf(Form("PCon2, phi %g dphi %g ",90.0-kSSDCableAngle-0.5*ssdcableangle, ssdcableangle));
7490   ssdcableslay5pconrmin[2] = ssdcableslay5pconrmin[1];
7491   ssdcableslay5pconrmax[2] = ssdcableslay5pconrmax[1];
7492   ssdcableslay5pconrmin[3] = 0.25*(fgkSSDPConeUpMaxRadius+3.*fgkSSDPConeUpRadius
7493                                                    - 4.*fgkSSDLowerPConeRadius)+fgkSSDLowerPConeRadius;
7494   ssdcableslay5pconrmin[3]*=(1.0+ssdcablelayvertical);
7495   ssdcableslay5pconrmax[3] = ssdcableslay5pconrmin[3] + kSSDCablesHeight;
7496   for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[1]->DefineSection(i,ssdcableslay5pconzsection[i+2],
7497                                                   ssdcableslay5pconrmin[i+2],ssdcableslay5pconrmax[i+2]);
7498   ssdcableslay5pcon[1] = new TGeoVolume("SSDCableLay5RightSidePCon2",ssdcableslay5pconshape[1],fSSDCopper);
7499   ssdcableslay5pcon[1]->SetLineColor(9);
7500   ////////////////////////////////////
7501   ssdcableslay5pconshape[2] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7502                                                                                    ssdcableangle,2);
7503   ssdcableslay5pconrmin[4] = ssdcableslay5pconrmin[3];
7504   ssdcableslay5pconrmax[4] = ssdcableslay5pconrmax[3];
7505   ssdcableslay5pconrmin[5] = ssdcableslay5pconrmin[4];
7506   ssdcableslay5pconrmax[5] = ssdcableslay5pconrmax[4];
7507   ssdcableslay5pconzsection[4] = ssdcableslay5pconzsection[3];
7508   ssdcableslay5pconzsection[5] = (ssdcableslay5pconrmin[5]-fgkSSDLowerPConeRadius)
7509                                                            * TanD(fgkSSDPConeAngle)
7510                                                            + 0.5*fgkSSDCentralSupportLength
7511                                                            + fgkSSDCentralAL3SupportLength;
7512   ssdcableslay5pconzsection[5]-= ssdcablelaylateral;
7513   for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[2]->DefineSection(i,ssdcableslay5pconzsection[i+4],
7514                                                   ssdcableslay5pconrmin[i+4],ssdcableslay5pconrmax[i+4]);
7515   ssdcableslay5pcon[2] = new TGeoVolume("SSDCableLay5RightSidePCon3",ssdcableslay5pconshape[2],fSSDCopper);
7516   ssdcableslay5pcon[2]->SetLineColor(9);
7517 ////////////////////////////////////
7518   TGeoRotation* ssdcableslay5pconrot[4];
7519   for(Int_t i=0; i<4; i++){
7520    ssdcableslay5pconrot[i] = new TGeoRotation();
7521    ssdcableslay5pconrot[i]->SetAngles(90.0*i,0.,0.);
7522    ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+1,ssdcableslay5pconrot[i]);
7523    ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+1,ssdcableslay5pconrot[i]);
7524    // Printf(Form("Pcon2, Pcon3, vol %g %g",ssdcableslay5pcon[1]->Capacity(),ssdcableslay5pcon[2]->Capacity()));
7525    totvol += ssdcableslay5pcon[1]->Capacity()+ssdcableslay5pcon[2]->Capacity();
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   TGeoRotation* ssdcablesLay5RightPConToLeftRot = new TGeoRotation();
7534   ssdcablesLay5RightPConToLeftRot->SetAngles(90.,180.,-90);
7535   ssdcablesmother->AddNode(ssdcableslay5pcon[0],2,ssdcablesLay5RightPConToLeftRot);
7536   TGeoHMatrix* ssdcablesLay5RightPConToLeftMatrix[4];
7537   for(Int_t i=0; i<4; i++){ ssdcablesLay5RightPConToLeftMatrix[i] =
7538         new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconrot[i]));
7539         ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7540     ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7541   }
7542   ////////////////////////////////////
7543   //cablescapacity[4] = ssdcablelay5rightubeshape->Capacity();
7544   //cablescapacity[5] = ssdcableslay5pconshape[0]->Capacity();
7545   //cablescapacity[6] = 4.*ssdcableslay5pconshape[1]->Capacity();
7546   //cablescapacity[7] = 4.*ssdcableslay5pconshape[2]->Capacity();
7547   /////////////////////////////////////////////////////////////
7548   // Water Tubes Layer 5
7549   /////////////////////////
7550   /*  Remove ring; could be replaced with a PCone next to/on top of the cables
7551
7552    //
7553    // MvL: Remove ring; put everything in PCone
7554    //
7555    // Need to keep dimensions for water ring...
7556
7557    Double_t ssdcablesfactor = 0.5;     // Internal variables to control overlapping with SDD cables
7558
7559   Double_t ssdcableslay5rigthsideradiusmin = fgkEndCapSupportMiddleRadius[0]+kSSDCablesLay5TubeRadiusMin;
7560   Double_t ssdcableslay5endconedistance = (ssdcableslay5rigthsideradiusmin
7561                                                                             -  fgkSSDLowerPConeRadius)
7562                                                                             * TanD(fgkSSDPConeAngle);
7563   Double_t ssdcableslay5startconedistance = fgkEndCapSupportCenterLay5ITSPosition
7564                                                                               + fgkEndCapSupportCenterLay5Position
7565                                                                               - 0.5*fgkSSDCentralSupportLength-fgkSSDCentralAL3SupportLength;
7566   Double_t ssdcablelay5rightsidelength = ssdcableslay5endconedistance
7567                                                                            - ssdcableslay5startconedistance;
7568   ssdcablelay5rightsidelength *= ssdcablesfactor;
7569   Double_t ssdcableslay5rightsideradiusmax = ssdcableslay5rigthsideradiusmin+kSSDCablesLay5RingArea/ssdcablelay5rightsidelength;
7570
7571
7572   TGeoTranslation* ssdcablelay5rightrans =
7573                                           new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay5ITSPosition
7574                                                                     + fgkEndCapSupportCenterLay5Position
7575                                                                     + 0.5*ssdcablelay5rightsidelength);
7576
7577   TGeoTranslation* ssdcablesLay5RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7578                                                                                                         - 0.5*ssdcablelay5rightsidelength
7579                                                                                                         - fgkEndCapSupportCenterLay5Position
7580                                                                                                     - fgkEndCapSupportCenterLay5ITSPosition);
7581
7582   TGeoTube* ssdcablelay5rightubewatershape = new TGeoTube(ssdcableslay5rightsideradiusmax,
7583                                                                                      ssdcableslay5rightsideradiusmax
7584                                                                                + kSSDCablesLay5RightSideWaterHeight,
7585                                                                                      0.5*ssdcablelay5rightsidelength);
7586   TGeoVolume* ssdcablelay5rightwatertube = new TGeoVolume("SSDCableLay5RightSideWaterTube",
7587                                                                                                          ssdcablelay5rightubewatershape,
7588                                                                                                          fSSDCoolingTubeWater);
7589   ssdcablelay5rightwatertube->SetLineColor(7);
7590   ssdcablesmother->AddNode(ssdcablelay5rightwatertube,1,ssdcablelay5rightrans);
7591   ssdcablesmother->AddNode(ssdcablelay5rightwatertube,2,ssdcablesLay5RightTubeToLeftrans);
7592   */
7593   ////////////////////////////////////
7594   // TGeoPCone Water Volumes Layer
7595   ///////////////////////////////////
7596   TGeoPcon* ssdcableslay5pconwatershape[3];
7597   TGeoVolume* ssdcableslay5pconwater[3];
7598   ssdcableslay5pconwatershape[0] = new TGeoPcon(0.,360.,2);
7599   Double_t ssdcableslay5pconwaterzsection[6];
7600   Double_t ssdcableslay5pcwateronrmin[6];
7601   Double_t ssdcableslay5pconwaterrmax[6];
7602   ssdcableslay5pcwateronrmin[0] = ssdcableslay5pconrmax[0];
7603   ssdcableslay5pconwaterrmax[0] = ssdcableslay5pcwateronrmin[0]
7604                                                                 + kSSDCablesLay5RightSideWaterHeight;
7605   ssdcableslay5pcwateronrmin[1] = ssdcableslay5pconrmax[1];
7606   ssdcableslay5pconwaterrmax[1] = ssdcableslay5pcwateronrmin[1]
7607                                                                 + kSSDCablesLay5RightSideWaterHeight;
7608   ssdcableslay5pconwaterzsection[0] = ssdcableslay5pconzsection[0];
7609   ssdcableslay5pconwaterzsection[1] = ssdcableslay5pconzsection[1];
7610   for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[0]->DefineSection(i,ssdcableslay5pconwaterzsection[i],
7611                                                   ssdcableslay5pcwateronrmin[i],ssdcableslay5pconwaterrmax[i]);
7612   ssdcableslay5pconwater[0] = new TGeoVolume("SSDCableLay5RightSidePConWater1",
7613                                                            ssdcableslay5pconwatershape[0],fSSDCoolingTubeWater);
7614   ssdcableslay5pconwater[0]->SetLineColor(7);
7615   ssdcablesmother->AddNode(ssdcableslay5pconwater[0],1);
7616   ssdcablesmother->AddNode(ssdcableslay5pconwater[0],2,ssdcablesLay5RightPConToLeftRot);
7617 ////////////////////////////////////
7618   ssdcableslay5pconwaterzsection[2] = ssdcableslay5pconzsection[2];
7619   ssdcableslay5pconwaterzsection[3] = ssdcableslay5pconzsection[3];
7620   ssdcableslay5pconwatershape[1] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7621                                                                                                 ssdcableangle,2);
7622   ssdcableslay5pcwateronrmin[2] = ssdcableslay5pconrmax[1];
7623   ssdcableslay5pconwaterrmax[2] = ssdcableslay5pcwateronrmin[2]
7624                                                                 + kSSDCablesLay5RightSideWaterHeight;
7625   ssdcableslay5pcwateronrmin[3] = ssdcableslay5pconrmax[3];
7626   ssdcableslay5pconwaterrmax[3] = ssdcableslay5pcwateronrmin[3]
7627                                                                 + kSSDCablesLay5RightSideWaterHeight;
7628   for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[1]->DefineSection(i,ssdcableslay5pconwaterzsection[i+2],
7629                                                   ssdcableslay5pcwateronrmin[i+2],ssdcableslay5pconwaterrmax[i+2]);
7630   ssdcableslay5pconwater[1] = new TGeoVolume("SSDCableLay5RightSidePConWater2",
7631                                                            ssdcableslay5pconwatershape[1],fSSDCoolingTubeWater);
7632   ssdcableslay5pconwater[1]->SetLineColor(7);
7633 ////////////////////////////////////
7634   ssdcableslay5pconwatershape[2] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7635                                                                                                 ssdcableangle,2);
7636   ssdcableslay5pcwateronrmin[4] = ssdcableslay5pconrmax[3];
7637   ssdcableslay5pconwaterrmax[4] = ssdcableslay5pcwateronrmin[4]
7638                                                                 + kSSDCablesLay5RightSideWaterHeight;
7639   ssdcableslay5pcwateronrmin[5] = ssdcableslay5pconrmax[4];
7640   ssdcableslay5pconwaterrmax[5] = ssdcableslay5pcwateronrmin[4]
7641                                                                 + kSSDCablesLay5RightSideWaterHeight;
7642   ssdcableslay5pconwaterzsection[4] = ssdcableslay5pconzsection[4];
7643   ssdcableslay5pconwaterzsection[5] = ssdcableslay5pconzsection[5];
7644   for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[2]->DefineSection(i,ssdcableslay5pconwaterzsection[i+4],
7645                                                   ssdcableslay5pcwateronrmin[i+4],ssdcableslay5pconwaterrmax[i+4]);
7646   ssdcableslay5pconwater[2] = new TGeoVolume("SSDCableLay5RightSidePConWater3",
7647                                                            ssdcableslay5pconwatershape[2],fSSDCoolingTubeWater);
7648   ssdcableslay5pconwater[2]->SetLineColor(7);
7649 ////////////////////////////////////
7650   TGeoRotation* ssdcableslay5pconwaterot[4];
7651   TGeoHMatrix* ssdcablesLay5RightPConWaterToLeftMatrix[4];
7652   for(Int_t i=0; i<4; i++){
7653    ssdcableslay5pconwaterot[i] = new TGeoRotation();
7654    ssdcableslay5pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7655    ssdcablesLay5RightPConWaterToLeftMatrix[i] =
7656         new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconwaterot[i]));
7657         ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+1,ssdcableslay5pconwaterot[i]);
7658         ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7659         ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+1,ssdcableslay5pconwaterot[i]);
7660         ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7661   }
7662   /////////////////////////
7663   // SSD Layer 6 Cables
7664   /////////////////////////
7665   Double_t ssdcableslay6rigthsideradiusmin = fgkEndCapSupportMiddleRadius[1]+kSSDCablesLay6TubeRadiusMin;
7666   Double_t ssdcablelay6rightsidelength = 2.; // cm  was 2.*ssdcablelay5rightsidelength;
7667   Double_t ssdcableslay6rightsideradiusmax = ssdcableslay6rigthsideradiusmin+kSSDCablesLay6RingArea/ssdcablelay6rightsidelength;
7668   // Printf(Form("Lay 6 cables, length %g, radius %g, thickness %g", ssdcablelay6rightsidelength, ssdcableslay6rigthsideradiusmin, kSSDCablesLay6RingArea/ssdcablelay6rightsidelength));
7669   TGeoTube* ssdcablelay6rightubeshape = new TGeoTube(ssdcableslay6rigthsideradiusmin,
7670                                                                                                 ssdcableslay6rightsideradiusmax,
7671                                                                                                 0.5*ssdcablelay6rightsidelength);
7672   TGeoVolume* ssdcablelay6righttube = new TGeoVolume("SSDCableLay6RightSideTube",
7673                                                                                                          ssdcablelay6rightubeshape,
7674                                                                                                          fSSDCopper);
7675   ssdcablelay6righttube->SetLineColor(9);
7676   TGeoTranslation* ssdcablelay6rightrans =
7677                                           new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay6ITSPosition
7678                                                                                  +              fgkEndCapSupportCenterLay6Position
7679                                                                                  +      0.5*ssdcablelay6rightsidelength);
7680   TGeoTranslation* ssdcablesLay6RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7681                                                                                                         - 0.5*ssdcablelay6rightsidelength
7682                                                                                                         - fgkEndCapSupportCenterLay6Position
7683                                                                                                     - fgkEndCapSupportCenterLay6ITSPosition);
7684   ssdcablesmother->AddNode(ssdcablelay6righttube,1,ssdcablelay6rightrans);
7685   ssdcablesmother->AddNode(ssdcablelay6righttube,2,ssdcablesLay6RightTubeToLeftrans);
7686   // Printf(Form("Cables; ring layer 6, volume: %g",ssdcablelay6rightubeshape->Capacity()));
7687   totvol += ssdcablelay6rightubeshape->Capacity();
7688   ////////////////////////////////////
7689   //cablescapacity[8] = 2.*ssdcablelay6rightubeshape->Capacity();
7690   ////////////////////////////////////
7691   // MvL: PCon is part of connection to patch panels;
7692   // removed since current volume is too thick; now absorbed in rings+connections
7693   /*
7694   TGeoPcon* ssdcableslay6pconshape = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7695                                                                                    ssdcableangle,2);
7696   TGeoVolume* ssdcableslay6pcon;
7697   Double_t ssdcableslay6pconrmin[2];
7698   Double_t ssdcableslay6pconrmax[2];
7699   Double_t ssdcableslay6pconzsection[2];
7700   ssdcableslay6pconrmin[0] = ssdcableslay6rigthsideradiusmin;
7701   ssdcableslay6pconrmax[0] = ssdcableslay6rightsideradiusmax;
7702   ssdcableslay6pconrmin[1] = ssdcableslay6pconrmin[0];
7703   ssdcableslay6pconrmax[1] = ssdcableslay6pconrmax[0];
7704   ssdcableslay6pconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7705                                                            + fgkEndCapSupportCenterLay6Position
7706                                                            + ssdcablelay6rightsidelength;
7707   ssdcableslay6pconzsection[1] = ssdcableslay5pconwaterzsection[5];
7708   for(Int_t i=0; i<2;i++) ssdcableslay6pconshape->DefineSection(i,ssdcableslay6pconzsection[i],
7709                                                   ssdcableslay6pconrmin[i],ssdcableslay6pconrmax[i]);
7710
7711   ssdcableslay6pcon = new TGeoVolume("SSDCableLay6RightSidePCon",
7712                                                            ssdcableslay6pconshape,fSSDCopper);
7713   ssdcableslay6pcon->SetLineColor(9);
7714   for(Int_t i=0; i<4; i++){
7715    ssdcablesmother->AddNode(ssdcableslay6pcon,i+1,ssdcableslay5pconrot[i]);
7716    ssdcablesmother->AddNode(ssdcableslay6pcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7717   }
7718   */
7719   ////////////////////////////////////
7720   //cablescapacity[9] = 8.*ssdcableslay6pconshape->Capacity();
7721   /////////////////////////
7722   // Water Tubes Layer 6
7723   /////////////////////////
7724   TGeoTube* ssdcablelay6righwatertubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax,
7725                                                                                                                   ssdcableslay6rightsideradiusmax
7726                                                                                    +                      kSSDCablesLay5RightSideWaterHeight,
7727                                                                                                                   0.5*ssdcablelay6rightsidelength);
7728   TGeoVolume* ssdcablelay6rightwatertube = new TGeoVolume("SSDCableLay6RightSideWaterTube",
7729                                                                                                          ssdcablelay6righwatertubeshape,
7730                                                                                                          fSSDCoolingTubeWater);
7731   ssdcablelay6rightwatertube->SetLineColor(7);
7732   ssdcablesmother->AddNode(ssdcablelay6rightwatertube,1,ssdcablelay6rightrans);
7733   ssdcablesmother->AddNode(ssdcablelay6rightwatertube,2,ssdcablesLay6RightTubeToLeftrans);
7734   TGeoPcon* ssdcableslay6waterpconshape = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7735                                                                                    ssdcableangle,2);
7736   TGeoVolume* ssdcableslay6waterpcon;
7737   Double_t ssdcableslay6waterpconrmin[2];
7738   Double_t ssdcableslay6waterpconrmax[2];
7739   Double_t ssdcableslay6waterpconzsection[2];
7740   ssdcableslay6waterpconrmin[0] = ssdcableslay6rightsideradiusmax;
7741   ssdcableslay6waterpconrmax[0] = ssdcableslay6rightsideradiusmax
7742                                                             + kSSDCablesLay5RightSideWaterHeight;
7743   ssdcableslay6waterpconrmin[1] = ssdcableslay6waterpconrmin[0];
7744   ssdcableslay6waterpconrmax[1] = ssdcableslay6waterpconrmax[0];
7745   ssdcableslay6waterpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7746                                                            + fgkEndCapSupportCenterLay6Position
7747                                                            + ssdcablelay6rightsidelength;
7748   ssdcableslay6waterpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7749   for(Int_t i=0; i<2;i++) ssdcableslay6waterpconshape->DefineSection(i,ssdcableslay6waterpconzsection[i],
7750                                                   ssdcableslay6waterpconrmin[i],ssdcableslay6waterpconrmax[i]);
7751   ssdcableslay6waterpcon = new TGeoVolume("SSDCableLay6RightSideWaterPCon",
7752                                                            ssdcableslay6waterpconshape,fSSDCoolingTubeWater);
7753   ssdcableslay6waterpcon->SetLineColor(7);
7754   TGeoRotation* ssdcableslay6pconwaterot[4];
7755   TGeoRotation* ssdcablesLay6RightPConToLeftRot = new TGeoRotation();
7756   ssdcablesLay6RightPConToLeftRot->SetAngles(90.,180.,-90);
7757   TGeoHMatrix* ssdcablesLay6RightPConToLeftMatrix[4];
7758   for(Int_t i=0; i<4; i++){
7759    ssdcableslay6pconwaterot[i] = new TGeoRotation();
7760    ssdcableslay6pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7761    ssdcablesLay6RightPConToLeftMatrix[i] = new TGeoHMatrix((*ssdcablesLay6RightPConToLeftRot)
7762                                                                                  * (*ssdcableslay6pconwaterot[i]));
7763    ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+1,ssdcableslay6pconwaterot[i]);
7764    ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+5,ssdcablesLay6RightPConToLeftMatrix[i]);
7765   }
7766   ////////////////////////////////////////
7767   // From ITS Ring to Patch Panel3-RB26
7768   ////////////////////////////////////////
7769   Double_t ssdcablepatchpanel3BB26radiusmin[2];
7770   Double_t ssdcablepatchpanel3BB26radiusmax[2];
7771   Double_t ssdcablepatchpanel3RB26zsection[2];
7772   ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*kSSDPatchPanelHeight;// +2.8+0.003;//Avoid small overlap with SPDshieldring;
7773   ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0]
7774                                         + kSSDCablesHeight;
7775   ssdcablepatchpanel3BB26radiusmin[1] = kSSDPatchPanel2RB26Radius;
7776   ssdcablepatchpanel3BB26radiusmax[1] = ssdcablepatchpanel3BB26radiusmin[1]
7777                                         + kSSDCablesHeight;
7778   ssdcablepatchpanel3RB26zsection[0] = 0.5*fgkSSDCentralSupportLength
7779                                         + fgkSSDCentralAL3SupportLength
7780                                                                                  + fgkSSDPConeZLength[0];
7781   ssdcablepatchpanel3RB26zsection[1] = kSSDPatchPanel2RB26ITSDistance;
7782   // Printf(Form("RB26 cable length %g",ssdcablepatchpanel3RB26zsection[1]-ssdcablepatchpanel3RB26zsection[0]));
7783   // Printf(Form("Angular range %g",ssdcableangle));
7784
7785   TGeoPcon* ssdcablepatchpanel3RB26pconshape =
7786                                                                 new TGeoPcon(90.0-kSSDCablesPatchPanel2RB26Angle[0]
7787                                                                                                 - 0.5*ssdcableangle,ssdcableangle,2);
7788   for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB26pconshape->DefineSection(i,ssdcablepatchpanel3RB26zsection[i],
7789                                                   ssdcablepatchpanel3BB26radiusmin[i],ssdcablepatchpanel3BB26radiusmax[i]);
7790   TGeoVolume* ssdcablepatchpanel3RB26pcon = new TGeoVolume("SSDCablePatchPanel3RB26",
7791                                                                                                 ssdcablepatchpanel3RB26pconshape,fSSDCopper);
7792   ssdcablepatchpanel3RB26pcon->SetLineColor(9);
7793   TGeoRotation* ssdcablepatchpanel3B26rot[4];
7794   for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
7795   ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
7796   ssdcablepatchpanel3B26rot[1]->SetAngles(kSSDCablesPatchPanel2RB26Angle[0]
7797                                           + kSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
7798   ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0);
7799   ssdcablepatchpanel3B26rot[3]->SetAngles(180.0 + kSSDCablesPatchPanel2RB26Angle[0]
7800                                                 + kSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
7801   for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]);
7802   // Printf(Form("Cable to patch panels RB26 volume: %g (x4)",ssdcablepatchpanel3RB26pcon->Capacity()));
7803   ////////////////////////////////////
7804   //cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity();
7805   ////////////////////////////////////////
7806   //  ITS Ring Cables RB26 Part
7807   ////////////////////////////////////////
7808   Double_t ssdcableitsring3BB26pconzsection[2];
7809   Double_t ssdcableitsring3BB26pconrmin[2];
7810   Double_t ssdcableitsring3BB26pconrmax[2];
7811   ssdcableitsring3BB26pconzsection[0] = 0.5*fgkSSDCentralSupportLength
7812                                                                           + fgkSSDCentralAL3SupportLength
7813                                                                           + (4.0/5.0)*fgkSSDPConeZLength[0];
7814   ssdcableitsring3BB26pconzsection[1] = ssdcablepatchpanel3RB26zsection[0];
7815   ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*kSSDPatchPanelHeight;
7816   ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0] + 2.5*kSSDCablesHeight; // widths of cable bunch is about half of patch panels; need factor 2.5
7817
7818   ssdcableitsring3BB26pconrmin[1] = ssdcablepatchpanel3BB26radiusmin[0];
7819   ssdcableitsring3BB26pconrmax[1] = ssdcablepatchpanel3BB26radiusmax[0];
7820   TGeoPcon* ssdcableitsring3BB26pconshape[4];
7821   ssdcableitsring3BB26pconshape[0] = new TGeoPcon(90.0 - kSSDCablesPatchPanel2RB26Angle[0]
7822                                                                    -              0.5*ssdcableangle,ssdcableangle
7823                                                                    +                            (kSSDCablesPatchPanel2RB26Angle[0]
7824                                                                    -                             kSSDCableAngle),2);
7825   ssdcableitsring3BB26pconshape[1] = new TGeoPcon(90.0 + kSSDCablesPatchPanel2RB26Angle[1]
7826                                                                    -              0.5*ssdcableangle,ssdcableangle
7827                                                                    +                      3.0*kSSDCableAngle
7828                                                                    -                      kSSDCablesPatchPanel2RB26Angle[1],2);
7829   ssdcableitsring3BB26pconshape[2] = new TGeoPcon(270-kSSDCablesPatchPanel2RB26Angle[0]
7830                                                                    -              0.5*ssdcableangle,ssdcableangle
7831                                                                    -                      kSSDCableAngle
7832                                                                    +                      kSSDCablesPatchPanel2RB26Angle[0],2);
7833   ssdcableitsring3BB26pconshape[3] = new TGeoPcon(270.0+kSSDCablesPatchPanel2RB26Angle[1]
7834                                                                    -              0.5*ssdcableangle,ssdcableangle
7835                                                                    +                      3.0*kSSDCableAngle
7836                                                                    -                      kSSDCablesPatchPanel2RB26Angle[1],2);
7837   for(Int_t i=0;i<4;i++)
7838         for(Int_t j=0; j<2; j++) ssdcableitsring3BB26pconshape[i]->DefineSection(j,ssdcableitsring3BB26pconzsection[j],
7839                                                          ssdcableitsring3BB26pconrmin[j],
7840                                                          ssdcableitsring3BB26pconrmax[j]);
7841   TGeoVolume* ssdcableitsring3BB26pcon[4];
7842   ssdcableitsring3BB26pcon[0] = new TGeoVolume("SSDCableITSRing3RB26Part1",
7843                                                                                                 ssdcableitsring3BB26pconshape[0],fSSDCopper);
7844   ssdcableitsring3BB26pcon[1] = new TGeoVolume("SSDCableITSRing3RB26Part2",
7845                                                                                                 ssdcableitsring3BB26pconshape[1],fSSDCopper);
7846   ssdcableitsring3BB26pcon[2] = new TGeoVolume("SSDCableITSRing3RB26Part3",
7847                                                                                                 ssdcableitsring3BB26pconshape[2],fSSDCopper);
7848   ssdcableitsring3BB26pcon[3] = new TGeoVolume("SSDCableITSRing3RB26Part4",
7849                                                                                                 ssdcableitsring3BB26pconshape[3],fSSDCopper);
7850   for(Int_t i=0;i<4;i++){
7851         ssdcableitsring3BB26pcon[i]->SetLineColor(9);
7852         ssdcablesmother->AddNode(ssdcableitsring3BB26pcon[i],1);
7853         //Printf(Form("Cable to patch panels RB26 volume part 2: %g (%d)",ssdcableitsring3BB26pcon[i]->Capacity(),i));
7854 }
7855
7856   ////////////////////////////////////
7857   //cablescapacity[11] = ssdcableitsring3BB26pconshape[0]->Capacity()
7858   //                             + ssdcableitsring3BB26pconshape[1]->Capacity()
7859   //                             + ssdcableitsring3BB26pconshape[2]->Capacity()
7860   //                             + ssdcableitsring3BB26pconshape[3]->Capacity();
7861   ////////////////////////////////////////
7862   // From ITS Ring to Patch Panel2-RB24
7863   ////////////////////////////////////////
7864   Double_t ssdcablepatchpanel3BB24radiusmin[2];
7865   Double_t ssdcablepatchpanel3BB24radiusmax[2];
7866   Double_t ssdcablepatchpanel3RB24zsection[2];
7867   ssdcablepatchpanel3BB24radiusmin[0] = ssdcablepatchpanel3BB26radiusmin[0];
7868   ssdcablepatchpanel3BB24radiusmax[0] = ssdcablepatchpanel3BB26radiusmax[0];
7869   ssdcablepatchpanel3BB24radiusmin[1] = kSSDPatchPanel2RB24Radius;
7870   ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1]
7871                                         + kSSDCablesHeight;
7872   ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength
7873                                                                          -  fgkSSDCentralAL3SupportLength
7874                                                                          -  fgkSSDPConeZLength[0];
7875   ssdcablepatchpanel3RB24zsection[1] = -kSSDPatchPanel2RB24ITSDistance;
7876   //Printf(Form("RB24 cable length %g",ssdcablepatchpanel3RB24zsection[1]-ssdcablepatchpanel3RB24zsection[0]));
7877   TGeoPcon* ssdcablepatchpanel3RB24pconshape =
7878                                                                 new TGeoPcon(90.0-kSSDCablesPatchPanel2RB24Angle[1]
7879                                                                                                 - 0.5*ssdcableangle,ssdcableangle,2);
7880   for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB24pconshape->DefineSection(i,ssdcablepatchpanel3RB24zsection[i],
7881                                                   ssdcablepatchpanel3BB24radiusmin[i],ssdcablepatchpanel3BB24radiusmax[i]);
7882   TGeoVolume* ssdcablepatchpanel3RB24pcon = new TGeoVolume("SSDCablePatchPanel3RB24",
7883                                                                                                 ssdcablepatchpanel3RB24pconshape,
7884                                                                                                 fSSDCopper);
7885   ssdcablepatchpanel3RB24pcon->SetLineColor(9);
7886   TGeoRotation* ssdcablepatchpanel3B24rot[4];
7887   for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation();
7888   ssdcablepatchpanel3B24rot[0]->SetAngles(-6.0,0.0,0.0);
7889   ssdcablepatchpanel3B24rot[1]->SetAngles(kSSDCablesPatchPanel2RB24Angle[0]
7890                                           + kSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
7891   ssdcablepatchpanel3B24rot[2]->SetAngles(174.0,0.0,0.0);
7892   ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+kSSDCablesPatchPanel2RB24Angle[0]
7893                                           + kSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
7894   for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB24pcon,i+1,ssdcablepatchpanel3B24rot[i]);
7895   //Printf(Form("Cable to patch panels RB24 volume: %g (x4)",ssdcablepatchpanel3RB24pcon->Capacity()));
7896   ////////////////////////////////////
7897   //cablescapacity[12] = 4.*ssdcablepatchpanel3RB24pconshape->Capacity();
7898   ////////////////////////////////////////
7899   //  ITS Ring Cables RB24 Part
7900   ////////////////////////////////////////
7901   Double_t ssdcableitsring3BB24pconzsection[2];
7902   Double_t ssdcableitsring3BB24pconrmin[2];
7903   Double_t ssdcableitsring3BB24pconrmax[2];
7904   ssdcableitsring3BB24pconzsection[0] = -ssdcableitsring3BB26pconzsection[0];
7905   ssdcableitsring3BB24pconzsection[1] = ssdcablepatchpanel3RB24zsection[0];
7906   ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*kSSDPatchPanelHeight;
7907   ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0] + 2.5*kSSDCablesHeight;  // Cable bunch width smaller; make it thicker
7908
7909   ssdcableitsring3BB24pconrmin[1] = ssdcablepatchpanel3BB24radiusmin[0];
7910   ssdcableitsring3BB24pconrmax[1] = ssdcablepatchpanel3BB24radiusmax[0];
7911   TGeoPcon* ssdcableitsring3BB24pconshape[4];
7912   ssdcableitsring3BB24pconshape[0] = new TGeoPcon(kSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7913                                                                + (90.0-kSSDCablesPatchPanel2RB24Angle[1]
7914                                                                    - kSSDCableAngle),2);
7915   ssdcableitsring3BB24pconshape[1] = new TGeoPcon(90.0+kSSDCableAngle-0.5*ssdcableangle,
7916                                                                      ssdcableangle-kSSDCableAngle
7917                                                                    + kSSDCablesPatchPanel2RB24Angle[0],2);
7918   ssdcableitsring3BB24pconshape[2] = new TGeoPcon(180.0+kSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7919                                                                    - kSSDCableAngle
7920                                                                    + 90.0 - kSSDCablesPatchPanel2RB24Angle[1],2);
7921   ssdcableitsring3BB24pconshape[3] = new TGeoPcon(270.0+kSSDCableAngle-0.5*ssdcableangle,
7922                                                                    ssdcableangle-kSSDCableAngle
7923                                                                    + kSSDCablesPatchPanel2RB24Angle[0],2);
7924   for(Int_t i=0;i<4;i++)
7925         for(Int_t j=0; j<2; j++) ssdcableitsring3BB24pconshape[i]->DefineSection(j,ssdcableitsring3BB24pconzsection[j],
7926                                                          ssdcableitsring3BB24pconrmin[j],
7927                                                          ssdcableitsring3BB24pconrmax[j]);
7928   TGeoVolume* ssdcableitsring3BB24pcon[4];
7929   ssdcableitsring3BB24pcon[0] = new TGeoVolume("SSDCableITSRing3RB24Part1",
7930                                                                                                 ssdcableitsring3BB24pconshape[0],fSSDCopper);
7931   ssdcableitsring3BB24pcon[1] = new TGeoVolume("SSDCableITSRing3RB24Part2",
7932                                                                                                 ssdcableitsring3BB24pconshape[1],fSSDCopper);
7933   ssdcableitsring3BB24pcon[2] = new TGeoVolume("SSDCableITSRing3RB24Part3",
7934                                                                                                 ssdcableitsring3BB24pconshape[2],fSSDCopper);
7935   ssdcableitsring3BB24pcon[3] = new TGeoVolume("SSDCableITSRing3RB24Part4",
7936                                                                                                 ssdcableitsring3BB24pconshape[3],fSSDCopper);
7937   for(Int_t i=0;i<4;i++){
7938         ssdcableitsring3BB24pcon[i]->SetLineColor(9);
7939         ssdcablesmother->AddNode(ssdcableitsring3BB24pcon[i],1);
7940         // Printf(Form("Cable to patch panels RB24 (part 2) volume: %g (%d)",ssdcableitsring3BB24pcon[i]->Capacity(),i));
7941 }
7942
7943   ////////////////////////////////////
7944   //cablescapacity[13] = ssdcableitsring3BB24pconshape[0]->Capacity()
7945   //                                     + ssdcableitsring3BB24pconshape[1]->Capacity()
7946   //                                     + ssdcableitsring3BB24pconshape[2]->Capacity()
7947   //                                     + ssdcableitsring3BB24pconshape[3]->Capacity();
7948
7949   // MvL: Pcon are connection to patch panels (part of)
7950   // Removed; do not contribute much; put into ring structure
7951   /*
7952   TGeoPcon* ssdcablelay6materialbudgetpconshape =
7953                                         new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,ssdcableangle,2);
7954   TGeoVolume* ssdcablelay6materialbudgetpcon;
7955   Double_t ssdcablelay6materialbudgetpconrmin[2];
7956   Double_t ssdcablelay6materialbudgetpconrmax[2];
7957   Double_t ssdcablelay6materialbudgetpconzsection[2];
7958   ssdcablelay6materialbudgetpconrmin[0] = ssdcableslay6rightsideradiusmax
7959                                                                                 + kSSDCablesLay5RightSideWaterHeight;
7960   ssdcablelay6materialbudgetpconrmax[0] = ssdcablelay6materialbudgetpconrmin[0]
7961                                                                                 + kSSDCableMaterialBudgetHeight;
7962   ssdcablelay6materialbudgetpconrmin[1] = ssdcablelay6materialbudgetpconrmin[0];
7963   ssdcablelay6materialbudgetpconrmax[1] = ssdcablelay6materialbudgetpconrmax[0];
7964   ssdcablelay6materialbudgetpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7965                                                                                         + fgkEndCapSupportCenterLay6Position
7966                                                                                         + ssdcablelay6rightsidelength;
7967   ssdcablelay6materialbudgetpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7968   for(Int_t i=0; i<2;i++) ssdcablelay6materialbudgetpconshape->DefineSection(i,
7969                                                   ssdcablelay6materialbudgetpconzsection[i],
7970                                                   ssdcablelay6materialbudgetpconrmin[i],
7971                                                   ssdcablelay6materialbudgetpconrmax[i]);
7972   ssdcablelay6materialbudgetpcon = new TGeoVolume("SSDCableLay6MaterialBudgetPCon",
7973                                                            ssdcablelay6materialbudgetpconshape,fSSDCopper);
7974   ssdcablelay6materialbudgetpcon->SetLineColor(9);
7975   for(Int_t i=0; i<4; i++){
7976    ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+1,ssdcableslay5pconrot[i]);
7977    ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7978   }
7979   */
7980 ////////////////////////////////////
7981  /* cablescapacity[14] = 2.*ssdcablelay6materialbudgetubeshape->Capacity();
7982   cablescapacity[15] = 2.*ssdcablelay6materialbudgetpconshape->Capacity();
7983   Double_t ssdcablesvolume = 0.0;
7984   for(Int_t i=0;i<16;i++) ssdcablesvolume+=cablescapacity[i];
7985   std::cout << ssdcablesvolume << std::endl;*/
7986   // Printf(Form("Total volume (one side; without conn to patch panel): %g",totvol));
7987   return ssdcablesmother;
7988  }
7989  ////////////////////////////////////////////////////////////////////////////////
7990 TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3 const * const vertexpos[4] , const Double_t* width,
7991                                             Double_t height, const char* shapename, Int_t isign) const{
7992   /////////////////////////////////////////////////////////////
7993   // Method generating an Arb shape
7994   /////////////////////////////////////////////////////////////
7995   const Int_t kvertexnumber = 8;
7996   const Int_t ktransvectnumber = 2;
7997   TVector3 vertex[kvertexnumber];
7998   TVector3 transvector[2];
7999   for(Int_t i=0; i<ktransvectnumber; i++) transvector[i].SetY(width[i]);
8000   /////////////////////////////////////////////////////////////
8001   //Setting the vertices for TGeoArb8
8002   /////////////////////////////////////////////////////////////
8003   vertex[0] = *vertexpos[0];
8004   vertex[1] = *vertexpos[1];
8005   vertex[2] = vertex[1];
8006   vertex[3] = vertex[0];
8007   vertex[4] = *vertexpos[2];
8008   vertex[5] = *vertexpos[3];
8009   vertex[6] = vertex[5];
8010   vertex[7] = vertex[4];
8011
8012   // NB: order of points is clockwise
8013   if (isign < 0) {
8014     vertex[2] -= transvector[0];
8015     vertex[3] -= transvector[0];
8016     vertex[6] -= transvector[1];
8017     vertex[7] -= transvector[1];
8018   }
8019   else {
8020     vertex[0] += transvector[0];
8021     vertex[1] += transvector[0];
8022     vertex[4] += transvector[1];
8023     vertex[5] += transvector[1];
8024   }
8025
8026   /////////////////////////////////////////////////////////////
8027   TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
8028   for(Int_t i = 0; i<kvertexnumber;i++) {
8029     arbshape->SetVertex(i,vertex[i].X(),vertex[i].Y());
8030   }
8031
8032   return arbshape;
8033 }
8034 ///////////////////////////////////////////////////////////////////////////////
8035 TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
8036                                                                 Double_t rmax, Int_t nedges, Double_t height){
8037   /////////////////////////////////////////////////////////////
8038   // Method generating Arc shape
8039   /////////////////////////////////////////////////////////////
8040         const Int_t kvertexnumber = 2*nedges+2;
8041         TGeoXtru* arcshape = new TGeoXtru(2);
8042         TVector3** vertexposition[2];
8043         for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
8044         Double_t angle = 0.;
8045     for(Int_t i=0; i<nedges+1; i++){
8046                 angle = 90.+0.5*phi-i*(phi/nedges);
8047                 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle),0);
8048                 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle),0);
8049         }
8050         Double_t *xvertexpoints = new Double_t[kvertexnumber];
8051         Double_t *yvertexpoints = new Double_t[kvertexnumber];
8052         for(Int_t i=0; i<kvertexnumber; i++){
8053                 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
8054                                   yvertexpoints[i] = vertexposition[0][i]->Y();
8055                 }
8056                 else if(i>=1&&i<nedges+2)
8057                 {
8058                         xvertexpoints[i] = vertexposition[1][i-1]->X();
8059                         yvertexpoints[i] = vertexposition[1][i-1]->Y();
8060                 }
8061         else
8062                 {
8063                         xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
8064                         yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
8065                 }
8066     }
8067   arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
8068   arcshape->DefineSection(0,-0.5*height);
8069   arcshape->DefineSection(1,0.5*height);
8070   /////////////////////////////////////////////////////////////
8071   // Deallocating memory
8072   /////////////////////////////////////////////////////////////
8073   for(Int_t i=0; i<2; i++){
8074         for(Int_t j=0; j<nedges+1; j++)
8075                 delete vertexposition[i][j];
8076         delete [] vertexposition[i];
8077   }
8078   delete [] xvertexpoints;
8079   delete [] yvertexpoints;
8080   /////////////////////////////////////////////////////////////
8081         return arcshape;
8082 }
8083 ////////////////////////////////////////////////////////////////////////////////
8084 TGeoShape* AliITSv11GeometrySSD::GetScrewShape(const Double_t* radius,const Int_t* edgesnumber,const Double_t* section) const {
8085   ///////////////////////////////////////////////////////////////////////
8086   // Method Generating the Screw Shape
8087   // radius[0]: outer radius
8088   // radius[1]: inner radius
8089   // edgesnumber[0]: outer number of edges
8090   // edgesnumber[1]: inner number of edges
8091   // section[0]: lower section position
8092   // section[1]: higher section position
8093   ///////////////////////////////////////////////////////////////////////
8094   Double_t outradius = radius[0];
8095   Double_t inradius = radius[1];
8096   Int_t outvertexnumber = edgesnumber[0];
8097   Int_t invertexnumber = edgesnumber[1];
8098   Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8099   Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8100   for(Int_t i=0; i<outvertexnumber; i++){
8101         xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
8102         yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
8103   }
8104   for(Int_t i=0; i<invertexnumber; i++){
8105         xscrewvertex[outvertexnumber+i] = inradius*CosD(90.+i*360./invertexnumber);
8106         yscrewvertex[outvertexnumber+i] = inradius*SinD(90.+i*360./invertexnumber);
8107   }
8108   TGeoXtru* screwshapeout = new TGeoXtru(2);
8109   screwshapeout->DefinePolygon(outvertexnumber,xscrewvertex,yscrewvertex);
8110   screwshapeout->DefineSection(0,section[0]);
8111   screwshapeout->DefineSection(1,section[1]);
8112   TGeoXtru* screwshapein = new TGeoXtru(2);
8113   screwshapein->DefinePolygon(invertexnumber,&xscrewvertex[outvertexnumber],&yscrewvertex[outvertexnumber]);
8114   screwshapein->DefineSection(0,section[0]-0.01); // make inner part bigger in Z
8115   screwshapein->DefineSection(1,section[1]+0.01); // safer when we subtract it
8116   TGeoSubtraction *snode = new TGeoSubtraction(screwshapeout, screwshapein);
8117   TGeoCompositeShape *screwshape = new TGeoCompositeShape("", snode);
8118
8119   delete [] xscrewvertex;
8120   delete [] yscrewvertex;
8121   return screwshape;
8122 }
8123 ////////////////////////////////////////////////////////////////////////////////
8124 TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, const Double_t *section) const {
8125   ///////////////////////////////////////////////////////////////////////
8126   // Method Generating the Hole Shape
8127   // radius of the Hole
8128   // nedges: number of edges to approximate the circle
8129   ///////////////////////////////////////////////////////////////////////
8130   Double_t* xholevertex = new Double_t[nedges];
8131   Double_t* yholevertex = new Double_t[nedges];
8132   Double_t z  = 0.5*(section[0]+section[1]);
8133   Double_t dz = 0.5*(section[1]-section[0]);
8134   TGeoTranslation *tr = 0;
8135   if (TMath::Abs(z) > TGeoShape::Tolerance()) {
8136      tr = new TGeoTranslation(0.,0.,z);
8137      tr->RegisterYourself();
8138   }
8139   TGeoBBox *box = new TGeoBBox("",radius,radius,dz);
8140   for(Int_t i=0; i<nedges; i++){
8141         xholevertex[i] = radius*CosD(i*360./nedges);
8142         yholevertex[i] = radius*SinD(i*360./nedges);
8143   }
8144   TGeoXtru* holeshapeout = new TGeoXtru(2);
8145   holeshapeout->DefinePolygon(nedges,xholevertex,yholevertex);
8146   holeshapeout->DefineSection(0,section[0]-0.01); // make subtracted part larger in Z
8147   holeshapeout->DefineSection(1,section[1]+0.01);
8148   TGeoSubtraction *snode = new TGeoSubtraction(box,holeshapeout,tr);
8149   TGeoCompositeShape *holeshape = new TGeoCompositeShape("", snode);
8150
8151   delete [] xholevertex;
8152   delete [] yholevertex;
8153   return holeshape;
8154 }
8155 ////////////////////////////////////////////////////////////////////////////////
8156 TVector3* AliITSv11GeometrySSD::GetReflection(const TVector3* vector,const Double_t* param) const{
8157   /////////////////////////////////////////////////////////////
8158   // Given an axis specified by param, it gives the reflection of the point
8159   // respect to the axis
8160   /////////////////////////////////////////////////////////////
8161   TVector3* n = new TVector3(param[0],param[1],param[2]);
8162   Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
8163   TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
8164   /////////////////////////////////////////////////////////////
8165   // Deallocating memory
8166   /////////////////////////////////////////////////////////////
8167   delete n;
8168   /////////////////////////////////////////////////////////////
8169   return reflectedvector;
8170 }
8171 ////////////////////////////////////////////////////////////////////////////////
8172 TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(const TGeoHMatrix* ct,
8173                                                        Double_t dx,
8174                                                        Double_t dy,
8175                                                        Double_t dz) const{
8176   /////////////////////////////////////////////////////////////
8177   // Add a dx,dy,dz translation to the initial TGeoCombiTrans
8178   /////////////////////////////////////////////////////////////
8179   TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
8180   const Double_t *vect = hmatrix->GetTranslation();
8181   Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
8182   hmatrix->SetTranslation(newvect);
8183   TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
8184   delete hmatrix;
8185   return matrix;
8186 }
8187 ////////////////////////////////////////////////////////////////////////////////
8188 TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
8189   /////////////////////////////////////////////////////////////
8190   // Method returning the Medium type
8191   /////////////////////////////////////////////////////////////
8192   char ch[100];
8193   snprintf(ch,100, "ITS_%s",mediumName);
8194   TGeoMedium* medium =  gGeoManager->GetMedium(ch);
8195   if (! medium)
8196     AliError(Form("medium %s not found !\n", mediumName));
8197   return medium;
8198 }
8199 ////////////////////////////////////////////////////////////////////////////////
8200 void AliITSv11GeometrySSD::CreateMaterials(){
8201 ///////////////////////////////////
8202 // This part has to be modified
8203 ///////////////////////////////////
8204   ///////////////////////////////////
8205   // Silicon for Sensor
8206   ///////////////////////////////////
8207   fSSDSensorMedium = GetMedium("SI$");
8208   ///////////////////////////////////
8209   // Silicon Mixture for Sensor
8210   ///////////////////////////////////
8211   fSSDChipMedium = GetMedium("SPD SI CHIP$");
8212   fSSDChipGlueMedium = GetMedium("EPOXY$");
8213   ///////////////////////////////////
8214   // Stiffener Components Materials
8215   ///////////////////////////////////
8216   fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
8217   ///////////////////////////
8218   // Stiffener Connectors
8219   ///////////////////////////
8220   fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
8221   ////////////////////////////////
8222   // Stiffener 0603-1812 Capacitor
8223   ////////////////////////////////
8224   fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8225   fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8226   fSSDStiffenerCapacitorCapMedium = GetMedium("NiSn$");
8227   ///////////////////////////
8228   // Stiffener Hybrid Wire
8229   ///////////////////////////
8230   fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
8231   ///////////////////////////
8232   // Al for Cooling Block
8233   ///////////////////////////
8234   fSSDAlCoolBlockMedium = GetMedium("AL$");
8235   //////////////////////////////////////////////////////
8236   // Kapton and Al for Chip Cable Flex and Ladder Cables
8237   //////////////////////////////////////////////////////
8238   fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8239   fSSDAlTraceChipCableMedium = GetMedium("AL$");
8240   fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
8241   fSSDAlTraceFlexMedium = GetMedium("AL$");
8242   fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8243   fSSDAlTraceLadderCableMedium = GetMedium("AL$");
8244   /////////////////////////////////////////////////////////////////
8245   // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
8246   //////////////////////////////////////////////////////////////////
8247   fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
8248   /////////////////////////////////////////////////////////////////
8249   // G10 for Detector Leg, TubeHolder
8250   //////////////////////////////////////////////////////////////////
8251   fSSDTubeHolderMedium = GetMedium("G10FR4$");
8252   fSSDSensorSupportMedium = GetMedium("G10FR4$");
8253   fSSDMountingBlockMedium = GetMedium("G10FR4$");
8254   fSSDMountingBlockMedium = GetMedium("G10FR4$");
8255   /////////////////////////////////////////////////////////////////
8256   // Water and Phynox for Cooling Tube
8257   //////////////////////////////////////////////////////////////////
8258   fSSDCoolingTubeWater = GetMedium("WATER$");
8259   fSSDCoolingTubePhynox = GetMedium("INOX$");
8260   /////////////////////////////////////////////////////////////////////
8261   // Material for Support Rings
8262   /////////////////////////////////////////////////////////////////////
8263   fSSDSupportRingAl = GetMedium("AL$");
8264   fSSDRohaCellCone = GetMedium("ROHACELL$");
8265   /////////////////////////////////////////////////////////////////////
8266   fSSDAir = GetMedium("SDD AIR$");
8267   fSSDCopper = GetMedium("COPPER$");
8268   fSSDSn = GetMedium("Sn$");
8269   fCreateMaterials = kTRUE;
8270 }
8271 /////////////////////////////////////////////////////////////////////
8272