ITS/AliITSv11GeometrySSD.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 //*************************************************************************
  19 // SSD geometry, based on ROOT geometrical modeler
  20 //
  21 // Enrico Cattaruzza                                    ecattar@ts.infn.it
  22 //*************************************************************************
  23 #include "TMath.h"
  24 #include "TGeoVolume.h"
  25 #include "TGeoMatrix.h"
  26 #include <TGeoManager.h>
  27 #include "TVector3.h"
  28 #include "TGeoArb8.h"
  29 #include "TList.h"
  30 #include "TGeoMatrix.h"
  31 #include "TGeoCompositeShape.h"
  32 #include "TGeoTube.h"
  33 #include "TGeoBBox.h"
  34 #include "TGeoXtru.h"
  35 #include "TGeoTorus.h"
  36 #include "TGeoPgon.h"
  37 #include "TRotation.h"
  38 #include "AliITSv11GeometrySSD.h"
  39 /////////////////////////////////////////////////////////////////////////////////
  40 // Names of the Sensitive Volumes of Layer 5 and Layer 6
  41 /////////////////////////////////////////////////////////////////////////////////
  42 const char* AliITSv11GeometrySSD::fgSDDsensitiveVolName5 = "ITSsddSensitivL5";
  43 const char* AliITSv11GeometrySSD::fgSDDsensitiveVolName6 = "ITSsddSensitivL6";
  44 /////////////////////////////////////////////////////////////////////////////////
  45 //Parameters for SSD Geometry
  46 /////////////////////////////////////////////////////////////////////////////////
  47 // Layer5 (lengths are in mm and angles in degrees)
  48 /////////////////////////////////////////////////////////////////////////////////
  49 const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength      = 950.7*fgkmm;
  50 const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber        =  22;
  51 const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber         =  34;
  52 const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin         = 378.0*fgkmm;
  53 const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax         = 384.0*fgkmm;
  54 const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition    = 467.85*fgkmm;
  55 /////////////////////////////////////////////////////////////////////////////////
  56 // Layer6 (lengths are in mm and angles in degrees)
  57 /////////////////////////////////////////////////////////////////////////////////
  58 const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength      = 1068.0*fgkmm;
  59 const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber        =   25;
  60 const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber         =   38;
  61 const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin         =  428.0*fgkmm;
  62 const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax         =  434.0*fgkmm;
  63 const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition    = 526.50*fgkmm;
  64 /////////////////////////////////////////////////////////////////////////////////
  65 // SSD Chips and Hybrid (lengths are in mm and angles in degrees)
  66 /////////////////////////////////////////////////////////////////////////////////
  67 const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber               =   6;
  68 const Double_t AliITSv11GeometrySSD::fgkSSDChipLength            =  11.100*fgkmm;
  69 const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth             =   3.850*fgkmm;
  70 const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight            =   0.180*fgkmm;
  71 const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength  =   1.000*fgkmm;
  72 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength     = fgkSSDChipLength;
  73 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth      =  fgkSSDChipWidth;
  74 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight        =   0.030*fgkmm;
  75 /////////////////////////////////////////////////////////////////////////////////
  76 // Stiffener (lengths are in mm and angles in degrees)
  77 /////////////////////////////////////////////////////////////////////////////////
  78 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength       =  73.000*fgkmm;
  79 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth        =   6.500*fgkmm;
  80 //const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight       =   3.315;
  81 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight       =   0.315*fgkmm;
  82 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist   =   2.500*fgkmm;
  83 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length   = 1.600*fgkmm;
  84 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width    =   0.870*fgkmm;
  85 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height   =   0.800*fgkmm;
  86 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length   =   4.600*fgkmm;
  87 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width    =   3.400*fgkmm;
  88 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height   =   0.700*fgkmm; // multiplied by 0.5
  89 const Double_t AliITSv11GeometrySSD::fgkSSDWireLength            =  30.000*fgkmm;
  90 const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius            =   0.185*fgkmm;
  91 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2]  =
  92                                                                                                            {44.32*fgkmm, 0.33*fgkmm};
  93 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation   =        0.44*fgkmm;
  94 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength       =        2.16*fgkmm;
  95 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth        =        3.60*fgkmm;
  96 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight       =
  97                                                                                                           0.25*fgkSSDStiffenerHeight;
  98 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight     =       0.030*fgkmm;
  99 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight     =   0.002*fgkmm;
 100 /////////////////////////////////////////////////////////////////////////////////
 101 // Cooling Block (lengths are in mm and angles in degrees)
 102 /////////////////////////////////////////////////////////////////////////////////
 103 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength    =   3.000*fgkmm;
 104 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth     =   4.000*fgkmm;
 105 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
 106                                                                                  {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
 107 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
 108                                                                                                           {1.000*fgkmm, 0.120*fgkmm};
 109 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
 110                                                                                                           {1.900*fgkmm, 0.400*fgkmm};
 111 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter    =
 112                                                                                                                                          1.500*fgkmm;
 113 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight    =
 114                                                                                                                                          0.300*fgkmm;
 115 /////////////////////////////////////////////////////////////////////////////////
 116 // SSD Sensor (lengths are in mm and angles in degrees)
 117 /////////////////////////////////////////////////////////////////////////////////
 118 const char*  AliITSv11GeometrySSD::fgkSSDSensitiveVolName       =
 119                                                                                                                  "SSDSensorSensitiveVol";
 120 const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength          =  42.000*fgkmm;
 121 const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight          =   0.300*fgkmm;
 122 const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth           =  75.000*fgkmm;
 123 const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap         =
 124                                                                                                    fgkSSDSensorLength-39.1*fgkmm;
 125 const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength    = 1.*fgkmm;
 126 const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth     = 1.*fgkmm;
 127 /////////////////////////////////////////////////////////////////////////////////
 128 // Flex (lengths are in mm and angles in degrees)
 129 /////////////////////////////////////////////////////////////////////////////////
 130 const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength       =  106.000*fgkmm;
 131 const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4]        =
 132                         {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
 133                                  + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
 134                          0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
 135                                  + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)
 136                                                                            - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm};
 137 const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2]         =
 138                                                                                                    {  9.340*fgkmm,  5.380*fgkmm};
 139 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2]        =
 140                                                                                                    {  0.030*fgkmm,  0.020*fgkmm};
 141 const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle            =   30.000;
 142 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength       =    1.430*fgkmm;
 143 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth        =    3.000*fgkmm;
 144 const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
 145                          {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
 146 const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
 147                                                                                    {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
 148 /////////////////////////////////////////////////////////////////////////////////
 149 // SSD Ladder Cable (lengths are in mm and angles in degrees)
 150 /////////////////////////////////////////////////////////////////////////////////
 151 const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth     =     23.5*fgkmm;
 152 /////////////////////////////////////////////////////////////////////////////////
 153 // SSD Module (lengths are in mm and angles in degrees)
 154 /////////////////////////////////////////////////////////////////////////////////
 155 const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2]  =
 156                                                                                                          { 1.000*fgkmm, 3.900*fgkmm};
 157 const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
 158                                                                                                                                         45.600*fgkmm;
 159 const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor  =
 160                                                                                                                                          5.075*fgkmm;
 161 /////////////////////////////////////////////////////////////////////////////////
 162 // Sensor Support (lengths are in mm and angles in degrees)
 163 /////////////////////////////////////////////////////////////////////////////////
 164 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength                     =
 165                                                                                                                                          5.800*fgkmm;
 166 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth          =
 167                                                                                                                                          2.000*fgkmm;
 168 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2]      =
 169                                                                                                      { 4.620*fgkmm, 5.180*fgkmm};
 170 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2]   =
 171                                                                                                          { 0.450*fgkmm, 0.450*fgkmm};
 172 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition
 173                                                                 = 0.5 * (fgkSSDModuleSensorSupportDistance
 174                                                             +  fgkSSDSensorSideSupportThickness[0])
 175                                                                 -  fgkSSDSensorSideSupportLength;
 176 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength       =
 177                                                                                                                                     5.250*fgkmm;
 178 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth        =
 179                                                                                                                                         1.680*fgkmm;
 180 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]
 181                                                                   = {fgkSSDSensorSideSupportHeight[0]
 182                                                                   +  fgkSSDSensorSideSupportThickness[0],
 183                                                                          fgkSSDSensorSideSupportHeight[1]
 184                                                                   +  fgkSSDSensorSideSupportThickness[1]};
 185 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2]
 186                                                                   =  {fgkSSDSensorSideSupportThickness[0],
 187                                                                           fgkSSDSensorSideSupportThickness[1]};
 188 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition     =
 189                                                                                                                                    19.000*fgkmm;
 190 /////////////////////////////////////////////////////////////////////////////////
 191 // Chip Cables (lengths are in mm and angles in degrees)
 192 /////////////////////////////////////////////////////////////////////////////////
 193 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2]   =
 194                                   {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
 195 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4]   =
 196                                   {  0.014*fgkmm,  0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
 197                                                                   -  (fgkSSDSensorSideSupportHeight[1]
 198                                                                   -   fgkSSDSensorSideSupportHeight[0])
 199                                                                   -   fgkSSDCoolingBlockHoleCenter
 200                                                                   -   fgkSSDStiffenerHeight
 201                                                                   -   fgkSSDChipHeight-fgkSSDSensorHeight,
 202                                                                           fgkSSDModuleCoolingBlockToSensor
 203                                                                   -   fgkSSDCoolingBlockHoleCenter
 204                                                                   -       fgkSSDStiffenerHeight
 205                                                                   -   fgkSSDChipHeight-fgkSSDSensorHeight};
 206 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3]    =
 207                                             { 11.000*fgkmm,  0.800*fgkmm,  0.600*fgkmm};
 208 /////////////////////////////////////////////////////////////////////////////////
 209 // Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
 210 /////////////////////////////////////////////////////////////////////////////////
 211 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          =
 212                                                                                                                                         3.820*fgkmm;
 213 //const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          =
 214 //                                                                                                                                         3.780;
 215 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth           =
 216                                                                                  fgkSSDSensorLength-fgkSSDSensorOverlap;
 217 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2]         =
 218                                                                                                         {  0.86*fgkmm,  0.30*fgkmm};
 219 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2]        =
 220                                                                                                                                 { 30.00, 90.00};
 221 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
 222                                                                                                                                          1.78*fgkmm;
 223 /////////////////////////////////////////////////////////////////////////////////
 224 //Carbon Fiber Parameters (lengths are in mm and angles in degrees)
 225 /////////////////////////////////////////////////////////////////////////////////
 226 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength
 227                                                                    = fgkSSDModuleSensorSupportDistance
 228                                                                    - 2. * fgkCarbonFiberJunctionToSensorSupport;
 229 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
 230 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2]   =
 231                                                                                                   {  0.751*fgkmm,  0.482*fgkmm};
 232 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength  =
 233                                                                                                                                         1.630*fgkmm;
 234 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth =   0.950*fgkmm;
 235 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength
 236                                                                         = fgkCarbonFiberTriangleLength
 237                                                                         - 0.5*fgkCarbonFiberSupportTopEdgeDist[1]
 238                                                                         / TMath::Cos(fgkCarbonFiberTriangleAngle
 239                                                                         * TMath::DegToRad());
 240 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength
 241                                                                         = 0.5*(fgkCarbonFiberJunctionWidth
 242                                                                         - fgkCarbonFiberSupportWidth)
 243                                                                         - fgkCarbonFiberSupportTopEdgeDist[0]
 244                                                                         - fgkCarbonFiberSupportWidth;
 245 /////////////////////////////////////////////////////////////////////////////////
 246 // Carbon Fiber Lower Support Parameters (lengths are in mm)
 247 /////////////////////////////////////////////////////////////////////////////////
 248 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
 249                                                                                                                                           =  0.950*fgkmm;
 250 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
 251                                                                                                                                           =  1.600*fgkmm;
 252 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
 253                                                                                                                                           =  0.830*fgkmm;
 254 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
 255                                                                                           = 0.5*fgkCarbonFiberSupportWidth;
 256 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
 257                                                                         = fgkCarbonFiberJunctionWidth
 258                                                                         - 2. * (fgkCarbonFiberLowerSupportWidth
 259                                                                         + fgkCarbonFiberLowerSupportVolumeSeparation);
 260 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
 261                                                                         = {fgkCarbonFiberLowerSupportWidth
 262                                                                         +  fgkCarbonFiberLowerSupportVolumeSeparation,
 263                                                                            fgkCarbonFiberLowerSupportWidth
 264                                                                         +  fgkCarbonFiberLowerSupportVolumeSeparation
 265                                                                         +  fgkCarbonFiberLowerSupportTransverseWidth};
 266 /////////////////////////////////////////////////////////////////////////////////
 267 // End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
 268 /////////////////////////////////////////////////////////////////////////////////
 269 const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
 270                                                            {0.5 * (fgkSSDLay5LadderLength
 271                                                                         -  fgkSSDLay5SensorsNumber
 272                                                                         *  fgkCarbonFiberJunctionWidth
 273                                                                         -  fgkCarbonFiberLowerSupportWidth),
 274                                                                 0.5 * (fgkSSDLay5LadderLength
 275                                                                         -  fgkSSDLay5SensorsNumber
 276                                                                         *  fgkCarbonFiberJunctionWidth
 277                                                                         +  fgkCarbonFiberLowerSupportWidth)};
 278 const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
 279                                                 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
 280                                                  fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
 281 const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
 282                                                 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
 283                                                  fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
 284 const Double_t AliITSv11GeometrySSD::fgkendladdercoolingsupportdistance[3] =
 285                                                                                         {15.0*fgkmm, 13.5*fgkmm, 14.5*fgkmm};
 286 /////////////////////////////////////////////////////////////////////////////////
 287 // Cooling Tube Support (lengths are in mm and angles in degrees)
 288 /////////////////////////////////////////////////////////////////////////////////
 289 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax      =  1.45*fgkmm;
 290 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
 291                                                                                           = fgkSSDCoolingBlockHoleRadius[0];
 292 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength    =  8.55*fgkmm;
 293 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight    =  0.85*fgkmm;
 294 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth     =  2.00*fgkmm;
 295 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation    =
 296                                         fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
 297 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber =
 298                                                                                                                                           11.70*fgkmm;
 299 /////////////////////////////////////////////////////////////////////////////////
 300 // Cooling Tube (lengths are in mm and angles in degrees)
 301 /////////////////////////////////////////////////////////////////////////////////
 302 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
 303 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin =  0.96*fgkmm;
 304 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
 305                                                                                                         fgkCarbonFiberJunctionWidth;
 306 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
 307                                                                          fgkSSDModuleSensorSupportDistance
 308                                                                   +      fgkSSDCoolingBlockLength;
 309 const Double_t AliITSv11GeometrySSD::fgkMountingBlockToSensorSupport = 30.7*fgkmm;
 310 /////////////////////////////////////////////////////////////////////////////////
 311 // SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
 312 /////////////////////////////////////////////////////////////////////////////////
 313 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3]            =
 314                                                                                    { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
 315 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4]            =
 316                                                            {  4.0*fgkmm,  8.0*fgkmm,  5.0*fgkmm,  0.2*fgkmm};
 317 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth                =
 318                                                                                                                                           20.0*fgkmm;
 319 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle   =
 320                                                                                                                                                     40.0;
 321 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight  =
 322                    0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
 323 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
 324                                                                                                                                           2.5*fgkmm;
 325 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2]    =
 326                                                                                                           { 56.0*fgkmm, 12.0*fgkmm};
 327 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2]     =
 328                                                                                                       {  5.0*fgkmm,  2.9*fgkmm};
 329 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius           =
 330                                                                                                                                           1.0*fgkmm;
 331 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge        =
 332                                                                                                                                           6.0*fgkmm;
 333 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth      =
 334                                                                                                                                           4.0*fgkmm;
 335 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2]   =
 336                                                           {  1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
 337 /////////////////////////////////////////////////////////////////////////////////
 338 // SSD Mounting Block Clip Parameters (lengths are in mm and angles in degrees)
 339 /////////////////////////////////////////////////////////////////////////////////
 340 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipLength        = 15.1*fgkmm;
 341 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipThickness     = 0.3*fgkmm;
 342 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewRadius   = 1.6*fgkmm;
 343 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewPosition = 4.0*fgkmm;
 344 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibWidth         = 9.0*fgkmm;
 345 /////////////////////////////////////////////////////////////////////////////////
 346 // SSD Mounting Block Support Parameters (lengths are in mm and angles in degrees)
 347 /////////////////////////////////////////////////////////////////////////////////
 348 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportWidth[2] = {9.5*fgkmm,10.0*fgkmm};
 349 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportDownHeight   = 4.0*fgkmm;
 350 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDLay5RadiusMin
 351                                                                                                   -  fgkSSDMountingBlockHeight[1]
 352                                                                                                   +  0.5*fgkCoolingTubeSupportHeight
 353                                                                                                   +      fgkSSDModuleCoolingBlockToSensor
 354                                                                                                   -      fgkMountingBlockSupportDownHeight,
 355                                                                                                          fgkSSDLay6RadiusMin
 356                                                                                                   -  fgkSSDMountingBlockHeight[1]
 357                                                                                                   +  0.5*fgkCoolingTubeSupportHeight
 358                                                                                                   +      fgkSSDModuleCoolingBlockToSensor
 359                                                                                                   -      fgkMountingBlockSupportDownHeight};
 360 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax
 361                                                                                                     -  fgkSSDMountingBlockHeight[1]
 362                                                                                                     +  0.5*fgkCoolingTubeSupportHeight
 363                                                                                                     +  fgkSSDModuleCoolingBlockToSensor
 364                                                                                                         -  fgkMountingBlockSupportRadius[0],
 365                                                                                                            fgkSSDLay6RadiusMax
 366                                                                                                     -  fgkSSDMountingBlockHeight[1]
 367                                                                                                     +  0.5*fgkCoolingTubeSupportHeight
 368                                                                                                     +  fgkSSDModuleCoolingBlockToSensor
 369                                                                                                         -  fgkMountingBlockSupportRadius[1]};
 370 const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeigth = 10.0*fgkmm; // To be verified
 371 const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
 372 const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
 373 /////////////////////////////////////////////////////////////////////////////////
 374 // SSD End Cap Cover Plate Parameters (lengths are in mm and angles in degrees)
 375 /////////////////////////////////////////////////////////////////////////////////
 376 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleRadius = 1.25*fgkmm;
 377 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateBigHoleRadius = 2.45*fgkmm;
 378 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateThickness = 0.5*fgkmm;
 379 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleSeparation[3] =
 380                                                                                                 {16.5*fgkmm,22.0*fgkmm,7.*fgkmm};
 381 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateLength[6] =
 382                                   {7.*fgkmm,55.*fgkmm,8.0*fgkmm,53.*fgkmm,61.0*fgkmm,25.5*fgkmm};
 383 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateWidth[3] =
 384                                                                                            {68.5*fgkmm,75.5*fgkmm,6.5*fgkmm};
 385 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMin = 0.750*fgkmm;
 386 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMax = 2.*fgkmm;
 387 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipLength = 10.4*fgkmm;
 388 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipWidth = 6.0*fgkmm;
 389 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipLength = 5.7*fgkmm;
 390 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipWidth = 5.0*fgkmm;
 391 /////////////////////////////////////////////////////////////////////////////////
 392 // SSD End Cap Kapton Foil Parameters (lengths are in mm and angles in degrees)
 393 /////////////////////////////////////////////////////////////////////////////////
 394 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilThickness = 0.4*fgkmm;
 395 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilLength = 68.0*fgkmm;
 396 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilWidth = 75.0*fgkmm;
 397 /////////////////////////////////////////////////////////////////////////////////
 398 // SSD End Cap Cooling Tube Parameters (lengths are in mm and angles in degrees)
 399 /////////////////////////////////////////////////////////////////////////////////
 400 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAxialRadius[2] =
 401                                                                                                                 {10.5*fgkmm,9.25*fgkmm};
 402 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMin = 1.3*fgkmm;
 403 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMax = 1.5*fgkmm;
 404 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAngle[5] =
 405                                                                                                         {182.3,177.9,84.4,70.0,35.0};
 406 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeLength[5] =
 407                                                                         {49.5*fgkmm,41.7*fgkmm,47.6*fgkmm,5.0*fgkmm};
 408 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeToCoverSide = 13.0*fgkmm;
 409 /////////////////////////////////////////////////////////////////////////////////
 410 // SSD End Cap Cover Side Parameters (lengths are in mm and angles in degrees)
 411 /////////////////////////////////////////////////////////////////////////////////
 412 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverLength[5] = {3.5*fgkmm,
 413                                                                           6.5*fgkmm,75.0*fgkmm,8.0*fgkmm,2.0*fgkmm};
 414 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverWidth[7] = {30.9*fgkmm,
 415                                                                           47.5*fgkmm,12.6*fgkmm,5.6*fgkmm,
 416                                                                           20.0*fgkmm,7.0*fgkmm,5.9*fgkmm};
 417 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm;
 418 /////////////////////////////////////////////////////////////////////////////////
 419 // SSD End Cap Cards Parameters (lengths are in mm and angles in degrees)
 420 /////////////////////////////////////////////////////////////////////////////////
 421 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] =
 422                                                                                                            {62.0*fgkmm,21.87*fgkmm};
 423 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] =
 424                                                                                                             {47.1*fgkmm,0.35*fgkmm};
 425 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness =
 426                                                                                                                                           1.0*fgkmm;
 427 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm;
 428 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerWidth[2] =
 429                                                                                                            {43.5*fgkmm, 0.70*fgkmm};
 430 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerThickness =
 431                                                                                                                                          0.15*fgkmm;
 432 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorThickness =
 433                                                                                                                                          19.0*fgkmm;
 434 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorLength[2] =
 435                                                                                                                  {4.80*fgkmm,1.1*fgkmm};
 436 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorWidth[2] =
 437                                                                                                                  {3.3*fgkmm,1.10*fgkmm};
 438 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorToLayer =
 439                                                                                                                                           2.1*fgkmm;
 440 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorLength[3] =
 441                                                                                                 {5.2*fgkmm,3.5*fgkmm,1.2*fgkmm};
 442 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorWidth[2] =
 443                                                                                                                  {1.9*fgkmm,0.15*fgkmm};
 444 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorThickness =
 445                                                                                                                                            19*fgkmm;
 446 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorDistance =
 447                                                                                                                                           1.0*fgkmm;
 448 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorToLayer =
 449                                                                                                                                           3.6*fgkmm;
 450 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionLength =
 451                                                                                                                                          61.0*fgkmm;
 452 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionThickness =
 453                                                                                                                                          5.97*fgkmm;
 454 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionWidth = 3.0*fgkmm;
 455 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBLength[7] =
 456                                                                                                 {3.1*fgkmm,68.0*fgkmm,3.6*fgkmm,
 457                                                                           1.9*fgkmm,2.5*fgkmm,14.2*fgkmm,1.5*fgkmm};
 458 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBWidth[5] =
 459                                                   {17.0*fgkmm,10.0*fgkmm,5.9*fgkmm,6.4*fgkmm,3.9*fgkmm};
 460 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBThickness =
 461                                                                                                                                           1.0*fgkmm;
 462 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceElectBoardCardBThickness
 463                                                                                                                                    = 0.15*fgkmm;
 464 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBJMDConnectorSeparation =
 465                                                                                                                                          20.0*fgkmm;
 466 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerLength = 68.0*fgkmm;
 467 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerWidth = 5.0*fgkmm;
 468 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerThickness = 5.0*fgkmm;
 469 const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMin = 1.25*fgkmm; // To Be Checked
 470 const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMax = 1.575*fgkmm; // To Be Checked
 471 /////////////////////////////////////////////////////////////////////////////////
 472 // SSD End Cap SupportLayer5/6 Side Parameters (lengths are in mm and angles in degrees)
 473 /////////////////////////////////////////////////////////////////////////////////
 474 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLength[2] = {70.424*fgkmm,72.919*fgkmm};
 475 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fgkmm,437.0*fgkmm};
 476 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {365.0*fgkmm,430.0*fgkmm};
 477 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm;
 478 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm};
 479 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 625.0*fgkmm;
 480 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
 481 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
 482 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
 483 /////////////////////////////////////////////////////////////////////////////////
 484 ClassImp(AliITSv11GeometrySSD)
 485 /////////////////////////////////////////////////////////////////////////////////
 486 AliITSv11GeometrySSD::AliITSv11GeometrySSD():
 487   AliITSv11Geometry(),
 488   fSSDChipMedium(),
 489   fSSDChipGlueMedium(),
 490   fSSDStiffenerMedium(),
 491   fSSDStiffenerConnectorMedium(),
 492   fSSDStiffener0603CapacitorMedium(),
 493   fSSDStiffener1812CapacitorMedium(),
 494   fSSDStiffenerHybridWireMedium(),
 495   fSSDKaptonFlexMedium(),
 496   fSSDAlTraceFlexMedium(),
 497   fSSDAlTraceLadderCableMedium(),
 498   fSSDKaptonLadderCableMedium(),
 499   fSSDKaptonChipCableMedium(),
 500   fSSDAlTraceChipCableMedium(),
 501   fSSDAlCoolBlockMedium(),
 502   fSSDSensorMedium(),
 503   fSSDSensorSupportMedium(),
 504   fSSDCarbonFiberMedium(),
 505   fSSDTubeHolderMedium(),
 506   fSSDCoolingTubeWater(),
 507   fSSDCoolingTubePhynox(),
 508   fSSDSupportRingAl(),
 509   fSSDMountingBlockMedium(),
 510   fSSDAir(),
 511   fCreateMaterials(kFALSE),
 512   fTransformationMatrices(kFALSE),
 513   fBasicObjects(kFALSE),
 514   fcarbonfiberjunction(),
 515   fcoolingtubesupport(),
 516   fhybridmatrix(),
 517   fssdcoolingblocksystem(),
 518   fcoolingblocksystematrix(),
 519   fssdstiffenerflex(),
 520   fssdendflex(),
 521   fendladdercoolingtubesupportmatrix(),
 522   fendladdermountingblock(),
 523   fendladdermountingblockclip(),
 524   fSSDSensor5(),
 525   fSSDSensor6(),
 526   fSSDLayer5(),
 527   fSSDLayer6(),
 528   fMotherVol(),
 529   fLay5LadderSupportRing(),
 530   fLay6LadderSupportRing(),
 531   fColorCarbonFiber(4),
 532   fColorRyton(5),
 533   fColorPhynox(14),
 534   fColorSilicon(3),
 535   fColorAl(38),
 536   fColorKapton(6),
 537   fColorPolyhamide(5),
 538   fColorStiffener(9),
 539   fColorEpoxy(30),
 540   fColorWater(7),
 541   fColorG10(41)
 542 {
 543   ////////////////////////
 544   // Standard constructor
 545   ////////////////////////
 546 }
 547 /////////////////////////////////////////////////////////////////////////////////
 548 AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
 549   AliITSv11Geometry(s.GetDebug()),
 550   fSSDChipMedium(s.fSSDChipMedium),
 551   fSSDChipGlueMedium(s.fSSDChipGlueMedium),
 552   fSSDStiffenerMedium(s.fSSDStiffenerMedium),
 553   fSSDStiffenerConnectorMedium(s.fSSDStiffenerConnectorMedium),
 554   fSSDStiffener0603CapacitorMedium(s.fSSDStiffener0603CapacitorMedium),
 555   fSSDStiffener1812CapacitorMedium(s.fSSDStiffener1812CapacitorMedium),
 556   fSSDStiffenerHybridWireMedium(s.fSSDStiffenerHybridWireMedium),
 557   fSSDKaptonFlexMedium(s.fSSDKaptonFlexMedium),
 558   fSSDAlTraceFlexMedium(s.fSSDAlTraceFlexMedium),
 559   fSSDAlTraceLadderCableMedium(s.fSSDAlTraceLadderCableMedium),
 560   fSSDKaptonLadderCableMedium(s.fSSDKaptonLadderCableMedium),
 561   fSSDKaptonChipCableMedium(s.fSSDKaptonChipCableMedium),
 562   fSSDAlTraceChipCableMedium(s.fSSDAlTraceChipCableMedium),
 563   fSSDAlCoolBlockMedium(s.fSSDAlCoolBlockMedium),
 564   fSSDSensorMedium(s.fSSDSensorMedium),
 565   fSSDSensorSupportMedium(s.fSSDSensorSupportMedium),
 566   fSSDCarbonFiberMedium(s.fSSDCarbonFiberMedium),
 567   fSSDTubeHolderMedium(s.fSSDTubeHolderMedium),
 568   fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
 569   fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
 570   fSSDSupportRingAl(s.fSSDSupportRingAl),
 571   fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
 572   fSSDAir(s.fSSDAir),
 573   fCreateMaterials(s.fCreateMaterials),
 574   fTransformationMatrices(s.fTransformationMatrices),
 575   fBasicObjects(s.fBasicObjects),
 576   fcarbonfiberjunction(s.fcarbonfiberjunction),
 577   fcoolingtubesupport(s.fcoolingtubesupport),
 578   fhybridmatrix(s.fhybridmatrix),
 579   fssdcoolingblocksystem(s.fssdcoolingblocksystem),
 580   fcoolingblocksystematrix(s.fcoolingblocksystematrix),
 581   fssdstiffenerflex(s.fssdstiffenerflex),
 582   fssdendflex(s.fssdendflex),
 583   fendladdercoolingtubesupportmatrix(s.fendladdercoolingtubesupportmatrix),
 584   fendladdermountingblock(s.fendladdermountingblock),
 585   fendladdermountingblockclip(s.fendladdermountingblockclip),
 586   fSSDSensor5(s.fSSDSensor5),
 587   fSSDSensor6(s.fSSDSensor6),
 588   fSSDLayer5(s.fSSDLayer5),
 589   fSSDLayer6(s.fSSDLayer6),
 590   fMotherVol(s.fMotherVol),
 591   fLay5LadderSupportRing(s.fLay5LadderSupportRing),
 592   fLay6LadderSupportRing(s.fLay6LadderSupportRing),
 593   fColorCarbonFiber(s.fColorCarbonFiber),
 594   fColorRyton(s.fColorRyton),
 595   fColorPhynox(s.fColorPhynox),
 596   fColorSilicon(s.fColorSilicon),
 597   fColorAl(s.fColorAl),
 598   fColorKapton(s.fColorKapton),
 599   fColorPolyhamide(s.fColorPolyhamide),
 600   fColorStiffener(s.fColorStiffener),
 601   fColorEpoxy(s.fColorEpoxy),
 602   fColorWater(s.fColorWater),
 603   fColorG10(s.fColorG10)
 604 {
 605   ////////////////////////
 606   // Copy Constructor
 607   ////////////////////////
 608 }
 609 /////////////////////////////////////////////////////////////////////////////////
 610 AliITSv11GeometrySSD& AliITSv11GeometrySSD::
 611 operator=(const AliITSv11GeometrySSD &s){
 612   ////////////////////////
 613   // Assignment operator
 614   ////////////////////////
 615   this->~AliITSv11GeometrySSD();
 616   new(this) AliITSv11GeometrySSD(s);
 617   return *this;
 618 /*
 619   if(&s == this) return *this;
 620   fMotherVol = s.fMotherVol;
 621   return *this;
 622  */
 623 }
 624 ///////////////////////////////////////////////////////////////////////////////
 625 void AliITSv11GeometrySSD::CreateTransformationMatrices(){
 626   ///////////////////////////////////////////////////////////////////////
 627   // Method generating the trasformation matrix for the whole SSD Geometry
 628   ///////////////////////////////////////////////////////////////////////
 629   // Setting some variables for Carbon Fiber Supportmatrix creation
 630   //////////////////////////////////////////////////////////////////////
 631   Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
 632                                                                                    * CosD(fgkCarbonFiberJunctionAngle[0]);
 633   Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
 634                                                                  +      fgkCarbonFiberSupportTopEdgeDist[0]
 635                                                                  +      fgkCarbonFiberSupportWidth);
 636   Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
 637                                                                         * TanD(fgkCarbonFiberJunctionAngle[0]);
 638   TGeoRotation* carbonfiberot[3];
 639   for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
 640   carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
 641   carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
 642   carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
 643   Double_t transvector[3] = {fgkCarbonFiberTriangleLength
 644                                                   *  CosD(fgkCarbonFiberTriangleAngle),0.,
 645                                                   -  fgkCarbonFiberTriangleLength
 646                                                   *      SinD(fgkCarbonFiberTriangleAngle)};
 647   ///////////////////////////////////////////
 648   //Setting Local Translations and Rotations:
 649   ///////////////////////////////////////////
 650   TGeoCombiTrans* localcarbonfibersupportmatrix[3];
 651   localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
 652                                                                          0.5*carbonfibersupportheight,NULL);
 653   localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
 654                                                                          2.*symmetryplaneposition+transvector[1],
 655                                                                          transvector[2], carbonfiberot[2]);
 656   localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
 657   /////////////////////////////////////////////////////////////
 658   // Carbon Fiber Support Transformations
 659   /////////////////////////////////////////////////////////////
 660   const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
 661   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
 662                 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
 663                 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
 664                         fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
 665   }
 666   /////////////////////////////////////////////////////////////
 667   // Carbon Fiber Junction Transformation
 668   /////////////////////////////////////////////////////////////
 669   const Int_t kcarbonfiberjunctionmatrixnumber = 2;
 670   TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
 671   TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
 672   TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
 673   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
 674         localcarbonfiberjunctionmatrix[i] =
 675                                                 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
 676         localcarbonfiberjunctionrot[i] =
 677                                                 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
 678         localcarbonfiberjunctiontrans[i] =
 679                                                 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
 680   }
 681   ///////////////////////
 682   // Setting Translations
 683   ///////////////////////
 684   localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
 685   localcarbonfiberjunctiontrans[1][0] =
 686                                  new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
 687   localcarbonfiberjunctiontrans[2][0] =
 688                                  new TGeoTranslation(fgkCarbonFiberTriangleLength
 689                                  * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
 690                                  fgkCarbonFiberTriangleLength
 691                                  * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
 692   localcarbonfiberjunctiontrans[0][1] =
 693                                  new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
 694   localcarbonfiberjunctiontrans[1][1] =
 695                                  new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
 696   localcarbonfiberjunctiontrans[2][1] =
 697                                  new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
 698   ////////////////////
 699   // Setting Rotations
 700   ////////////////////
 701   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
 702                 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
 703                         localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
 704   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
 705         localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
 706   localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
 707   localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
 708   localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
 709   ////////////////////////////////////////
 710   // Setting Carbon Fiber Junction matrix
 711   ////////////////////////////////////////
 712   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
 713                 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
 714                 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
 715                         localcarbonfiberjunctionmatrix[i][j] =
 716                         new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
 717                                                            *localcarbonfiberjunctionrot[i][j]);
 718                     fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
 719          }
 720   }
 721   /////////////////////////////////////////////////////////////
 722   // Carbon Fiber Lower Support Transformations
 723   /////////////////////////////////////////////////////////////
 724   TGeoTranslation* localcarbonfiberlowersupportrans[2];
 725   localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
 726                                                                          fgkCarbonFiberLowerSupportVolumePosition[1]
 727                                                                 +    fgkCarbonFiberLowerSupportVolumePosition[0],
 728                                                                          0.0);
 729   localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
 730                                                                          fgkCarbonFiberJunctionWidth
 731                                                                 -    fgkCarbonFiberLowerSupportWidth
 732                                                                 -    fgkCarbonFiberLowerSupportVolumePosition[0]
 733                                                                 -    fgkCarbonFiberLowerSupportVolumePosition[1],
 734                                                                 -    0.5*fgkCarbonFiberLowerSupportHeight);
 735    localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
 736    fcarbonfiberlowersupportrans[0] =
 737                                                 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
 738    fcarbonfiberlowersupportrans[1] =
 739                                                 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
 740   /////////////////////////////////////////////////////////////
 741   // SSD Sensor Support Transformations
 742   /////////////////////////////////////////////////////////////
 743   const Int_t kssdsensorsupportmatrixnumber = 3;
 744   TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
 745   TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
 746   TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
 747   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 748         localssdsensorsupportmatrix[i] =
 749                                                 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
 750         localssdsensorsupportrot[i] =
 751                                                 new TGeoRotation*[kssdsensorsupportmatrixnumber];
 752         localssdsensorsupportrans[i] =
 753                                                 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
 754   }
 755   ///////////////////////
 756   // Setting Translations
 757   ///////////////////////
 758   localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
 759                                                                           0.5*fgkSSDSensorSideSupportWidth,
 760                                                                           0.0);
 761   localssdsensorsupportrans[1][0] =
 762                                                  new TGeoTranslation(*localssdsensorsupportrans[0][0]);
 763   localssdsensorsupportrans[2][0] =
 764                                                  new TGeoTranslation(*localssdsensorsupportrans[0][0]);
 765   localssdsensorsupportrans[0][1] =
 766                                                  new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
 767                                                                                 0.5*fgkSSDSensorSideSupportThickness[0],
 768                                                                                 0.0);
 769   localssdsensorsupportrans[1][1] =
 770                                                  new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
 771                                                                         -   0.5*fgkSSDSensorSideSupportThickness[0]
 772                                                                     -   fgkSSDModuleSensorSupportDistance,
 773                                                                                 0.0);
 774   localssdsensorsupportrans[2][1] =
 775                                                  new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
 776                                                                         -    fgkSSDSensorCenterSupportPosition,
 777                                                                                  0.5*fgkSSDSensorCenterSupportWidth
 778                                                                         -    0.5*fgkSSDModuleSensorSupportDistance,
 779                                                                                  fgkSSDSensorCenterSupportThickness[0]);
 780   localssdsensorsupportrans[0][2] =
 781                                                  new TGeoTranslation(fgkCarbonFiberTriangleLength
 782                                                                         +    fgkCarbonFiberJunctionToSensorSupport,
 783                                                                                  fgkCarbonFiberJunctionWidth
 784                                                                     -    0.5*(fgkCarbonFiberLowerSupportWidth
 785                                                                         +    fgkSSDSensorCenterSupportLength
 786                                                                         -    fgkSSDSensorCenterSupportThickness[0])
 787                                                                         -    fgkSSDSensorCenterSupportPosition,
 788                                                                              0.0);
 789   localssdsensorsupportrans[1][2] =
 790                                                 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
 791   localssdsensorsupportrans[2][2] =
 792                                                 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
 793   ////////////////////
 794   // Setting Rotations
 795   ////////////////////
 796   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
 797                 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
 798                         localssdsensorsupportrot[i][j] = new TGeoRotation();
 799   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 800         localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
 801         localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
 802   }
 803   localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
 804   localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
 805   localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
 806   ////////////////////////////////////////
 807   // SSD Sensor Support matrix
 808   ////////////////////////////////////////
 809   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 810                 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
 811                 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
 812                         localssdsensorsupportmatrix[i][j] =
 813                         new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
 814                                                            *localssdsensorsupportrot[i][j]);
 815                     fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
 816          }
 817   }
 818   /////////////////////////////////////////////////////////////
 819   // SSD Cooling Tube Support Transformations
 820   /////////////////////////////////////////////////////////////
 821   const Int_t kcoolingtubesupportmatrixnumber = 2;
 822   TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
 823   TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
 824   TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
 825   Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
 826                                                                                                         /fgkCoolingTubeSupportRmax);
 827   localcoolingtubesupportrans[0] =
 828                         new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
 829                                                 +  2.*(fgkCoolingTubeSupportLength
 830                                                 -  fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
 831                                                 +  fgkCarbonFiberTriangleLength
 832                                                 -  2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
 833   localcoolingtubesupportrans[1] =
 834                         new TGeoTranslation(fgkCarbonFiberJunctionLength
 835                                         - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
 836                                         - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 837                                                    fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 838                     +  0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 839                     -  0.5*(fgkCarbonFiberLowerSupportWidth
 840                                         +          fgkSSDSensorCenterSupportLength
 841                     -      fgkSSDSensorCenterSupportThickness[0])
 842                                         +  0.5*fgkSSDSensorLength,
 843                                         -  0.5*fgkCoolingTubeSupportHeight);
 844   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
 845   localcoolingtubesupportrot[i] = new TGeoRotation();
 846   localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
 847   localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
 848   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
 849         localcoolingtubesupportmatrix[i] =
 850                 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
 851                                                    *localcoolingtubesupportrot[i]);
 852   fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
 853   fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
 854                                                                 (*localcoolingtubesupportmatrix[0]));
 855   /////////////////////////////////////////////////////////////
 856   // End Ladder SSD Cooling Tube Support Transformations
 857   /////////////////////////////////////////////////////////////
 858   TGeoTranslation** localendladdercooltubetrans[2];
 859   localendladdercooltubetrans[0] = new TGeoTranslation*[4];
 860   localendladdercooltubetrans[1] = new TGeoTranslation*[2];
 861   for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
 862   localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
 863                                                                                         -          (fgkCoolingTubeSupportLength
 864                                                                                         -               fgkCoolingTubeSupportRmax),
 865                                                                                                         fgkEndLadderMountingBlockPosition[0]
 866                                                                                         -               fgkendladdercoolingsupportdistance[0]
 867                                                                                         +   0.5*fgkCoolingTubeSupportWidth,
 868                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 869   localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
 870                                                                                         -          (fgkCoolingTubeSupportLength
 871                                                                                         -               fgkCoolingTubeSupportRmax),
 872                                                                                                         fgkEndLadderMountingBlockPosition[0]
 873                                                                                         +               fgkendladdercoolingsupportdistance[1]
 874                                                                                         +   0.5*fgkCoolingTubeSupportWidth,
 875                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 876   localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
 877                                                                                         -       fgkCoolingTubeSupportRmax)
 878                                                                                         +               fgkCarbonFiberTriangleLength
 879                                                                                         -   2.0*fgkCarbonFiberJunctionLength,
 880                                                                                                 0.0,
 881                                                                                                 0.0);
 882   localendladdercooltubetrans[0][3]->SetTranslation(0.0,
 883                                                                                                         fgkendladdercoolingsupportdistance[0]
 884                                                                                         +               fgkendladdercoolingsupportdistance[1],
 885                                                                                                         0.0);
 886   for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
 887   localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
 888                                                                                         +               fgkCarbonFiberJunctionLength
 889                                                                                         -               fgkCoolingTubeSupportLength,
 890                                                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[1]
 891                                                                                         -       0.5*fgkCoolingTubeSupportWidth
 892                                                                                                    -fgkendladdercoolingsupportdistance[2],
 893                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 894   localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
 895                                                                                         +               fgkCoolingTubeSupportLength
 896                                                                                         -               fgkCoolingTubeSupportRmax
 897                                                                                         -               fgkCarbonFiberJunctionLength,
 898                                                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[1]
 899                                                                                         -       0.5*fgkCoolingTubeSupportWidth
 900                                                                                         -               fgkendladdercoolingsupportdistance[2],
 901                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 902   fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
 903   fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
 904   fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
 905   fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
 906   (*localcoolingtubesupportrot[1]));
 907   fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
 908   (*localcoolingtubesupportrot[1]));
 909   fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
 910   fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
 911   fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
 912   fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
 913   fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
 914
 915   fendladdercoolingtubesupportmatrix[1][0] =
 916                                                         new TGeoHMatrix((*localendladdercooltubetrans[1][0])
 917                                                                                    *(*localcoolingtubesupportrot[1]));
 918   fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
 919   fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
 920   fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
 921   /////////////////////////////////////////////////////////////
 922   // SSD Cooling Tube Transformations
 923   /////////////////////////////////////////////////////////////
 924   TGeoRotation* localcoolingtuberot = new TGeoRotation();
 925   localcoolingtuberot->SetAngles(0.,90.,0.);
 926   TGeoTranslation** localcoolingtubetrans[4];
 927   TVector3** localcoolingtubevect[4];
 928   for(Int_t i=0; i<4; i++){
 929         localcoolingtubevect[i] = new TVector3*[2];
 930         localcoolingtubetrans[i] = new TGeoTranslation*[2];
 931         fcoolingtubematrix[i] = new TGeoHMatrix*[2];
 932   }
 933   localcoolingtubevect[0][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
 934                                                   -fgkCarbonFiberTriangleLength),
 935                                                   - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 936                                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 937                                                   +      0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 938                                                   -      0.5*(fgkCarbonFiberLowerSupportWidth
 939                                                   +      fgkSSDSensorCenterSupportLength
 940                                                   -      fgkSSDSensorCenterSupportThickness[0])+
 941                                                          0.5*fgkSSDSensorLength-0.25*(fgkSSDSensorLength
 942                                                   -  2.0*fgkSSDModuleStiffenerPosition[1]
 943                                                   -      2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
 944                                                   -  0.5*fgkCoolingTubeSupportWidth,
 945                                                   -  0.5*fgkCoolingTubeSupportHeight);
 946   localcoolingtubevect[0][1] = new TVector3(localcoolingtubevect[0][0]->X(),
 947                                                         localcoolingtubevect[0][0]->Y()+0.5*(fgkSSDSensorLength
 948                                                   -  2.0*fgkSSDModuleStiffenerPosition[1]
 949                                                   -      2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
 950                                                   +  fgkCoolingTubeSupportWidth,
 951                                                   localcoolingtubevect[0][0]->Z());
 952   localcoolingtubevect[1][0] = new TVector3(-localcoolingtubevect[0][0]->X()
 953                                                          +                               fgkCarbonFiberTriangleLength,
 954                                                                                          localcoolingtubevect[0][0]->Y(),
 955                                                                                          localcoolingtubevect[0][0]->Z());
 956   localcoolingtubevect[1][1] = new TVector3(-localcoolingtubevect[0][1]->X()
 957                                                          +                               fgkCarbonFiberTriangleLength,
 958                                                                                          localcoolingtubevect[0][1]->Y(),
 959                                                                                          localcoolingtubevect[0][1]->Z());
 960   localcoolingtubevect[2][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
 961                                                   -     fgkCarbonFiberTriangleLength),
 962                                                   - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 963                                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 964                                                   +      0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 965                                                   -      0.5*(fgkCarbonFiberLowerSupportWidth
 966                                                   +      fgkSSDSensorCenterSupportLength
 967                                                   -      fgkSSDSensorCenterSupportThickness[0])
 968                                                   +  fgkSSDModuleStiffenerPosition[1]
 969                                                   -  0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDSensorOverlap),
 970                                                   -  0.5*fgkCoolingTubeSupportHeight);
 971   localcoolingtubevect[2][1] = new TVector3(-localcoolingtubevect[2][0]->X()
 972                                                          +                               fgkCarbonFiberTriangleLength,
 973                                                                                          localcoolingtubevect[2][0]->Y(),
 974                                                                                          localcoolingtubevect[2][0]->Z());
 975   localcoolingtubevect[3][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
 976                                                   -     fgkCarbonFiberTriangleLength),
 977                                                   - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 978                                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 979                                                   +      0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 980                                                   -      0.5*(fgkCarbonFiberLowerSupportWidth
 981                                                   +      fgkSSDSensorCenterSupportLength
 982                                                   -      fgkSSDSensorCenterSupportThickness[0])
 983                                                   +      fgkSSDSensorLength
 984                                                   -      0.5*fgkSSDModuleStiffenerPosition[1],
 985                                                   -  0.5*fgkCoolingTubeSupportHeight);
 986   localcoolingtubevect[3][1] = new TVector3(-localcoolingtubevect[3][0]->X()
 987                                                   + fgkCarbonFiberTriangleLength,
 988                                                         localcoolingtubevect[3][0]->Y(),
 989                                                   - 0.5*fgkCoolingTubeSupportHeight);
 990   for(Int_t i=0; i<4; i++)
 991         for(Int_t j=0; j<2; j++){
 992                 localcoolingtubetrans[i][j] =
 993                         new TGeoTranslation(localcoolingtubevect[i][j]->X(),
 994                                                                 localcoolingtubevect[i][j]->Y(),
 995                                                                 localcoolingtubevect[i][j]->Z());
 996                 fcoolingtubematrix[i][j] = new TGeoHMatrix((*localcoolingtubetrans[i][j])
 997                                                           *                                     (*localcoolingtuberot));
 998         }
 999   /////////////////////////////////////////////////////////////
1000   // SSD End Ladder Cooling Tube Transformations
1001   /////////////////////////////////////////////////////////////
1002   TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
1003   localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
1004   TGeoTranslation** localendlladdercoolingtubetrans[2];
1005   localendlladdercoolingtubetrans[0] = new TGeoTranslation*[6];
1006   localendlladdercoolingtubetrans[1] = new TGeoTranslation*[4];
1007   for(Int_t i=0; i<2; i++)
1008         for(Int_t j=0; j<(i==0?6:4); j++)
1009                 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
1010   localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1011                                                                         -        fgkCoolingTubeSupportRmax)
1012                                                                         +        fgkCarbonFiberJunctionLength,
1013                                                                           0.5*(fgkEndLadderMountingBlockPosition[0]
1014                                                                         -    fgkendladdercoolingsupportdistance[0]),
1015                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1016   localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1017                                                                         -        fgkCoolingTubeSupportRmax)
1018                                                                         -        fgkCarbonFiberJunctionLength
1019                                                                         +    fgkCarbonFiberTriangleLength,
1020                                                                           0.5*(fgkEndLadderMountingBlockPosition[0]
1021                                                                         -    fgkendladdercoolingsupportdistance[0]),
1022                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1023   localendlladdercoolingtubetrans[0][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1024                                                                         -   fgkCoolingTubeSupportRmax)
1025                                                                         +       fgkCarbonFiberJunctionLength,
1026                                                                            fgkEndLadderMountingBlockPosition[0]
1027                                                                         -   fgkendladdercoolingsupportdistance[0]
1028                                                   +                0.5*(fgkendladdercoolingsupportdistance[0]
1029                                                   +                             fgkendladdercoolingsupportdistance[1]
1030                                                   +                             fgkCoolingTubeSupportWidth),
1031                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1032   localendlladdercoolingtubetrans[0][3]->SetTranslation((fgkCoolingTubeSupportLength
1033                                                                         -        fgkCoolingTubeSupportRmax)
1034                                                                         -        fgkCarbonFiberJunctionLength
1035                                                                         +    fgkCarbonFiberTriangleLength,
1036                                                                            fgkEndLadderMountingBlockPosition[0]
1037                                                                         -   fgkendladdercoolingsupportdistance[0]
1038                                                   +                0.5*(fgkendladdercoolingsupportdistance[0]
1039                                                   +                             fgkendladdercoolingsupportdistance[1]
1040                                                   +                             fgkCoolingTubeSupportWidth),
1041                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1042   localendlladdercoolingtubetrans[0][4]->SetTranslation(-(fgkCoolingTubeSupportLength
1043                                                                         -   fgkCoolingTubeSupportRmax)
1044                                                                         +       fgkCarbonFiberJunctionLength,
1045                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[0]
1046                                                   - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1047                                                   -                     fgkEndLadderMountingBlockPosition[0]
1048                                                   -                     fgkendladdercoolingsupportdistance[1]
1049                                                   -                     fgkCoolingTubeSupportWidth),
1050                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1051   localendlladdercoolingtubetrans[0][5]->SetTranslation((fgkCoolingTubeSupportLength
1052                                                                         -        fgkCoolingTubeSupportRmax)
1053                                                                         -        fgkCarbonFiberJunctionLength
1054                                                                         +    fgkCarbonFiberTriangleLength,
1055                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[0]
1056                                                   - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1057                                                   -                     fgkEndLadderMountingBlockPosition[0]
1058                                                   -                     fgkendladdercoolingsupportdistance[1]
1059                                                   -                     fgkCoolingTubeSupportWidth),
1060                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1061   localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1062                                                                         -   fgkCoolingTubeSupportRmax)
1063                                                                         +       fgkCarbonFiberJunctionLength,
1064                                                         - 0.50 * (fgkMountingBlockToSensorSupport
1065                                                         - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1066                                                         -                 fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1067                                                         +                 fgkSSDSensorOverlap
1068                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1069                                                         -                 fgkendladdercoolingsupportdistance[2]
1070                                                         -                 fgkEndLadderMountingBlockPosition[1]
1071                                                         -                 fgkCoolingTubeSupportWidth)
1072                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1073                                                         -                 fgkendladdercoolingsupportdistance[2]
1074                                                         -                 fgkCoolingTubeSupportWidth,
1075                                                   -             0.5*fgkCoolingTubeSupportHeight);
1076   localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1077                                                   -      fgkCoolingTubeSupportRmax)
1078                                                   -      fgkCarbonFiberJunctionLength
1079                                                   +    fgkCarbonFiberTriangleLength,
1080                                                   - 0.50 * (fgkMountingBlockToSensorSupport
1081                                                         - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1082                                                         -                 fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1083                                                         +                 fgkSSDSensorOverlap
1084                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1085                                                         -                 fgkendladdercoolingsupportdistance[2]
1086                                                         -                 fgkEndLadderMountingBlockPosition[1]
1087                                                         -                 fgkCoolingTubeSupportWidth)
1088                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1089                                                         -                 fgkendladdercoolingsupportdistance[2]
1090                                                         -                 fgkCoolingTubeSupportWidth,
1091                                                   -             0.5*fgkCoolingTubeSupportHeight);
1092   localendlladdercoolingtubetrans[1][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1093                                                                         -   fgkCoolingTubeSupportRmax)
1094                                                                         +       fgkCarbonFiberJunctionLength,
1095                                                                                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1096                                                                         - 0.5*fgkendladdercoolingsupportdistance[2],
1097                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1098   localendlladdercoolingtubetrans[1][3]->SetTranslation((fgkCoolingTubeSupportLength
1099                                                                         -        fgkCoolingTubeSupportRmax)
1100                                                                         -        fgkCarbonFiberJunctionLength
1101                                                                         +    fgkCarbonFiberTriangleLength,
1102                                                                                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1103                                                                         - 0.5*fgkendladdercoolingsupportdistance[2],
1104                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1105   fendladdercoolingtubematrix[0] = new TGeoHMatrix*[6];
1106   fendladdercoolingtubematrix[1] = new TGeoHMatrix*[4];
1107   for(Int_t i=0; i<2; i++)
1108         for(Int_t j=0; j<(i==0?6:4); j++){
1109                 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1110                 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1111         }
1112   /////////////////////////////////////////////////////////////
1113   // SSD Hybrid Components Transformations
1114   /////////////////////////////////////////////////////////////
1115   const Int_t khybridmatrixnumber = 3;
1116   TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1117   localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1118                                             0.5*fgkSSDStiffenerWidth,
1119                                             0.5*fgkSSDStiffenerHeight);
1120   localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1121                                             fgkSSDModuleStiffenerPosition[1],0.0);
1122
1123   localhybridtrans[2] = new TGeoTranslation(
1124                       -  0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1125                       -      (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1126                               fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1127                       +         0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1128                       -         0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1129                       -       fgkSSDSensorCenterSupportThickness[0]),
1130                       -      (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
1131                       -       fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight));
1132   fhybridmatrix = new TGeoHMatrix();
1133   for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1134   /////////////////////////////////////////////////////////////
1135   // SSD Cooling Block Transformations
1136   /////////////////////////////////////////////////////////////
1137   const Int_t kcoolingblockmatrixnumber = 4;
1138   TGeoTranslation* localcoolingblocktrans[kcoolingblockmatrixnumber];
1139   localcoolingblocktrans[0] = new TGeoTranslation(-2.*(fgkCoolingTubeSupportRmax
1140                             -  fgkCoolingTubeSupportRmin),0.0,
1141                                0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1142   localcoolingblocktrans[1] = new TGeoTranslation(0.5*fgkSSDStiffenerLength
1143                             -  0.5*fgkSSDModuleSensorSupportDistance-fgkSSDCoolingBlockLength,
1144                                0.0,fgkSSDStiffenerHeight);
1145   localcoolingblocktrans[2] = new TGeoTranslation(*localhybridtrans[1]);
1146   localcoolingblocktrans[3] = new TGeoTranslation(*localhybridtrans[2]);
1147   fcoolingblocksystematrix = new TGeoHMatrix();
1148   for(Int_t i=0; i<kcoolingblockmatrixnumber; i++)
1149       fcoolingblocksystematrix->MultiplyLeft(localcoolingblocktrans[i]);
1150   /////////////////////////////////////////////////////////////
1151   // SSD Stiffener Flex Transformations
1152   /////////////////////////////////////////////////////////////
1153   const Int_t klocalflexmatrixnumber = 4;
1154   TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1155   for(Int_t i=0; i<fgkflexnumber; i++)
1156       localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1157   for(Int_t i=0; i<fgkflexnumber; i++)
1158       for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1159             localflexmatrix[i][j] = new TGeoCombiTrans();
1160   Double_t ssdstiffenerseparation = fgkSSDSensorLength
1161                                                                   - 2.*fgkSSDModuleStiffenerPosition[1]
1162                                                                   -    fgkSSDStiffenerWidth;
1163   localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1164                                         +0.5*fgkSSDStiffenerLength,
1165                                          0.5*fgkSSDStiffenerWidth,
1166                                         -0.5*fgkSSDStiffenerHeight
1167                                         -0.5*fgkSSDFlexHeight[0]);
1168   localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1169                                         +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1170                                         -0.5*fgkSSDStiffenerWidth,
1171                                         -0.5*fgkSSDStiffenerHeight
1172                                         -0.5*fgkSSDFlexHeight[0]);
1173   TGeoRotation* localflexrot = new TGeoRotation();
1174   localflexrot->SetAngles(180.,0.,0.);
1175   localflexmatrix[1][0]->SetRotation(localflexrot);
1176   for(Int_t i=0; i<fgkflexnumber; i++)
1177       for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1178             localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1179   for(Int_t i=0; i<fgkflexnumber; i++){
1180       fstiffenerflexmatrix[i] = new TGeoHMatrix();
1181       for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1182             fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
1183   }
1184   /////////////////////////////////////////////////////////////
1185   // SSD End Flex Transformations
1186   /////////////////////////////////////////////////////////////
1187   TGeoRotation* localendflexrot = new TGeoRotation();
1188   localendflexrot->SetAngles(0.0,90.0,0.0);
1189   TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1190   Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1191                             /  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1192   Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1193                             * TMath::DegToRad()*ssdflexradiusmax
1194                                                                - fgkSSDFlexLength[2]-TMath::Pi()
1195                                                                * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
1196   Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1197                             + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1198                             +      fgkSSDFlexLength[2];
1199   localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1200                               0.5*fgkSSDFlexWidth[0],
1201                               2.*fgkSSDStiffenerHeight
1202                             + 0.5*fgkSSDFlexHeight[0]);
1203   localendflexmatrix->SetRotation(localendflexrot);
1204   for(Int_t i=0; i<fgkflexnumber; i++)
1205       fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1206   /////////////////////////////////////////////////////////////
1207   // End Ladder Carbon Fiber Junction
1208   /////////////////////////////////////////////////////////////
1209   TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1210   TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1211   TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1212   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1213       localendladdercarbonfiberjunctionmatrix[i]
1214             = new TGeoCombiTrans*[fgkendladdercabonfiberjunctionmatrixnumber];
1215       localendladdercarbonfiberjunctionrot[i]
1216             = new TGeoRotation*[fgkendladdercabonfiberjunctionmatrixnumber];
1217       localendladdercarbonfiberjunctiontrans[i]
1218             = new TGeoTranslation*[fgkendladdercabonfiberjunctionmatrixnumber];
1219       fendladdercarbonfiberjunctionmatrix[i]
1220             = new TGeoHMatrix*[fgkendladdercabonfiberjunctionmatrixnumber];
1221   }
1222   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1223       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1224             localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1225             localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1226       }
1227   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1228       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
1229           localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1230   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1231       localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1232                               0.0,0.0);
1233       localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1234                 *                     CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1235                 *                     SinD(fgkCarbonFiberTriangleAngle),
1236                         0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1237   -                          fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1238   }
1239   TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1240   TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1241   TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1242   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1243       localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1244       localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1245       localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1246       localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1247             0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1248       localendladdercarbonfiberjunctionglobalmatrix[i] =
1249             new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1250                                *localendladdercarbonfiberjunctionglobalrot[i]);
1251   }
1252   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1253       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1254             localendladdercarbonfiberjunctionmatrix[i][j] =
1255                   new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1256                                      *localendladdercarbonfiberjunctionrot[i][j]);
1257            fendladdercarbonfiberjunctionmatrix[i][j] =
1258             new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1259             *               (*localendladdercarbonfiberjunctionmatrix[i][j]));
1260       }
1261   /////////////////////////////////////////////////////////////
1262   // End Ladder Carbon Fiber Support
1263   /////////////////////////////////////////////////////////////
1264   TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1265   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1266       localendladdercarbonfibertrans[i] = new TGeoTranslation();
1267       localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1268             i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1269       fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1270   }
1271   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1272       for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1273             fendladdercarbonfibermatrix[i][j] =
1274             new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1275             *(*fcarbonfibersupportmatrix[j]));
1276   /////////////////////////////////////////////////////////////
1277   // End Ladder SSD Mounting Block
1278   /////////////////////////////////////////////////////////////
1279   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1280       fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1281   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1282       fendladdermountingblockcombitrans[i]->SetTranslation(-  0.25*(fgkSSDMountingBlockLength[0]
1283                                 +        fgkSSDMountingBlockLength[1])
1284                                 +  0.5*fgkCarbonFiberTriangleLength,
1285                                 fgkEndLadderMountingBlockPosition[i],
1286                                 -  fgkSSDMountingBlockHeight[1]
1287                                 +  0.5*fgkSSDMountingBlockHeight[0]);
1288   TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1289   endladdermountingblockrot->SetAngles(0.,90.,0.);
1290   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1291         fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1292   /////////////////////////////////////////////////////////////
1293   // End Ladder SSD Mounting Block Clip Matrix
1294   /////////////////////////////////////////////////////////////
1295   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1296         fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1297
1298   TGeoRotation* localendladdercliprot = new TGeoRotation();
1299   TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1300   localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1301                                                                                   -     fgkSSDMountingBlockLength[1])
1302                                                                                   + fgkSSDMountingBlockLength[0],0.,0.);
1303   localendladdercliprot->SetAngles(90.,180.,-90.);
1304   TGeoCombiTrans* localendladderclipcombitrans =
1305                         new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1306   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1307         for(Int_t j=0; j<2; j++){
1308                 fendladdermountingblockclipmatrix[i][j] =
1309                                                 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1310                 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1311         }
1312   /////////////////////////////////////////////////////////////
1313   // End Ladder Carbon Fiber Lower Support
1314   /////////////////////////////////////////////////////////////
1315   for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1316       fendladderlowersupptrans[i] =
1317             new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1318                         +  0.5*fgkSSDMountingBlockWidth),
1319                         -  0.5*fgkCarbonFiberLowerSupportHeight);
1320   fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1321                                                                          fgkCarbonFiberLowerSupportVolumePosition[1]
1322                                                                 +    fgkCarbonFiberLowerSupportVolumePosition[0],
1323                                                                          0.0);
1324   fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1325  /////////////////////////////////////////////////////////////
1326   // Matrix for positioning Ladder into mother volume
1327   /////////////////////////////////////////////////////////////
1328   TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1329   for(Int_t i=0; i<fgkladdernumber; i++)
1330         ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1331   TGeoRotation* localladdermotherrot = new TGeoRotation();
1332   localladdermotherrot->SetAngles(0.,90.,0.);
1333   TGeoTranslation* localladdermothertrans[fgkladdernumber];
1334   TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1335   for(Int_t i=0; i<fgkladdernumber; i++){
1336         localladdermothertrans[i] = new TGeoTranslation(0.,
1337                                                           - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1338                                                           + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1339                                                           + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1340                                                           * fgkCarbonFiberJunctionWidth,0.);
1341         localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1342                                                                                                                 *localladdermotherrot);
1343         ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1344         ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
1345   }
1346   /////////////////////////////////////////////////////////////
1347   // Ladder Cables Matrices
1348   /////////////////////////////////////////////////////////////
1349   Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
1350                                              + fgkSSDFlexHeight[1];
1351   Double_t ssdladdercabletransx[3];
1352   ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1353                                                   *   SinD(2.*fgkSSDFlexAngle)
1354                                                   *       CosD(2.*fgkSSDFlexAngle);
1355   ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1356                                                   -     ssdladdercabletransx[0]
1357                                                   /     SinD(2.*fgkSSDFlexAngle))
1358                                                   *     CosD(fgkSSDFlexAngle);
1359   ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1360                                                   *       TMath::DegToRad()*ssdflexradiusmax
1361                                                   -     fgkSSDFlexLength[2]-TMath::Pi()
1362                                                   *       fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1363                                                   -       fgkSSDLadderCableWidth)
1364                                                   *       CosD(2.*fgkSSDFlexAngle);
1365   Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
1366                                                   *     TanD(2.*fgkSSDFlexAngle),
1367                                                         ssdladdercabletransx[1]
1368                                                   *     TanD(fgkSSDFlexAngle),
1369                                                         ssdladdercabletransx[2]
1370                                                   *     TanD(2.*fgkSSDFlexAngle)};
1371   TGeoRotation* localladdercablerot[3];
1372   for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1373   localladdercablerot[0]->SetAngles(90.,0.,0.);
1374   localladdercablerot[1]->SetAngles(90.,60.,-90.);
1375   localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1376                                                  *                        (*localladdercablerot[0]));
1377   ////////////////////////////////////////////
1378   // LocalLadderCableCombiTransMatrix
1379   ////////////////////////////////////////////
1380   const Int_t klocalladdersidecablesnumber = 2;
1381   const Int_t klocalladdercombitransnumber = 5;
1382   TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1383   for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1384          localladdercablecombitransmatrix[i] =
1385                                                            new TGeoCombiTrans*[klocalladdercombitransnumber];
1386   ///////////////////////////////////////////
1387   // Left Side Ladder Cables Transformations
1388   ///////////////////////////////////////////
1389   localladdercablecombitransmatrix[0][0]  =
1390                                                 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1391                                                 0.,0.,NULL);
1392   localladdercablecombitransmatrix[0][1] =
1393         new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1394                                            - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1395                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1396                                            + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1397                                            - 0.5*(fgkCarbonFiberLowerSupportWidth
1398                                            + fgkSSDSensorCenterSupportLength
1399                                            - fgkSSDSensorCenterSupportThickness[0]),
1400                                            - (fgkSSDModuleCoolingBlockToSensor
1401                                            + 0.5*fgkCoolingTubeSupportHeight
1402                                            - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1403                                            - fgkSSDChipHeight),NULL);
1404   localladdercablecombitransmatrix[0][2] =
1405                                                 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1406                                                                                    fgkSSDModuleStiffenerPosition[1],0.,0);
1407   localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1408                                         0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1409                                    +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1410                                    fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1411                                          - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1412                                                                                                 new TGeoRotation("",180.,0.,0.));
1413   localladdercablecombitransmatrix[0][4] =
1414                                                 new TGeoCombiTrans(-ssdladdercabletransx[0]
1415                                                 -     ssdladdercabletransx[1]-ssdladdercabletransx[2]
1416                                                 +     fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1417                                                           0.,
1418                                                           0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1419                                                 +         fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
1420                                                 +     ssdladdercabletransz[0]-ssdladdercabletransz[1]
1421                                                 +         ssdladdercabletransz[2],localladdercablerot[2]);
1422   ///////////////////////////////////////////
1423   // Rigth Side Ladder Cables Transformations
1424   ///////////////////////////////////////////
1425   TGeoCombiTrans* localladdercablessdmodulematrix =
1426         new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1427                                                                   - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1428                                                                          fgkSSDStiffenerWidth,
1429                                                                   - 0.5*fgkSSDFlexHeight[0],NULL);
1430   for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1431    localladdercablecombitransmatrix[1][i] =
1432                         (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1433                                         new TGeoCombiTrans(*localladdercablessdmodulematrix));
1434   ///////////////////////////////////////////
1435   // Setting LadderCableHMatrix
1436   ///////////////////////////////////////////
1437   Int_t beamaxistrans[2][3];
1438   beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1439   beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1440   beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1441   beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1442   beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1443   beamaxistrans[1][2] = beamaxistrans[1][0];
1444   TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1445   TGeoRotation* laddercablerot = new TGeoRotation();
1446   TGeoTranslation* laddercabletrans = new TGeoTranslation();
1447   TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1448   Double_t* laddercabletransvector;
1449   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1450         localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1451         fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1452   }
1453   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1454         for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1455                 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1456                 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1457                         localladdercablehmatrix[i][j]->MultiplyLeft(
1458                         localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1459         }
1460                 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1461                 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1462                 laddercabletrans->SetTranslation(laddercabletransvector[0],
1463                                                                          laddercabletransvector[1]
1464                                         +                (j==0 ? beamaxistrans[i][0] : 0.)
1465                                         *                                fgkCarbonFiberJunctionWidth,
1466                                                                          laddercabletransvector[2]);
1467                 laddercablecombitrans->SetRotation(*laddercablerot);
1468                 laddercablecombitrans->SetTranslation(*laddercabletrans);
1469                 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1470         }
1471     fladdercablematrix[i][2] =
1472                                         AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1473                                         beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1474         fladdercablematrix[i][3] =
1475                                         AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1476                                         beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1477   }
1478   for(Int_t i=0; i<fgkladdercablesnumber; i++)
1479         for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1480                 fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1481   ///////////////////////////////////////////
1482   // Setting Ladder HMatrix
1483   ///////////////////////////////////////////
1484   Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1485                                                                                                 fgkSSDLay6SensorsNumber};
1486   for(Int_t i=0; i<fgkladdernumber; i++){
1487         fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1488         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1489                 fladdermatrix[i][j] = new TGeoHMatrix();
1490                 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1491                 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1492                 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1493         }
1494   }
1495   ///////////////////////////////////////////
1496   // Setting SSD Sensor Matrix
1497   ///////////////////////////////////////////
1498   TGeoCombiTrans* localssdsensorcombitrans[2];
1499   TGeoRotation* localssdsensorrot = new TGeoRotation();
1500   localssdsensorrot->SetAngles(0.,90.,0.);
1501   TGeoTranslation* localssdsensortrans[2];
1502   for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1503   localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1504                                           -             (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1505                               fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1506                       +         0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1507                       -         0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1508                       -       fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
1509                                                         0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1510                                           -             fgkSSDModuleCoolingBlockToSensor+(fgkSSDSensorSideSupportHeight[1]
1511                                           -             fgkSSDSensorSideSupportHeight[0]));
1512   localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1513                                           -        (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1514                               fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1515                       +         0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1516                       -         0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1517                       -       fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
1518                                                     0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1519                                                         -fgkSSDModuleCoolingBlockToSensor);
1520   for(Int_t i=0; i<2; i++)
1521         localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1522                                                                                                          *localssdsensorrot);
1523     for(Int_t i=0; i<fgkladdernumber; i++){
1524         fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1525         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1526                 switch(i){
1527                         case 0: //Ladder of Layer5
1528                         fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1529                                                                    * ((j%2==0 ? *localssdsensorcombitrans[0] :
1530                                                                                                 *localssdsensorcombitrans[1])));
1531                         break;
1532                         case 1: //Ladder of Layer6
1533                         fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1534                                                                    * ((j%2==0 ? *localssdsensorcombitrans[1] :
1535                                                                                                 *localssdsensorcombitrans[0])));
1536                 break;
1537                 }
1538           }
1539   }
1540   //////////////////////////
1541   // Setting SSD End Ladder
1542   //////////////////////////
1543   for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1544   for(Int_t i=0; i<2; i++){
1545         fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1546         fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1547         fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1548         fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1549         fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1550         fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1551         fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1552         fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1553    }
1554   /////////////////////////////////////////////////////
1555   // Setting the CombiTransformation to pass ITS center
1556   /////////////////////////////////////////////////////
1557   Double_t itscentertransz[fgklayernumber];
1558   itscentertransz[0] = fgkSSDLay5LadderLength
1559                                          - fgkLay5CenterITSPosition;
1560   itscentertransz[1] = fgkSSDLay6LadderLength
1561                                          - fgkLay6CenterITSPosition;
1562   Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1563                                                    + 0.5*fgkCoolingTubeSupportHeight;
1564   TGeoRotation* itscenterrot[3];
1565   for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1566   itscenterrot[0]->SetAngles(90.,180.,-90.);
1567   itscenterrot[1]->SetAngles(0.,90.,0.);
1568   itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1569   TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1570   for(Int_t i=0; i<fgklayernumber; i++)
1571         itscentercombitrans[i] = new TGeoCombiTrans(0.,
1572                                                          itssensortransy,
1573                                                          fgkEndLadderCarbonFiberLowerJunctionLength[1]
1574                                                    - itscentertransz[i],itscenterrot[2]);
1575   TGeoRotation** locallayerrot[fgklayernumber];
1576   TGeoTranslation** locallayertrans[fgklayernumber];
1577   TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1578   TGeoTranslation* localbeamaxistrans[fgklayernumber];
1579   localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1580                                          - fgkLay5CenterITSPosition);
1581   localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1582                                          - fgkLay6CenterITSPosition);
1583   const Int_t kssdlayladdernumber[fgklayernumber] =
1584                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1585   for(Int_t i=0; i<fgklayernumber; i++){
1586     locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1587     locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1588         locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1589         flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1590   }
1591   Double_t layerladderangleposition[fgklayernumber] =
1592                 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1593   Double_t layerradius = 0.;
1594   for(Int_t i=0; i<fgklayernumber; i++){
1595         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1596                 switch(i){
1597                         case 0: //Ladder of Layer5
1598                         layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1599                         break;
1600                         case 1: //Ladder of Layer6
1601                         layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1602                 break;
1603                 }
1604                 locallayerrot[i][j] = new TGeoRotation();
1605                 locallayertrans[i][j] = new TGeoTranslation();
1606                 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1607                 locallayertrans[i][j]->SetTranslation(layerradius
1608                                                           *     CosD(90.0+j*layerladderangleposition[i]),
1609                                                             layerradius
1610                                                           * SinD(90.0+j*layerladderangleposition[i]),0.);
1611                 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1612                                                                          *locallayerrot[i][j]);
1613                 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1614                 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1615                 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1616         }
1617   }
1618   /////////////////////////////////////////////////////////////
1619   // Deallocating memory
1620   /////////////////////////////////////////////////////////////
1621   for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1622         delete carbonfiberot[i];
1623         delete localcarbonfibersupportmatrix[i];
1624   }
1625   for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1626      for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1627        delete localcarbonfiberjunctionmatrix[i][j];
1628            delete localcarbonfiberjunctionrot[i][j];
1629            delete localcarbonfiberjunctiontrans[i][j];
1630            }
1631        delete [] localcarbonfiberjunctionmatrix[i];
1632        delete [] localcarbonfiberjunctionrot[i];
1633        delete [] localcarbonfiberjunctiontrans[i];
1634   }
1635   for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1636            delete localcarbonfiberlowersupportrans[i];
1637   for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1638      for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1639        delete localssdsensorsupportmatrix[i][j];
1640            delete localssdsensorsupportrot[i][j];
1641            delete localssdsensorsupportrans[i][j];
1642            }
1643        delete [] localssdsensorsupportmatrix[i];
1644        delete [] localssdsensorsupportrot[i];
1645        delete [] localssdsensorsupportrans[i];
1646   }
1647   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1648         delete localcoolingtubesupportmatrix[i];
1649         delete localcoolingtubesupportrot[i];
1650         delete localcoolingtubesupportrans[i];
1651   }
1652   for(Int_t i=0; i<4; i++){
1653         for(Int_t j=0; j<2; j++){
1654                 delete localcoolingtubevect[i][j];
1655                 delete localcoolingtubetrans[i][j];
1656         }
1657         delete [] localcoolingtubevect[i];
1658         delete [] localcoolingtubetrans[i];
1659   }
1660  delete endladdermountingblockrot;
1661  for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
1662  for(Int_t i=0; i<kcoolingblockmatrixnumber; i++) delete localcoolingblocktrans[i];
1663  for(Int_t i=0; i<fgkflexnumber; i++){
1664       for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1665             delete localflexmatrix[i][j];
1666       delete [] localflexmatrix[i];
1667  }
1668  delete localendlladdercoolingtuberot;
1669  for(Int_t i=0; i<2; i++){
1670         for(Int_t j=0; j<(i==0?6:4); j++)
1671                 delete localendlladdercoolingtubetrans[i][j];
1672         delete [] localendlladdercoolingtubetrans[i];
1673   }
1674
1675  delete localflexrot;
1676  delete localendflexrot;
1677  delete localendflexmatrix;
1678  for(Int_t i=0; i<fgkladdernumber; i++){
1679         delete localladdermothertrans[i];
1680         delete localladdermothercombitrans[i];
1681   }
1682  delete localladdermotherrot;
1683  for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1684       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1685             delete localendladdercarbonfiberjunctionmatrix[i][j];
1686             delete localendladdercarbonfiberjunctionrot[i][j];
1687             delete localendladdercarbonfiberjunctiontrans[i][j];
1688       }
1689       delete [] localendladdercarbonfiberjunctionmatrix[i];
1690       delete [] localendladdercarbonfiberjunctionrot[i];
1691       delete [] localendladdercarbonfiberjunctiontrans[i];
1692       delete localendladdercarbonfiberjunctionglobalrot[i];
1693       delete localendladdercarbonfiberjunctionglobaltrans[i];
1694       delete localendladdercarbonfiberjunctionglobalmatrix[i];
1695  }
1696   for(Int_t i=0; i<2; i++){
1697         for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1698         delete [] localendladdercooltubetrans[i];
1699   }
1700   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1701       delete localendladdercarbonfibertrans[i];
1702   for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1703   for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1704         for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1705                 delete localladdercablecombitransmatrix[i][j];
1706                 delete []localladdercablecombitransmatrix[i];
1707   }
1708   delete localendladdercliprot;
1709   delete localendladdercliptrans;
1710   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1711         for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1712                 delete localladdercablehmatrix[i][j];
1713         delete []localladdercablehmatrix[i];
1714   }
1715   delete laddercablerot;
1716   delete laddercabletrans;
1717   delete laddercablecombitrans;
1718   delete localladdercablessdmodulematrix;
1719   delete localssdsensorrot;
1720   for(Int_t i=0; i<2; i++){
1721         delete localssdsensortrans[i];
1722         delete localssdsensorcombitrans[i];
1723   }
1724   for(Int_t i=0; i<fgklayernumber; i++){
1725         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1726                 delete locallayerrot[i][j];
1727                 delete locallayertrans[i][j];
1728                 delete locallayercombitrans[i][j];
1729     }
1730         delete [] locallayerrot[i];
1731         delete [] locallayertrans[i];
1732         delete [] locallayercombitrans[i];
1733         delete localbeamaxistrans[i];
1734   }
1735   for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1736   for(Int_t i=0; i<fgkladdernumber; i++){
1737         for(Int_t j=0; j<fgkladdernumber; j++)
1738                 delete ladderglobalmatrix[i][j];
1739         delete [] ladderglobalmatrix[i];
1740   }
1741   /////////////////////////////////////////////////////////////
1742   fTransformationMatrices = kTRUE;
1743 }
1744 ///////////////////////////////////////////////////////////////////////////////
1745 void AliITSv11GeometrySSD::CreateBasicObjects(){
1746   /////////////////////////////////////////////////////////////
1747   // Method generating the Objects of SSD Geometry
1748   /////////////////////////////////////////////////////////////
1749   // SSD Sensor
1750   ///////////////////////////////////
1751   SetSSDSensor();
1752   /////////////////////////////////////////////////////////////
1753   // Carbon Fiber Support
1754   /////////////////////////////////////////////////////////////
1755   TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1756   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1757       fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
1758   /////////////////////////////////////////////////////////////
1759   // Carbon Fiber Junction
1760   /////////////////////////////////////////////////////////////
1761   fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth);
1762   /////////////////////////////////////////////////////////////
1763   // Carbon Fiber Lower Support
1764   /////////////////////////////////////////////////////////////
1765   TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1766   for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1767         fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1768   /////////////////////////////
1769   // SSD Sensor Support
1770   /////////////////////////////
1771   for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1772                                                                                 new TGeoVolume*[fgkssdsensorsupportnumber];
1773   Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
1774                                                                          fgkSSDSensorSideSupportThickness[1]};
1775   for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1776         fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1777                                                                                            fgkSSDSensorSideSupportHeight[i],
1778                                                                                            fgkSSDSensorSideSupportWidth,
1779                                                                                            sidesupporthickness);
1780         fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1781                                                                                            fgkSSDSensorCenterSupportHeight[i],
1782                                                                                            fgkSSDSensorCenterSupportWidth,
1783                                                                                            sidesupporthickness);
1784   }
1785   /////////////////////////////////////////////////////////////
1786   // SSD Cooling Tube Support
1787   /////////////////////////////////////////////////////////////
1788   Int_t edgesnumber = 16;
1789   fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1790   /////////////////////////////////////////////////////////////
1791   // SSD Hybrid
1792   /////////////////////////////////////////////////////////////
1793   TList* ssdhybridcomponentslist = GetSSDHybridParts();
1794   for(Int_t i=0; i<fgkhybridcompnumber; i++)
1795         fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1796   /////////////////////////////////////////////////////////////
1797   // SSD Cooling Block System
1798   /////////////////////////////////////////////////////////////
1799   fssdcoolingblocksystem = GetCoolingBlockSystem();
1800    /////////////////////////////////////////////////////////////
1801   // SSD Cooling Tube
1802   /////////////////////////////////////////////////////////////
1803   TList* coolingtubelist = GetCoolingTubeList();
1804   for(Int_t i=0; i<fgkcoolingtubenumber; i++)
1805         fcoolingtube[i] = (TGeoVolume*)coolingtubelist->At(i);
1806   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
1807         fendladdercoolingtube[i] =
1808                         (TGeoVolume*)coolingtubelist->At(fgkcoolingtubenumber+i);
1809   /////////////////////////////////////////////////////////////
1810   // SSD Flex
1811   /////////////////////////////////////////////////////////////
1812   fssdstiffenerflex = GetSSDStiffenerFlex();
1813   fssdendflex = GetSSDEndFlex();
1814   ///////////////////////////////////
1815   // End Ladder Carbon Fiber Junction
1816   ///////////////////////////////////
1817   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1818                                                    fendladdercarbonfiberjunction[i] =
1819                                                    new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1820   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1821     fendladdercarbonfiberjunction[i][0] =
1822                   GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]);
1823     fendladdercarbonfiberjunction[i][1] =
1824                   GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]);
1825   }
1826   ///////////////////////////////////
1827   // End Ladder Mounting Block
1828   ///////////////////////////////////
1829   fendladdermountingblock = GetSSDMountingBlock();
1830   ///////////////////////////////////
1831   // End Ladder Mounting Block
1832   ///////////////////////////////////
1833   fendladdermountingblockclip = GetMountingBlockClip();
1834   ///////////////////////////////////
1835   // Ladder Support
1836   ///////////////////////////////////
1837   TList* laddersupportlist = GetMountingBlockSupport(20);
1838   fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1839   fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1840   fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1841   fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
1842   /////////////////////////////////////////////////////////////
1843   // Deallocating memory
1844   /////////////////////////////////////////////////////////////
1845   delete carbonfibersupportlist;
1846   delete carbonfiberlowersupportlist;
1847   delete ssdhybridcomponentslist;
1848   delete laddersupportlist;
1849   /////////////////////////////////////////////////////////////
1850   fBasicObjects = kTRUE;
1851 }
1852 /////////////////////////////////////////////////////////////////////////////////
1853 void AliITSv11GeometrySSD::SetSSDSensor(){
1854   ////////////////////////////////////////////////////////////////
1855   // Method generating SSD Sensors: it sets the private variables
1856   // fSSDSensor5, fSSDSensor6
1857   ////////////////////////////////////////////////////////////////
1858   Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1859   Double_t ssdsensitivewidth  = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1860   TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
1861                                                 0.5*ssdsensitivewidth,
1862                                                 0.5*fgkSSDSensorHeight,
1863                                                 0.5*ssdsensitivelength);
1864   TGeoVolume* ssdsensorsensitiveLay5 =
1865         new TGeoVolume(fgSDDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
1866   TGeoVolume* ssdsensorsensitiveLay6 =
1867         new TGeoVolume(fgSDDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
1868   ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1869   ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
1870   TGeoBBox* ssdsensorinsensitiveshape[2];
1871   ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
1872                                                 0.5*fgkSSDSensorInsensitiveWidth,
1873                                                 0.5*fgkSSDSensorHeight,
1874                                                 0.5*fgkSSDSensorLength);
1875   ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
1876                                                 0.5*ssdsensitivewidth,
1877                                                 0.5*fgkSSDSensorHeight,
1878                                                 0.5*fgkSSDSensorInsensitiveWidth);
1879   const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
1880                                              "SSDSensorInsensitive2"};
1881   TGeoVolume* ssdsensorinsensitive[2];
1882   for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1883       new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1884                      fSSDSensorMedium);
1885       ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
1886   }
1887   /////////////////////////////////////////////////////////////
1888   // Virtual Volume containing SSD Sensor
1889   /////////////////////////////////////////////////////////////
1890   TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1891                                                                                              0.5*fgkSSDSensorWidth,
1892                                                                                              0.5*fgkSSDSensorHeight,
1893                                                                                              0.5*fgkSSDSensorLength);
1894   fSSDSensor5 = new TGeoVolume("ITSsddSensor5",virtualSSDSensorShape,
1895                                                                                  fSSDAir);
1896   fSSDSensor6 = new TGeoVolume("ITSsddSensor6",virtualSSDSensorShape,
1897                                                                                  fSSDAir);
1898   /////////////////////////////////////////////////////////////
1899   for(Int_t i=0; i<4; i++){
1900             fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1901             ssdsensorinsensitive[1],i<2?1:2,
1902                         new TGeoTranslation(
1903                          0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1904       *   (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1905                         0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1906       *   (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1907             fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1908             ssdsensorinsensitive[1],i<2?1:2,
1909                         new TGeoTranslation(
1910                          0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1911       *   (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1912                         0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1913       *   (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1914   }
1915     fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1916     fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
1917 }
1918 ///////////////////////////////////////////////////////////////////////////////
1919 TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1920   /////////////////////////////////////////////////////////////
1921   // Method generating the Carbon Fiber Support
1922   /////////////////////////////////////////////////////////////
1923   const Int_t kvertexnumber = 4;
1924   const Int_t kshapesnumber = 2;
1925   TVector3** vertexposition[kshapesnumber];
1926   for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1927   Double_t carbonfibersupportxaxisEdgeproj =
1928                 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1929         *       TMath::DegToRad());
1930   Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1931                                  /                         fgkCarbonFiberSupportXAxisLength);
1932   /////////////////////
1933   //Vertex Positioning
1934   ////////////////////
1935   vertexposition[0][0] = new TVector3();
1936   vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
1937                                                                           fgkCarbonFiberSupportYAxisLength);
1938   vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
1939                                                                           carbonfibersupportxaxisEdgeproj
1940                                            *                      TMath::Tan(theta));
1941   vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
1942                                            -                      carbonfibersupportxaxisEdgeproj,
1943                                                                           fgkCarbonFiberSupportYAxisLength
1944                                            -                      vertexposition[0][2]->Y());
1945   ////////////////////////////////////////////////////
1946   //Setting the parameters for Isometry Transformation
1947   ////////////////////////////////////////////////////
1948   Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
1949                                                                  +      fgkCarbonFiberSupportTopEdgeDist[0]
1950                                                                  +      fgkCarbonFiberSupportWidth);
1951   Double_t* param = new Double_t[4];
1952   param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
1953   for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
1954                                   new TVector3((GetReflection(vertexposition[0][j],param))->X(),
1955                                                           (GetReflection(vertexposition[0][j],param))->Y());
1956   char* carbonfibersupportshapename[kshapesnumber] =
1957                                                 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
1958   char* carbonfibersupportname[kshapesnumber] =
1959                                                 {"CarbonFiberSupport1","CarbonFiberSupport2"};
1960   TGeoArb8* carbonfibersupportshape[kshapesnumber];
1961   TGeoVolume* carbonfibersupport[kshapesnumber];
1962   TList* carbonfibersupportlist = new TList();
1963   Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
1964   Double_t carbonfibersupportheight =
1965           carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1966           *TMath::DegToRad());
1967   for(Int_t i = 0; i< kshapesnumber; i++){
1968    carbonfibersupportshape[i] =
1969                                         GetArbShape(vertexposition[i],width,carbonfibersupportheight,
1970                                                                 carbonfibersupportshapename[i],i==0 ? 1: -1);
1971    carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
1972                                                    carbonfibersupportshape[i],fSSDCarbonFiberMedium);
1973    carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
1974    carbonfibersupportlist->Add(carbonfibersupport[i]);
1975    }
1976   /////////////////////////////////////////////////////////////
1977   // Deallocating memory
1978   /////////////////////////////////////////////////////////////
1979   for(Int_t i=0; i< kshapesnumber; i++){
1980      for(Int_t j=0; j< kvertexnumber; j++)
1981            delete vertexposition[i][j];
1982        delete [] vertexposition[i];
1983   }
1984   delete [] param;
1985   /////////////////////////////////////////////////////////////
1986    return carbonfibersupportlist;
1987 }
1988 /////////////////////////////////////////////////////////////////////////////////
1989 TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
1990   /////////////////////////////////////////////////////////////
1991   // Method generating SSD Carbon Fiber Junction
1992   /////////////////////////////////////////////////////////////
1993   const Int_t kvertexnumber = 6;
1994   TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
1995   Double_t reflectionparam[3] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1996                                                           *  TMath::DegToRad()),-1.,0.};
1997   TVector3* vertex[kvertexnumber];
1998   vertex[0] = new TVector3();
1999   vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
2000                         *                         TMath::Cos(fgkCarbonFiberJunctionAngle[0]
2001                         *                         TMath::DegToRad()),
2002                                                   fgkCarbonFiberJunctionEdge[0]
2003                         *                         TMath::Sin(fgkCarbonFiberJunctionAngle[0]
2004                         *                         TMath::DegToRad()));
2005   vertex[4] = new TVector3(fgkCarbonFiberJunctionLength,
2006                                                    fgkCarbonFiberJunctionEdge[1]);
2007   vertex[5] = new TVector3(fgkCarbonFiberJunctionLength);
2008   vertex[1] = GetReflection(vertex[5],reflectionparam);
2009   vertex[2] = GetReflection(vertex[4],reflectionparam);
2010   Double_t xvertexpoints[6], yvertexpoints[6];
2011   for(Int_t i=0; i<kvertexnumber; i++)
2012           xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
2013   carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2014   carbonfiberjunctionshape->DefineSection(0,-0.5*width);
2015   carbonfiberjunctionshape->DefineSection(1,0.5*width);
2016   TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
2017                                                                 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
2018   carbonfiberjunction->SetLineColor(fColorCarbonFiber);
2019   /////////////////////////////////////////////////////////////
2020   // Deallocating memory
2021   /////////////////////////////////////////////////////////////
2022   for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
2023   /////////////////////////////////////////////////////////////
2024   return carbonfiberjunction;
2025 }
2026 ////////////////////////////////////////////////////////////////////////////////
2027 TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
2028   /////////////////////////////////////////////////////////////
2029   // Method generating the Carbon Fiber Lower Support
2030   /////////////////////////////////////////////////////////////
2031   const Int_t kvertexnumber = 4;
2032   const Int_t kshapesnumber = 2;
2033   Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
2034                                                                 fgkCarbonFiberLowerSupportWidth};
2035   TVector3** vertexposition[kshapesnumber];
2036   for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
2037                                                  new TVector3*[kvertexnumber];
2038   //First Shape Vertex Positioning
2039   vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
2040   vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
2041                                            -            fgkCarbonFiberLowerSupportLowerLenght);
2042   vertexposition[0][2] = new TVector3();
2043   vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
2044   //Second Shape Vertex Positioning
2045   Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
2046                                  -                              fgkCarbonFiberLowerSupportVolumePosition[0])
2047                                  /                              fgkCarbonFiberTriangleLength);
2048   vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
2049                                                                 vertexposition[0][0]->X()*TMath::Tan(theta)
2050                                  +                              fgkCarbonFiberLowerSupportVolumePosition[0]);
2051   vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
2052                                                                 vertexposition[0][1]->X()*TMath::Tan(theta)
2053                                  +                              fgkCarbonFiberLowerSupportVolumePosition[0]);
2054   vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
2055   vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
2056                                                                 fgkCarbonFiberLowerSupportVolumePosition[1]);
2057   char* carbonfiberlowersupportshapename[kshapesnumber] =
2058                           {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
2059   char* carbonfiberlowersupportname[kshapesnumber] =
2060                           {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
2061   TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
2062   TGeoVolume* carbonfiberlowersupport[kshapesnumber];
2063   TList* carbonfiberlowersupportlist = new TList();
2064   for(Int_t i = 0; i< kshapesnumber; i++){
2065         carbonfiberlowersupportshape[i] =
2066                                                                 GetArbShape(vertexposition[i],width,
2067                                                                                         fgkCarbonFiberLowerSupportHeight,
2068                                                                                         carbonfiberlowersupportshapename[i]);
2069     carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
2070                                                 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
2071         carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
2072     carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
2073   }
2074   /////////////////////////////////////////////////////////////
2075   // Deallocating memory
2076   /////////////////////////////////////////////////////////////
2077   for(Int_t i=0; i< kshapesnumber; i++){
2078      for(Int_t j=0; j< kvertexnumber; j++)
2079            delete vertexposition[i][j];
2080        delete [] vertexposition[i];
2081   }
2082   /////////////////////////////////////////////////////////////
2083   return carbonfiberlowersupportlist;
2084 }
2085 ///////////////////////////////////////////////////////////////////////////////
2086 TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
2087                                                                  Double_t width, Double_t* thickness)const{
2088   /////////////////////////////////////////////////////////////
2089   // Method generating the Sensor Support
2090   /////////////////////////////////////////////////////////////
2091         const Int_t kvertexnumber = 6;
2092         TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2093     TVector3* vertexposition[kvertexnumber];
2094         vertexposition[0] = new TVector3();
2095         vertexposition[1] = new TVector3(0.0,length);
2096         vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());
2097         vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);
2098         vertexposition[4] = new TVector3(height,vertexposition[3]->Y());
2099         vertexposition[5] = new TVector3(vertexposition[4]->X());
2100         Double_t xvertexpoints[6], yvertexpoints[6];
2101         for(Int_t i=0; i<kvertexnumber; i++)
2102                 xvertexpoints[i] = vertexposition[i]->X(),
2103                 yvertexpoints[i] = vertexposition[i]->Y();
2104     ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2105     ssdsensorsupportshape->DefineSection(0,-0.5*width);
2106     ssdsensorsupportshape->DefineSection(1,0.5*width);
2107     TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2108                                                                  ssdsensorsupportshape,fSSDSensorSupportMedium);
2109   /////////////////////////////////////////////////////////////
2110   // Deallocating memory
2111   /////////////////////////////////////////////////////////////
2112         for (Int_t i=0; i<kvertexnumber; i++)
2113                 delete vertexposition[i];
2114   /////////////////////////////////////////////////////////////
2115     return ssdsensorsupport;
2116 }
2117 ////////////////////////////////////////////////////////////////////////////////
2118 TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2119   /////////////////////////////////////////////////////////////
2120   // Method generating the Cooling Tube Support
2121   /////////////////////////////////////////////////////////////
2122   if(nedges%2!=0) nedges--;
2123   const Int_t kvertexnumber = nedges+5;
2124   Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2125                            /                     fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2126   Double_t angle = 90.+phi;
2127   Double_t psi = 90.-phi;
2128   ///////////////////////////////////////
2129   // Vertex Positioning for TGeoXTru
2130   ///////////////////////////////////////
2131   TVector3** vertexposition = new TVector3*[kvertexnumber];
2132   vertexposition[0] = new TVector3(fgkCoolingTubeSupportRmin*CosD(angle),
2133                                                                    fgkCoolingTubeSupportRmin*SinD(angle));
2134   vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2135                                                                    fgkCoolingTubeSupportRmax*SinD(angle));
2136   vertexposition[2] = new TVector3(vertexposition[1]->X(),
2137                                                                    fgkCoolingTubeSupportRmax);
2138   vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2139                                                                    fgkCoolingTubeSupportRmax);
2140   vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2141                                                                     vertexposition[1]->Y());
2142   for(Int_t i=0; i<nedges; i++)
2143         vertexposition[i+5] =
2144                 new TVector3(fgkCoolingTubeSupportRmin*CosD(psi+i*(2.*phi/nedges)),
2145                                          fgkCoolingTubeSupportRmin*SinD(psi+i*(2.*phi/nedges)));
2146   ///////////////////////////////////////////////////////////////////////
2147   // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2148   ///////////////////////////////////////////////////////////////////////
2149   TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2150   Double_t* xvertexpoints = new Double_t[kvertexnumber];
2151   Double_t* yvertexpoints = new Double_t[kvertexnumber];
2152   for(Int_t i=0; i<kvertexnumber; i++){
2153         xvertexpoints[i] = vertexposition[i]->X();
2154         yvertexpoints[i] = vertexposition[i]->Y();
2155   }
2156   coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2157                                                                                         yvertexpoints);
2158   coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2159   coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2160   TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2161                                                                           coolingtubesupportarcshape,
2162                                                                                   fSSDTubeHolderMedium);
2163   coolingtubesupportarc->SetLineColor(fColorG10);
2164   //////////////////////////////////////////////////////////////////////////
2165   // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2166   //////////////////////////////////////////////////////////////////////////
2167   TGeoTubeSeg* coolingtubesupportsegshape =
2168                                                         new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2169                                                                                         fgkCoolingTubeSupportRmax,
2170                                                                                         0.5*fgkCoolingTubeSupportWidth,
2171                                                                                         phi,360-phi);
2172   TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2173                                                                                         coolingtubesupportsegshape,
2174                                                                                         fSSDTubeHolderMedium);
2175   coolingtubesupportseg->SetLineColor(fColorG10);
2176   //////////////////////////////////////////////////////////////////////////
2177   // TGeoBBox Volume definition for Cooling Tube Support Box Part
2178   //////////////////////////////////////////////////////////////////////////
2179   Double_t* boxorigin = new Double_t[3];
2180   Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2181   boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2182   TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2183                                                                                  0.5*fgkCoolingTubeSupportHeight,
2184                                                                                  0.5*fgkCoolingTubeSupportWidth,boxorigin);
2185   TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2186                                coolingtubesupportboxshape,fSSDTubeHolderMedium);
2187   coolingtubesupportbox->SetLineColor(fColorG10);
2188   //////////////////////////////////////////////////////////////////////////
2189   // Cooling Tube for Cooling Tube Support
2190   //////////////////////////////////////////////////////////////////////////
2191   TGeoXtru* coolingtubearcshape[2];
2192   coolingtubearcshape[0] = new TGeoXtru(2);
2193   Double_t* xvert = new Double_t[nedges+2];
2194   Double_t* yvert = new Double_t[nedges+2];
2195   Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2196   ////////////////////////////////////////
2197   // Positioning the vertices for TGeoXTru
2198   ////////////////////////////////////////
2199   xvert[0] = 0., yvert[0] = 0.;
2200   xvert[1] = vertexposition[0]->X()*ratio,  yvert[1] = vertexposition[0]->Y()*ratio;
2201   for(Int_t i=0; i< nedges; i++)
2202                 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2203                 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2204   ////////////////////////////////////////
2205   // Defining TGeoXTru PolyGone
2206   ////////////////////////////////////////
2207   coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2208   coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2209   coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2210   coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2211                 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2212   TGeoVolume* coolingtubearc[2];
2213   coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2214                                                                   coolingtubearcshape[0],fSSDCoolingTubeWater);
2215   coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2216                                                                   coolingtubearcshape[1],fSSDCoolingTubePhynox);
2217   coolingtubearc[0]->SetLineColor(fColorWater);
2218   coolingtubearc[1]->SetLineColor(fColorPhynox);
2219   ////////////////////////////////////////////
2220   // Defining TGeoTubeSeg Part of Cooling Tube
2221   ////////////////////////////////////////////
2222   TGeoTubeSeg* coolingtubesegshape[2];
2223   coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2224                                                         0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2225   coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2226                                                         0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2227   TGeoVolume* coolingtubeseg[2];
2228   coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2229                                                                  coolingtubesegshape[0],fSSDCoolingTubePhynox);
2230   coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2231                                                                  coolingtubesegshape[1],fSSDCoolingTubeWater);
2232   coolingtubeseg[0]->SetLineColor(fColorPhynox);
2233   coolingtubeseg[1]->SetLineColor(fColorWater);
2234   /////////////////////////////////////////////////////////////
2235   // Virtual Volume containing Cooling Tube Support
2236   /////////////////////////////////////////////////////////////
2237   TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2238   const Int_t kvirtualvertexnumber = 8;
2239   TVector3* virtualvertex[kvirtualvertexnumber];
2240    ////////////////////////////////////////
2241   // Positioning the vertices for TGeoXTru
2242   ////////////////////////////////////////
2243   virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax);
2244   virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
2245   virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
2246   virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
2247   virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
2248   virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
2249   virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
2250   virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
2251   Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2252   for(Int_t i=0; i< kvirtualvertexnumber; i++)
2253         xmothervertex[i] = virtualvertex[i]->X(),
2254         ymothervertex[i] = virtualvertex[i]->Y();
2255   ////////////////////////////////////////
2256   // Defining TGeoXTru PolyGone
2257   ////////////////////////////////////////
2258   virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2259                                                                                                                                          ymothervertex);
2260   virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2261   virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2262   TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2263                                                                  virtualCoolingTubeSupportShape,fSSDAir);
2264   ////////////////////////////////////////
2265   // Positioning Volumes in Virtual Volume
2266   ////////////////////////////////////////
2267   TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2268   coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2269   virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2270   virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2271   virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
2272   virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2273   virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2274   virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2275   virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
2276   /////////////////////////////////////////////////////////////
2277   // Deallocating memory
2278   /////////////////////////////////////////////////////////////
2279   delete [] vertexposition;
2280   delete xvertexpoints;
2281   delete yvertexpoints;
2282   delete xvert;
2283   delete yvert;
2284   for(Int_t i=0; i< kvirtualvertexnumber; i++)
2285         delete virtualvertex[i];
2286   /////////////////////////////////////////////////////////////
2287         return virtualcoolingtubesupport;
2288 }
2289 /////////////////////////////////////////////////////////////////////////////////
2290 TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2291   /////////////////////////////////////////////////////////////
2292   // Method generating List containing SSD Hybrid Components
2293   /////////////////////////////////////////////////////////////
2294   TList* ssdhybridlist = new TList();
2295   const Int_t kssdstiffenernumber = 2;
2296   Double_t ssdstiffenerseparation = fgkSSDSensorLength
2297                                                                   - 2.*fgkSSDModuleStiffenerPosition[1]
2298                                                                   -    fgkSSDStiffenerWidth;
2299   Double_t ssdchipcablesradius[kssdstiffenernumber];
2300   for(Int_t i=0; i<kssdstiffenernumber; i++)
2301           ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2302                                -  fgkSSDChipCablesHeight[0]
2303                                -  fgkSSDChipCablesHeight[1]);
2304   /////////////////////////////////////////////////////////////
2305   // Mother Volumes Containers
2306   /////////////////////////////////////////////////////////////
2307   const Int_t kmothernumber = 2;
2308   const Int_t kmothervertexnumber = 12;
2309   Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2310   Double_t ymothervertex[kmothernumber][kmothervertexnumber];
2311   ///////////////////////
2312   // Setting the vertices
2313   ///////////////////////
2314   xmothervertex[0][0]  = -0.5*fgkSSDStiffenerLength;
2315   xmothervertex[0][1]  = xmothervertex[0][0];
2316   xmothervertex[0][2]  = fgkSSDFlexLength[0]-0.5*fgkSSDStiffenerLength;
2317   xmothervertex[0][3]  = xmothervertex[0][2];
2318   xmothervertex[0][4]  = xmothervertex[0][0];
2319   xmothervertex[0][5]  = xmothervertex[0][4];
2320   xmothervertex[0][6]  = -xmothervertex[0][0];
2321   xmothervertex[0][7]  = xmothervertex[0][6];
2322   xmothervertex[0][8]  = -xmothervertex[0][2];
2323   xmothervertex[0][9]  = xmothervertex[0][8];
2324   xmothervertex[0][10] = xmothervertex[0][7];
2325   xmothervertex[0][11] = xmothervertex[0][10];
2326   for(Int_t i=0; i<kmothervertexnumber; i++) xmothervertex[1][i] = xmothervertex[0][i];
2327   for(Int_t i = 0; i<kmothernumber; i++){
2328       ymothervertex[i][0]  = -(fgkSSDChipWidth-(0.5*fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist)
2329                            + ssdchipcablesradius[i]+fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]);
2330       ymothervertex[i][1]  = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexWidth[0];
2331       ymothervertex[i][2]  = ymothervertex[i][1];
2332       ymothervertex[i][3]  = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth;
2333       ymothervertex[i][4]  = ymothervertex[i][3];
2334       ymothervertex[i][5]  = ymothervertex[i][4]+0.5*fgkSSDStiffenerWidth-ymothervertex[i][0];
2335       ymothervertex[i][6]  = ymothervertex[i][5];
2336       ymothervertex[i][7]  = 0.5*fgkSSDStiffenerWidth+fgkSSDFlexWidth[0];
2337       ymothervertex[i][8]  = ymothervertex[i][7];
2338       ymothervertex[i][9]  = 0.5*fgkSSDStiffenerWidth;
2339       ymothervertex[i][10] = ymothervertex[i][9];
2340       ymothervertex[i][11] = ymothervertex[i][0];
2341   }
2342   TGeoXtru* ssdhybridmothershape[kmothernumber];
2343   TGeoVolume* ssdhybridmother[kmothernumber];
2344   const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2345   for(Int_t i=0; i<kmothernumber; i++){
2346       ssdhybridmothershape[i] = new TGeoXtru(2);
2347       ssdhybridmothershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
2348                                           ymothervertex[i]);
2349       ssdhybridmothershape[i]->DefineSection(0,-0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2350                                                -fgkSSDChipCablesHeight[i+2]);
2351       ssdhybridmothershape[i]->DefineSection(1, 0.5*fgkSSDStiffenerHeight);
2352       ssdhybridmother[i] = new TGeoVolume(ssdhybridmothername[i],ssdhybridmothershape[i],
2353                                           fSSDAir);
2354    }
2355   /////////////////////////////////////////////////////////////
2356   // SSD Stiffener
2357   /////////////////////////////////////////////////////////////
2358   TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2359                                              0.5*fgkSSDStiffenerLength,
2360                                              0.5*fgkSSDStiffenerWidth,
2361                                              0.5*fgkSSDStiffenerHeight);
2362   TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2363                                             fSSDStiffenerMedium);
2364   ssdstiffener->SetLineColor(fColorStiffener);
2365   TGeoTranslation* ssdstiffenertrans[kssdstiffenernumber];
2366   for(Int_t i=0; i<kssdstiffenernumber; i++)
2367       ssdstiffenertrans[i] = new TGeoTranslation(0.,i*ssdstiffenerseparation,0.);
2368   /////////////////////////////////////////////////////////////
2369   // SSD Chip System
2370   /////////////////////////////////////////////////////////////
2371   TList* ssdchipsystemlist = GetSSDChipSystem();
2372   Double_t ssdchipseparation = fgkSSDSensorLength
2373                              - 2.*fgkSSDModuleStiffenerPosition[1]
2374                              - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
2375                              - 0.5*fgkSSDChipWidth);
2376   Double_t ssdchipsystemlength = (fgkSSDChipNumber-1)*(fgkSSDChipLength
2377                                +  fgkSSDChipSeparationLength)+fgkSSDChipCablesLength[1];
2378   TGeoTranslation* ssdchipsystemtrans = new TGeoTranslation(0.5*fgkSSDChipCablesLength[1]
2379                                       - 0.5*ssdchipsystemlength,
2380                                         0.5*(ssdstiffenerseparation-ssdchipseparation),
2381                                       - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight));
2382 ////////////////////////////
2383 // Capacitor 0603-2200 nF
2384 ///////////////////////////
2385   const Int_t knapacitor0603number = 5;
2386   TGeoBBox* capacitor0603shape =  new TGeoBBox("Capacitor0603Shape",
2387                                                                                          0.5*fgkSSDCapacitor0603Length,
2388                                                                                          0.5*fgkSSDCapacitor0603Width,
2389                                                                                          0.5*fgkSSDCapacitor0603Height);
2390   TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
2391                                              fSSDStiffener0603CapacitorMedium);
2392   capacitor0603->SetLineColor(fColorAl);
2393   for(Int_t i=0; i<kmothernumber; i++){
2394       for(Int_t j=0; j<kssdstiffenernumber; j++){
2395             ssdhybridmother[i]->AddNode(ssdstiffener,j+1,ssdstiffenertrans[j]);
2396             for(Int_t k=1; k<knapacitor0603number+1; k++){
2397                   ssdhybridmother[i]->AddNode(capacitor0603,knapacitor0603number*j+k,
2398                         new TGeoTranslation((k-3.)/6*fgkSSDStiffenerLength,
2399                                              j*ssdstiffenerseparation
2400                         +                    0.5*((j==0? 1:-1)*fgkSSDStiffenerWidth
2401                         +                    (j==0? -1:+1)*fgkSSDCapacitor0603Width),
2402                         -                    0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
2403             }
2404       }
2405       ssdhybridmother[i]->AddNode((TGeoVolume*)ssdchipsystemlist->At(i),i+1,ssdchipsystemtrans);
2406       ssdhybridlist->Add(ssdhybridmother[i]);
2407   }
2408 /////////////////////////////////////////////////////////////
2409 // Mother Volume Containing Capacitor Part
2410 /////////////////////////////////////////////////////////////
2411   const Int_t kcapacitormothernumber = 8;
2412   Double_t xcapacitorvertex[kcapacitormothernumber];
2413   Double_t ycapacitorvertex[kcapacitormothernumber];
2414   ///////////////////////
2415   // Setting the vertices
2416   ///////////////////////
2417   xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2418   xcapacitorvertex[1] = xcapacitorvertex[0];
2419   xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2420   xcapacitorvertex[3] = xcapacitorvertex[2];
2421   xcapacitorvertex[4] = xcapacitorvertex[0];
2422   xcapacitorvertex[5] = xcapacitorvertex[0];
2423   xcapacitorvertex[6] = -xcapacitorvertex[0];
2424   xcapacitorvertex[7] = xcapacitorvertex[6];
2425   ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2426   ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2427   ycapacitorvertex[2] = ycapacitorvertex[1];
2428   ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2429   ycapacitorvertex[4] = ycapacitorvertex[3];
2430   ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2431   ycapacitorvertex[6] = ycapacitorvertex[5];
2432   ycapacitorvertex[7] = ycapacitorvertex[0];
2433   TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2434   ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2435                                               ycapacitorvertex);
2436   ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2437   ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
2438   TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2439                                           fSSDAir);
2440 ////////////////////////////
2441 // Connector
2442 ///////////////////////////
2443   const Int_t kssdconnectornumber = 2;
2444   TGeoBBox* ssdconnectorshape[kssdconnectornumber];
2445   Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2446   Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2447                                    +  fgkSSDConnectorAlHeight};
2448   const char* ssdconnectorname[kssdconnectornumber] = {"SSDConnectorAl","SSDConnectorNi"};
2449   TGeoVolume* ssdconnector[kssdconnectornumber];
2450   for(Int_t i=0; i<kssdconnectornumber; i++){
2451       ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2452                                           0.5*fgkSSDConnectorWidth,
2453                                           0.5*((1-i)*fgkSSDConnectorAlHeight
2454                            +              i*fgkSSDConnectorNiHeight),
2455                              i==0? ssdAlconnectororigin : ssdNiconnectororigin);
2456       ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
2457                                        i==0 ? fSSDAlTraceFlexMedium
2458                                             : fSSDStiffenerConnectorMedium);
2459       ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorPhynox);
2460   }
2461   TGeoTranslation* ssdconnectortrans[2*kssdconnectornumber];
2462   ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2463                        +  fgkSSDConnectorPosition[0]
2464                        -  fgkSSDConnectorSeparation
2465                        -  1.5*fgkSSDConnectorLength,
2466                           ssdstiffenerseparation+ssdstiffenershape->GetDY()
2467                        -  fgkSSDConnectorPosition[1]
2468                        -  ssdconnectorshape[0]->GetDY(),0.0);
2469   ssdconnectortrans[1] = new TGeoTranslation(
2470                        -  ssdstiffenershape->GetDX()
2471                        +  fgkSSDConnectorPosition[0]
2472                        -  0.5*fgkSSDConnectorLength,
2473                           ssdstiffenerseparation+ssdstiffenershape->GetDY()
2474                        -  fgkSSDConnectorPosition[1]
2475                        -  ssdconnectorshape[0]->GetDY(),0.0);
2476   ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2477                        -  fgkSSDConnectorPosition[0]
2478                        +  fgkSSDConnectorSeparation
2479                        +  1.5*fgkSSDConnectorLength,
2480                           -(ssdstiffenershape->GetDY()
2481                        -  fgkSSDConnectorPosition[1]
2482                        -  ssdconnectorshape[0]->GetDY()),0.0);
2483   ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2484                        -  fgkSSDConnectorPosition[0]
2485                        +  0.5*fgkSSDConnectorLength,
2486                           -(ssdstiffenershape->GetDY()
2487                        -  fgkSSDConnectorPosition[1]
2488                        -  ssdconnectorshape[0]->GetDY()),0.0);
2489   for(Int_t i=0; i<2*kssdconnectornumber; i++)
2490       for(Int_t j=0; j<kssdconnectornumber; j++)
2491             ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2492 ////////////////////////////
2493 // Capacitor 1812-330 nF
2494 ///////////////////////////
2495   Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
2496   TGeoBBox* capacitor1812shape =  new TGeoBBox("Capacitor1812Shape",
2497                                                                                          0.5*fgkSSDCapacitor1812Length,
2498                                                                                          0.5*fgkSSDCapacitor1812Width,
2499                                                                                          0.5*fgkSSDCapacitor1812Height,
2500             ssdcapacitor1812origin);
2501   TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2502                                              fSSDStiffener1812CapacitorMedium);
2503   capacitor1812->SetLineColor(fColorAl);
2504   TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2505                                         0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2506                                       - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.0);
2507   ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
2508 ////////////////////////////
2509 //Hybrid Wire
2510 ////////////////////////////
2511   Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
2512                                  - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2513                                  - fgkSSDConnectorSeparation;
2514   Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
2515                                  - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
2516   Double_t ssdwireradius = TMath::Sqrt(TMath::Power(wirex,2.)
2517                                          + TMath::Power(wirey,2));
2518   Double_t wireangle = TMath::ATan(wirex/wirey);
2519   TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2520                                                 fgkSSDWireRadius, 0.5*ssdwireradius);
2521   TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2522                                              fSSDStiffenerHybridWireMedium);
2523   hybridwire->SetLineColor(fColorPhynox);
2524   TGeoCombiTrans* hybridwirecombitrans[2];
2525   hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
2526                    0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2527                                  + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
2528                    0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
2529                                  + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
2530                                    ssdstiffenershape->GetDZ()
2531                                  + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight,
2532                    new TGeoRotation("HybridWireRot1",0.,90.,0.));
2533   hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
2534                             0.0,
2535                           - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2536                             0.0,
2537                             new TGeoRotation("HybridWireRot2",
2538                           - wireangle*TMath::RadToDeg(),0.,0.));
2539   TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2540   hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2541   hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
2542   ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2543   ssdhybridlist->Add(ssdhybridcapacitormother);
2544   /////////////////////////////////////////////////////////////
2545   // Deallocating memory
2546   /////////////////////////////////////////////////////////////
2547   delete hybridwirecombitrans[0];
2548   delete hybridwirecombitrans[1];
2549   delete ssdchipsystemlist;
2550   return ssdhybridlist;
2551   /////////////////////////////////////////////////////////////
2552 }
2553 ///////////////////////////////////////////////////////////////////////////////
2554 TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2555   /////////////////////////////////////////////////////////////
2556   // SSD Cooling Block System
2557   /////////////////////////////////////////////////////////////
2558   // SSD Cooling Block and Cooling Tube Transformations
2559   /////////////////////////////////////////////////////////////
2560   TGeoRotation* localcoolingblockrot = new TGeoRotation();
2561   localcoolingblockrot->SetAngles(0.,90.,0.);
2562   TGeoCombiTrans* localcoolingblockmatrix =
2563         new TGeoCombiTrans(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
2564   TGeoTranslation* localcoolingblocktrans;
2565   TVector3* coolingblocktransvector;
2566   coolingblocktransvector = new TVector3(fgkSSDModuleSensorSupportDistance
2567                                                                 + fgkSSDCoolingBlockLength,
2568                                                                   fgkSSDSensorLength
2569                                                                 - 2.*fgkSSDModuleStiffenerPosition[1]
2570                                                                 - fgkSSDCoolingBlockWidth);
2571   const Int_t kcoolingblocktransnumber = 2;
2572   const Int_t kcoolingblocknumber = 4;
2573   TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
2574   TGeoHMatrix* coolingtubematrix[kcoolingblocknumber];
2575   TGeoRotation* localcoolingtuberot = new TGeoRotation();
2576   localcoolingtuberot->SetAngles(0.0,90.0,0.0);
2577   TGeoTranslation* localcoolingtubetrans = new TGeoTranslation();
2578   localcoolingtubetrans->SetTranslation(0.5*fgkSSDCoolingBlockLength,
2579                                                                                 0.5*fgkSSDCoolingBlockWidth,
2580                                                                                         fgkSSDCoolingBlockHoleCenter);
2581   TGeoCombiTrans* localcoolingtubematrix = new TGeoCombiTrans(*localcoolingtubetrans,
2582                                                                                                                           *localcoolingtuberot);
2583   Double_t coolingtubedistance = fgkCoolingTubeSupportRmax-fgkCoolingTubeSupportRmin;
2584   for(Int_t i=0; i<kcoolingblocktransnumber; i++){
2585           for(Int_t j=0; j<kcoolingblocktransnumber; j++){
2586                 localcoolingblocktrans=
2587                      new TGeoTranslation(i*coolingblocktransvector->X()+2*coolingtubedistance,
2588                                                                  j*coolingblocktransvector->Y(),
2589                                                                  - 0.5*(fgkSSDCoolingBlockHoleCenter
2590                                                              + fgkCoolingTubeRmax));
2591                 coolingblockmatrix[2*i+j] = new TGeoHMatrix((*localcoolingblocktrans)
2592                                                                  *(*localcoolingblockmatrix));
2593                 coolingtubematrix[2*i+j] = new TGeoHMatrix((*localcoolingblocktrans)
2594                                                                  *(*localcoolingtubematrix));
2595         }
2596   }
2597   /////////////////////////////////////////////////////////////
2598   // Virtual Volume containing CoolingBlock System
2599   /////////////////////////////////////////////////////////////
2600   TGeoXtru* coolingsystemothershape = new TGeoXtru(2);
2601   const Int_t kmothervertexnumber = 16;
2602   Double_t xmothervertex[kmothervertexnumber];
2603   Double_t ymothervertex[kmothervertexnumber];
2604   ///////////////////////
2605   // Setting the vertices
2606   ///////////////////////fgkCoolingTubeSupportRmax
2607   xmothervertex[0] = 0.0,ymothervertex[0] = 0.0;
2608   xmothervertex[1] = xmothervertex[0], ymothervertex[1] = coolingblocktransvector->Y()
2609                                    + fgkSSDCoolingBlockWidth;
2610   xmothervertex[2] = coolingblocktransvector->X()
2611                                    + fgkSSDCoolingBlockLength
2612                                    + 4*coolingtubedistance;
2613   ymothervertex[2] = ymothervertex[1];
2614   xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
2615   xmothervertex[4] = xmothervertex[3]-2.*coolingtubedistance-fgkSSDCoolingBlockLength;
2616   ymothervertex[4] = ymothervertex[0];
2617   xmothervertex[5] = xmothervertex[4], ymothervertex[5] = fgkSSDCoolingBlockWidth;
2618   xmothervertex[6] = xmothervertex[3]-coolingtubedistance;
2619   ymothervertex[6] = ymothervertex[5];
2620   xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
2621                                    - fgkSSDCoolingBlockWidth;
2622   xmothervertex[8] = xmothervertex[5], ymothervertex[8] = ymothervertex[7];
2623   xmothervertex[9] = xmothervertex[8], ymothervertex[9] = ymothervertex[2]
2624                                    - coolingtubedistance;
2625   xmothervertex[10] = fgkSSDCoolingBlockLength+2.*coolingtubedistance;
2626   ymothervertex[10] = ymothervertex[9];
2627   xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[8];
2628   xmothervertex[12] = coolingtubedistance, ymothervertex[12] = ymothervertex[11];
2629   xmothervertex[13] = xmothervertex[12], ymothervertex[13] = fgkSSDCoolingBlockWidth;
2630   xmothervertex[14] = 2.*coolingtubedistance+fgkSSDCoolingBlockLength;
2631   ymothervertex[14] = ymothervertex[13];
2632   xmothervertex[15] = xmothervertex[14], ymothervertex[15] = ymothervertex[0];
2633   //////////////////////////////////////////////////////////
2634   coolingsystemothershape->DefinePolygon(kmothervertexnumber,
2635                                                                         xmothervertex,ymothervertex);
2636   coolingsystemothershape->DefineSection(0,-0.5*(fgkSSDCoolingBlockHoleCenter
2637                                                                                            + fgkCoolingTubeRmax));
2638   coolingsystemothershape->DefineSection(1, 0.5*(fgkSSDCoolingBlockHoleCenter
2639                                                                                            + fgkCoolingTubeRmax));
2640   TGeoVolume* coolingsystemother = new TGeoVolume("CoolingBlockSystem",
2641                                                           coolingsystemothershape,fSSDAir);
2642   /////////////////////////////////////////////////////////////
2643   // SSD Cooling Tube Part
2644   /////////////////////////////////////////////////////////////
2645   TGeoTube* coolingtubeshape[fgkcoolingtubenumber];
2646   coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2647                                                                                  0.5*fgkSSDCoolingBlockWidth);
2648   coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
2649                                                                          0.5*fgkSSDCoolingBlockWidth);
2650   TGeoVolume* coolingtube[fgkcoolingtubenumber];
2651   coolingtube[0] = new TGeoVolume("OuterCoolingTube",coolingtubeshape[0],
2652                                                                         fSSDCoolingTubePhynox);
2653   coolingtube[1] = new TGeoVolume("InnerCoolingTube",coolingtubeshape[1],
2654                                                                         fSSDCoolingTubeWater);
2655   coolingtube[0]->SetLineColor(fColorPhynox);
2656   coolingtube[1]->SetLineColor(fColorWater);
2657   TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2658   /////////////////////////////////////////////////////////////
2659   // Adding Cooling block to mother volume
2660   /////////////////////////////////////////////////////////////
2661    for(Int_t i=0; i<kcoolingblocknumber; i++){
2662         coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
2663         coolingsystemother->AddNode(coolingtube[0],i+1,coolingtubematrix[i]);
2664         coolingsystemother->AddNode(coolingtube[1],i+1,coolingtubematrix[i]);
2665   }
2666   /////////////////////////////////////////////////////////////
2667   // Deallocating memory
2668   /////////////////////////////////////////////////////////////
2669         delete coolingblocktransvector;
2670     delete localcoolingblocktrans;
2671         delete localcoolingblockrot;
2672         delete localcoolingblockmatrix;
2673         delete localcoolingtubetrans;
2674         delete localcoolingtuberot;
2675   /////////////////////////////////////////////////////////////
2676   // Checking overlaps
2677   /////////////////////////////////////////////////////////////
2678         //coolingsystemother->CheckOverlaps(0.01);
2679   /////////////////////////////////////////////////////////////
2680         return coolingsystemother;
2681 }
2682 /////////////////////////////////////////////////////////////////////////////////
2683 TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
2684   /////////////////////////////////////////////////////////////
2685   // SSD Flex
2686   /////////////////////////////////////////////////////////////
2687   const Int_t kssdflexlayernumber = 2;
2688   TGeoXtru* ssdflexshape[kssdflexlayernumber];
2689   for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2690   const Int_t kmothervertexnumber = 17;
2691   Double_t xmothervertex[kmothervertexnumber];
2692   Double_t ymothervertex[kmothervertexnumber];
2693   /////////////////////////////////////////////
2694   // Auxiliary variables for vertex positioning
2695   /////////////////////////////////////////////
2696   const Int_t kssdflexboxnumber = 5;
2697   Double_t ssdflexboxlength[kssdflexboxnumber];
2698   ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
2699                                           *     fgkSSDChipLength+(fgkSSDChipNumber-1)
2700                                           *     fgkSSDChipSeparationLength
2701                                           - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2702                                           - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
2703   ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2704   ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
2705                                           -     fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
2706   ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2707   ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2708                                           -     ssdflexboxlength[1];
2709   Double_t ssdflexboxwidth[kssdflexboxnumber];
2710   ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2711   ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2712   ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2713   ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2714   ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
2715   ///////////////////////
2716   // Setting the vertices
2717   ///////////////////////
2718   xmothervertex[0]  = 0.0;
2719   xmothervertex[1]  = xmothervertex[0];
2720   xmothervertex[2]  = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2721   xmothervertex[3]  = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2722                                         + ssdflexboxlength[4];
2723   xmothervertex[4]  = xmothervertex[3];
2724   xmothervertex[5]  = xmothervertex[4]-ssdflexboxlength[4];
2725   xmothervertex[6]  = xmothervertex[5];
2726   xmothervertex[7]  = xmothervertex[6]-fgkSSDFlexHoleLength;
2727   xmothervertex[8]  = xmothervertex[7];
2728   xmothervertex[9]  = xmothervertex[8]-ssdflexboxlength[2];
2729   xmothervertex[10] = xmothervertex[9];
2730   xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2731   xmothervertex[12] = xmothervertex[11];
2732   xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2733   xmothervertex[14] = xmothervertex[13];
2734   xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2735   xmothervertex[16] = xmothervertex[15];
2736   ymothervertex[0]  = 0.0;
2737   ymothervertex[1]  = fgkSSDFlexWidth[1];
2738   ymothervertex[2]  = fgkSSDFlexWidth[0];
2739   ymothervertex[3]  = ymothervertex[2];
2740   ymothervertex[4]  = ymothervertex[0];
2741   ymothervertex[5]  = ymothervertex[4];
2742   ymothervertex[6]  = ssdflexboxwidth[2];
2743   ymothervertex[7]  = ymothervertex[6];
2744   ymothervertex[8]  = ymothervertex[0];
2745   ymothervertex[9]  = ymothervertex[8];
2746   ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2747   ymothervertex[11] = ymothervertex[10];
2748   ymothervertex[12] = ymothervertex[0];
2749   ymothervertex[13] = ymothervertex[12];
2750   ymothervertex[14] = ymothervertex[7];
2751   ymothervertex[15] = ymothervertex[14];
2752   ymothervertex[16] = ymothervertex[0];
2753   /////////////////////////////////////////////////////////////
2754   // First Mother Volume containing SSDFlex
2755   /////////////////////////////////////////////////////////////
2756   TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2757   ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2758                                                                     ymothervertex);
2759   ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2760   ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
2761   TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2762                                                                                          fSSDAir);
2763   /////////////////////////////////////////////////////////////
2764   // SSDFlex Layer Shapes
2765   /////////////////////////////////////////////////////////////
2766   for(Int_t i=0; i<kssdflexlayernumber; i++){
2767         ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2768                                                                    ymothervertex);
2769     ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2770         ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2771   }
2772   /////////////////////////////////////
2773   // Setting Layers into Mother Volume
2774   /////////////////////////////////////
2775   Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2776   TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2777                                                                                                  fSSDKaptonFlexMedium};
2778   const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2779                                                                                                         "AlFlexLay2","KaptonFlexLay2"};
2780   TGeoVolume* ssdflex[2*kssdflexlayernumber];
2781   TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2782   for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2783         ssdflex[i] = new TGeoVolume(ssdflexname[i],
2784                                                                 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2785                                                                 i%2==0 ? ssdflexmed[0]   : ssdflexmed[1]);
2786         ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2787     ssdflextrans[i]  = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2788                                          +                                         fgkSSDFlexHeight[1]));
2789     ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2790   }
2791   //ssdflexmother->CheckOverlaps(0.01);
2792   return ssdflexmother;
2793 }
2794 /////////////////////////////////////////////////////////////////////////////////
2795 TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
2796   /////////////////////////////////////////////////////////////
2797   // Method generating SSD End Flex
2798   /////////////////////////////////////////
2799   Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2800                                                         /  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2801   Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2802                                                 * TMath::DegToRad()*ssdflexradiusmax
2803                                                 - fgkSSDFlexLength[2]-TMath::Pi()
2804                                                 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
2805   const Int_t knedges = 20;
2806   const Int_t karcnumber = 2;
2807   TVector3* vertexposition[karcnumber*(knedges+1)];
2808   Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2809   Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2810   Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2811   Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2812                                                                                  - 90.0*TMath::DegToRad()};
2813   TVector3* referencetrans[karcnumber];
2814   referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2815                                         +                          radius[0]*SinD(2.*fgkSSDFlexAngle),
2816                                                                    radius[0]);
2817   referencetrans[1] = new TVector3(referencetrans[0]->X()
2818                                         +              fgkSSDFlexLength[2],
2819      -              fgkSSDStiffenerHeight);
2820 for(Int_t i=0; i<karcnumber; i++){
2821         for(Int_t j=0; j<knedges+1; j++){
2822                 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2823                                                                                                radius[i]*SinD(angle[i]));
2824                 angle[i] +=  deltangle[i]*(1.0-2.0*i);
2825         }
2826   }
2827   ///////////////////////
2828   // Setting the vertices
2829   ///////////////////////
2830   const Int_t kendflexlayernumber = 4;
2831   const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2832   TVector3** vertex[kendflexlayernumber];
2833   for(Int_t i=0; i<kendflexlayernumber; i++)
2834                                         vertex[i] = new TVector3*[kendflexvertexnumber];
2835   TVector3* transvector[kendflexlayernumber+1];
2836   TVector3* deltatransvector = new TVector3();
2837   for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2838   transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2839                                 +                radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2840   for(Int_t i=1; i<kendflexlayernumber+1; i++){
2841         deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2842                                         *                 CosD(fgkSSDFlexAngle),
2843                                                           (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2844                                         *         SinD(fgkSSDFlexAngle),0.0);
2845         *transvector[i] = *transvector[i-1]+*deltatransvector;
2846   }
2847   Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2848   ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2849   for(Int_t i=0; i<karcnumber; i++){
2850         for(Int_t j=1; j<kendflexlayernumber+1; j++){
2851                 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2852                                                   * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2853                                               /radius[i];
2854         }
2855   }
2856   for(Int_t i=0; i<kendflexlayernumber; i++){
2857         vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
2858         vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
2859         for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2860                 if(j<(knedges+1)){
2861                         vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2862                                                                                   vertexposition[j]->Y()*ratioradius[0][i+1]);
2863                         vertex[i][j+2]->RotateZ(referenceangle[0]);
2864                         *vertex[i][j+2] += *referencetrans[0];
2865                         vertex[i][4*(knedges+1)-j+1] =
2866                                                          new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2867                                                                                   vertexposition[j]->Y()*ratioradius[0][i]);
2868                         vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2869                         *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2870                 }
2871                 else{
2872
2873                         vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2874                                                                                   vertexposition[j]->Y()*ratioradius[1][i+1]);
2875                         vertex[i][j+2]->RotateZ(referenceangle[1]);
2876                         *vertex[i][j+2] += *referencetrans[1];
2877                         vertex[i][4*(knedges+1)-j+1] =
2878                                                          new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2879                                                                                   vertexposition[j]->Y()*ratioradius[1][i]);
2880                         vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2881                         *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2882            }
2883         }
2884   }
2885   /////////////////////////////////////////////////////////////
2886   // First Mother Volume containing SSDEndFlex
2887   /////////////////////////////////////////////////////////////
2888   TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2889   Double_t xmothervertex[kendflexvertexnumber];
2890   Double_t ymothervertex[kendflexvertexnumber];
2891   xmothervertex[0] = vertex[0][0]->X();
2892   ymothervertex[0] = vertex[0][0]->Y();
2893   for(Int_t i=1; i<kendflexvertexnumber; i++){
2894         if(i<2*(knedges+1)+2){
2895                 xmothervertex[i] = vertex[3][i]->X();
2896                 ymothervertex[i] = vertex[3][i]->Y();
2897         }
2898         else{
2899                 xmothervertex[i] = vertex[0][i]->X();
2900                 ymothervertex[i] = vertex[0][i]->Y();
2901         }
2902   }
2903   ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2904                                                                            xmothervertex,ymothervertex);
2905   ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2906   ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2907   TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2908                                                                  ssdendflexmothershape,fSSDAir);
2909   //////////////////////////////////////
2910   // End Flex TGeoXtru Layer Definition
2911   //////////////////////////////////////
2912   TGeoXtru* ssdendflexshape[kendflexlayernumber];
2913   TGeoVolume* ssdendflex[kendflexlayernumber];
2914   for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2915   Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2916   Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2917   Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2918   TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2919                                                                                                         fSSDKaptonFlexMedium};
2920   const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2921                                                                                                          "AlEndFlexLay2","KaptonEndFlexLay2"};
2922   for(Int_t i=0; i<kendflexlayernumber; i++){
2923         for(Int_t j=0; j<4*(knedges+1)+2; j++){
2924                 xvertex[i][j] = vertex[i][j]->X();
2925                 yvertex[i][j] = vertex[i][j]->Y();
2926         }
2927   ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2928   ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2929   ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2930   ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2931                                                                  i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2932   ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2933   ssdendflexmother->AddNode(ssdendflex[i],1);
2934   }
2935   /////////////////////////////////////////////////////////////
2936   // Deallocating memory
2937   /////////////////////////////////////////////////////////////
2938   for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2939   for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2940   for(Int_t i=0; i<kendflexlayernumber; i++){
2941         for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2942         delete [] vertex[i];
2943   }
2944   for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2945   delete deltatransvector;
2946   /////////////////////////////////////////////////////////////
2947   //ssdendflexmother->CheckOverlaps(0.01);
2948   return ssdendflexmother;
2949 }
2950 ///////////////////////////////////////////////////////////////////////////////
2951 TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
2952   /////////////////////////////////////////////////////////////
2953   // Method generating the Mounting Block
2954   /////////////////////////////////////////////////////////////
2955   const Int_t kvertexnumber = 8;
2956   Double_t xvertex[kvertexnumber];
2957   Double_t yvertex[kvertexnumber];
2958   xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2959   xvertex[1] = xvertex[0];
2960   xvertex[2] = -xvertex[0];
2961   xvertex[3] = xvertex[2];
2962   xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2963                          -                                 fgkSSDMountingBlockLength[2]);
2964   xvertex[5] = xvertex[4];
2965   xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2966                          - 0.5*fgkSSDMountingBlockScrewHoleEdge
2967                          -     fgkSSDMountingBlockScrewHoleRadius[0];
2968   xvertex[7] = xvertex[6];
2969   yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
2970                          +      fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
2971   yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2972   yvertex[2] = yvertex[1];
2973   yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2974   yvertex[4] = yvertex[3];
2975   yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2976                          - fgkSSDMountingBlockHeight[0];
2977   yvertex[6] = yvertex[5];
2978   yvertex[7] = yvertex[0];
2979   ///////////////////////////////////////////////////////////////////////
2980   // TGeoXTru Volume definition for Mounting Block Part
2981   ///////////////////////////////////////////////////////////////////////
2982   TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2983   ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2984   ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2985   ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
2986   TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
2987                                                                           ssdmountingblockshape,
2988                                                                                   fSSDMountingBlockMedium);
2989   ssdmountingblock->SetLineColor(fColorG10);
2990   TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
2991   mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
2992   TGeoRotation* mountingblockrot = new TGeoRotation();
2993   mountingblockrot->SetAngles(90.,180.,-90.);
2994   mountingblockcombitrans->SetRotation(*mountingblockrot);
2995   /////////////////////////////////////////////////////////////
2996   // Generating the Mounting Block Screw Vertices
2997   /////////////////////////////////////////////////////////////
2998   const Int_t kscrewvertexnumber = 15;
2999   Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
3000                                  -                                      fgkSSDMountingBlockScrewHoleEdge)
3001                                  /                              fgkSSDMountingBlockScrewHoleRadius[0])
3002                                  * TMath::RadToDeg();
3003   Double_t phi0 = 90.+alpha;
3004   Double_t phi = 270.-2*alpha;
3005   Double_t deltaphi = phi/kscrewvertexnumber;
3006   TVector3* screwvertex[kscrewvertexnumber+1];
3007   for(Int_t i=0; i<kscrewvertexnumber+1; i++)
3008         screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
3009                                    *CosD(phi0+i*deltaphi),
3010                                    fgkSSDMountingBlockScrewHoleRadius[0]
3011                                    *SinD(phi0+i*deltaphi));
3012   Double_t xscrewvertex[kscrewvertexnumber+6];
3013   Double_t yscrewvertex[kscrewvertexnumber+6];
3014   xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
3015   yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
3016                                   -               fgkSSDMountingBlockScrewHoleEdge);
3017   xscrewvertex[1] = xscrewvertex[0];
3018   yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3019   xscrewvertex[2] = screwvertex[0]->X();
3020   yscrewvertex[2] = yscrewvertex[1];
3021   for(Int_t i=0; i<kscrewvertexnumber+1; i++){
3022         xscrewvertex[i+3] = screwvertex[i]->X();
3023         yscrewvertex[i+3] = screwvertex[i]->Y();
3024   }
3025   xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3026   yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
3027   xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
3028   yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
3029   TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
3030   ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
3031   ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
3032   ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
3033                                                         +                                  fgkSSDMountingBlockHeight[2]);
3034   TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
3035                                                                                 ssdmountingblockscrewshape,
3036                                                                                             fSSDMountingBlockMedium);
3037   ssdmountingblockscrew->SetLineColor(fColorG10);
3038   TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
3039   for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
3040   ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3041                                                                         -                                yscrewvertex[1],
3042                                                                                                          0.5*fgkSSDMountingBlockHeight[0]
3043                                                                         -                                fgkSSDMountingBlockHeight[2]
3044                                                                         +                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3045                                                                         +                                fgkSSDMountingBlockHeight[2]
3046                                                                         -                                yvertex[0]));
3047   ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3048                                                                                                         -0.5*fgkSSDMountingBlockScrewHoleEdge,
3049                                                                                                                  yscrewvertex[1]
3050                                                                                                         -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3051                                                                                                          +fgkSSDMountingBlockHeight[2]
3052                                                                                                          -yvertex[0]));
3053   ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3054                                                                                                           yscrewvertex[1],
3055                                                                         -                                 0.5*fgkSSDMountingBlockHeight[0]
3056                                                                         +                                 fgkSSDMountingBlockHeight[2]
3057                                                                         -                                 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3058                                                                         +                                 fgkSSDMountingBlockHeight[2]
3059                                                                         -                                 yvertex[0]));
3060   ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3061                                                                                                          yscrewvertex[1],
3062                                                                         -                                yscrewvertex[1]
3063                                                                         +                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3064                                                                         +                                fgkSSDMountingBlockHeight[2]
3065                                                                         -                                yvertex[0]));
3066   TGeoRotation* ssdmountingblockscrewrot[4];
3067   for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
3068         ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
3069     ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
3070     ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
3071   for(Int_t i=1; i<4; i++)
3072         ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
3073   TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
3074   ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
3075   TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
3076   ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
3077                                                          +                                xvertex[0],yscrewvertex[1]
3078                                                          -                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3079                                                          +                                fgkSSDMountingBlockHeight[2]
3080                                                          -                                yvertex[0]),0.);
3081   TGeoHMatrix* ssdmountingblockscrewmatrix[4];
3082   for(Int_t i=0; i<4; i++){
3083         ssdmountingblockscrewmatrix[i] =
3084                 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
3085         ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
3086   }
3087   ///////////////////////////////////////////////////////////////////////
3088   // TGeoXtru for Mother Volume
3089   ///////////////////////////////////////////////////////////////////////
3090   const Int_t kvertexmothernumber = 12;
3091   Double_t xmothervertex[kvertexmothernumber];
3092   Double_t ymothervertex[kvertexmothernumber];
3093   for(Int_t i=0; i<6; i++){
3094         xmothervertex[i] = xvertex[i];
3095         ymothervertex[i] = yvertex[i];
3096   }
3097   xmothervertex[6]  = xvertex[5]+fgkSSDMountingBlockLength[2];
3098   ymothervertex[6]  = ymothervertex[5];
3099   xmothervertex[7]  = xmothervertex[6];
3100   ymothervertex[7]  = ymothervertex[4];
3101   xmothervertex[8]  = xmothervertex[7]
3102                                         + 0.5*(fgkSSDMountingBlockLength[1]
3103                                         -          fgkSSDMountingBlockLength[2]);
3104   ymothervertex[8]  = ymothervertex[4];
3105   xmothervertex[9]  = xmothervertex[8];
3106   ymothervertex[9]  = ymothervertex[2];
3107   xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
3108   ymothervertex[10] = ymothervertex[1];
3109   xmothervertex[11] = xmothervertex[10];
3110   ymothervertex[11] = ymothervertex[0];
3111   TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3112   ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3113   ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3114   ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3115   TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3116                                                                           ssdmountingblockmothershape,
3117                                                                                   fSSDAir);
3118   /////////////////////////////////////////////////////////////
3119   // Placing the Volumes into Mother Volume
3120   /////////////////////////////////////////////////////////////
3121   ssdmountingblockmother->AddNode(ssdmountingblock,1);
3122   ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3123   for(Int_t i=0; i<4; i++)
3124         ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3125                                                                         ssdmountingblockscrewmatrix[i]);
3126   /////////////////////////////////////////////////////////////
3127   // Deallocating memory
3128   /////////////////////////////////////////////////////////////
3129   delete mountingblockrot;
3130   for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3131   delete ssdmountingblockglobalrot;
3132   delete ssdmountingblockglobaltrans;
3133   /////////////////////////////////////////////////////////////
3134   return ssdmountingblockmother;
3135 }
3136 ///////////////////////////////////////////////////////////////////////////////
3137  TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3138   /////////////////////////////////////////////////////////////
3139   // Method generating the Mounting Block Clip
3140   /////////////////////////////////////////////////////////////
3141   const Int_t kmothervertexnumber = 10;
3142   Double_t xmothervertex[kmothervertexnumber];
3143   Double_t ymothervertex[kmothervertexnumber];
3144   xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3145                                    - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3146   xmothervertex[1] = xmothervertex[0];
3147   xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3148                                    - fgkMountingBlockClibScrewRadius);
3149   xmothervertex[3] = xmothervertex[2];
3150   xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3151   xmothervertex[5] = xmothervertex[4];
3152   xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3153   xmothervertex[7] = xmothervertex[6];
3154   xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3155   xmothervertex[9] = xmothervertex[8];
3156   ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
3157                          +      fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
3158   ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3159   ymothervertex[2] = ymothervertex[1];
3160   ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3161                                    - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3162                                    - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3163   ymothervertex[4] = ymothervertex[3];
3164   ymothervertex[5] = ymothervertex[2];
3165   ymothervertex[6] = ymothervertex[5];
3166   ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3167   ymothervertex[8] = ymothervertex[7];
3168   ymothervertex[9] = ymothervertex[0];
3169   ///////////////////////////////////////////////////////////////////////
3170   // TGeoXTru Volume definition for Mounting Block Clip Part
3171   ///////////////////////////////////////////////////////////////////////
3172   TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3173   ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3174   ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3175   ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3176   TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3177                                                                           ssdmountingblockclipshape,fSSDAir);
3178   ssdmountingblockclip->SetLineColor(4);
3179   ///////////////////////////////////////////////////////////////////////
3180   // TGeoXTru Volume definition for Clip
3181   ///////////////////////////////////////////////////////////////////////
3182   const Int_t kclipvertexnumber = 6;
3183   Double_t xclipvertex[kclipvertexnumber];
3184   Double_t yclipvertex[kclipvertexnumber];
3185   xclipvertex[0] = xmothervertex[0];
3186   xclipvertex[1] = xclipvertex[0];
3187   xclipvertex[2] = xmothervertex[6];
3188   xclipvertex[3] = xclipvertex[2];
3189   xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3190   xclipvertex[5] = xclipvertex[4];
3191   yclipvertex[0] = ymothervertex[0];
3192   yclipvertex[1] = ymothervertex[1];
3193   yclipvertex[2] = yclipvertex[1];
3194   yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3195   yclipvertex[4] = yclipvertex[3];
3196   yclipvertex[5] = yclipvertex[0];
3197   TGeoXtru* clipshape = new TGeoXtru(2);
3198   clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3199   clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3200   clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3201                                                          +   fgkMountingBlockClibWidth);
3202   TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3203   clip->SetLineColor(18);
3204   ///////////////////////////////////////////////////////////////////////
3205   // Ladder Support Piece
3206   ///////////////////////////////////////////////////////////////////////
3207   const Int_t ksupportvertexnumber = 4;
3208   Double_t xsupportvertex[ksupportvertexnumber];
3209   Double_t ysupportvertex[ksupportvertexnumber];
3210   xsupportvertex[0] = xclipvertex[5];
3211   xsupportvertex[1] = xsupportvertex[0];
3212   xsupportvertex[2] = xmothervertex[9];
3213   xsupportvertex[3] = xsupportvertex[2];
3214   ysupportvertex[0] = yclipvertex[0];
3215   ysupportvertex[1] = yclipvertex[3];
3216   ysupportvertex[2] = ysupportvertex[1];
3217   ysupportvertex[3] = ysupportvertex[0];
3218   TGeoXtru* supportshape = new TGeoXtru(2);
3219   supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3220   supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3221   supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3222   TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3223   support->SetLineColor(9);
3224   ///////////////////////////////////////////////////////////////////////
3225   // TGeoXTru Volume definition for Screw
3226   ///////////////////////////////////////////////////////////////////////
3227   Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3228                                                 0.5*fgkMountingBlockClibScrewRadius};
3229   Int_t edgesnumber[2] = {50,6};
3230   Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3231                                                  +0.5*(ymothervertex[3]-ymothervertex[2])};
3232   TGeoXtru* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
3233   TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3234   clipscrew->SetLineColor(12);
3235   TGeoRotation* screwrot = new TGeoRotation();
3236   screwrot->SetAngles(0.,90.,0.);
3237   TGeoTranslation* screwtrans = new TGeoTranslation();
3238   screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3239                                                          0.5*(ymothervertex[3]+ymothervertex[2]),
3240                                                          0.5*fgkSSDMountingBlockWidth+
3241                                                         -0.5*fgkMountingBlockSupportWidth[0]);
3242   TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3243   ///////////////////////////////////////////////////////////////////////
3244   // Placing the Volumes
3245   ///////////////////////////////////////////////////////////////////////
3246   ssdmountingblockclip->AddNode(clip,1);
3247   ssdmountingblockclip->AddNode(support,1);
3248   ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3249   /////////////////////////////////////////////////////////////
3250   // Deallocating memory
3251   /////////////////////////////////////////////////////////////
3252   delete screwtrans;
3253   delete screwrot;
3254   /////////////////////////////////////////////////////////////
3255   return ssdmountingblockclip;
3256 }
3257 ///////////////////////////////////////////////////////////////////////////////
3258 TList* AliITSv11GeometrySSD::GetCoolingTubeList()const{
3259   /////////////////////////////////////////////////////////////
3260   // Method generating the Cooling Tube
3261   /////////////////////////////////////////////////////////////
3262    TGeoTube** coolingtubeshape[fgkcoolingtubenumber];
3263    for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtubeshape[i] =
3264                                                                                                 new     TGeoTube*[2];
3265    // Ladder Cooling Tubes
3266    coolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3267                                           0.25 * (fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3268                                                   -     2.*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth));
3269    coolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3270                                                                                  coolingtubeshape[0][0]->GetDz());
3271    coolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3272                                                                                  0.5*(fgkSSDModuleStiffenerPosition[1]
3273                                                   -                                       fgkSSDSensorOverlap));
3274    coolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3275                                                                                  coolingtubeshape[1][0]->GetDz());
3276    coolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3277                                                                                  0.5*fgkSSDModuleStiffenerPosition[1]);
3278    coolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3279                                                                                  coolingtubeshape[2][0]->GetDz());
3280    // End Ladder Cooling Tubes
3281    TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3282    for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3283         endladdercoolingtubeshape[i] = new      TGeoTube*[2];
3284    endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3285                                                         0.50 * (fgkEndLadderMountingBlockPosition[0]
3286                                                   -                     fgkendladdercoolingsupportdistance[0]));
3287    endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3288                                                                         endladdercoolingtubeshape[0][0]->GetDz());
3289    endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3290                                                         0.50 * (fgkendladdercoolingsupportdistance[0]
3291                                                   +                     fgkendladdercoolingsupportdistance[1]
3292                                                   -                     fgkCoolingTubeSupportWidth));
3293    endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3294                                                                         endladdercoolingtubeshape[1][0]->GetDz());
3295    endladdercoolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3296                                                         0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
3297                                                   -                     fgkEndLadderMountingBlockPosition[0]
3298                                                   -                     fgkendladdercoolingsupportdistance[1]
3299                                                   -                     fgkCoolingTubeSupportWidth));
3300    endladdercoolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3301                                                                         endladdercoolingtubeshape[2][0]->GetDz());
3302    endladdercoolingtubeshape[3][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3303                                                           0.50 * (fgkMountingBlockToSensorSupport
3304                                                         - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
3305                                                         -                 fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
3306                                                         +                 fgkSSDSensorOverlap
3307                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
3308                                                         -                 fgkendladdercoolingsupportdistance[2]
3309                                                         -                 fgkEndLadderMountingBlockPosition[1]
3310                                                         -                 fgkCoolingTubeSupportWidth));
3311    endladdercoolingtubeshape[3][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3312                                                                         endladdercoolingtubeshape[3][0]->GetDz());
3313    endladdercoolingtubeshape[4][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3314                                                           0.50 * fgkendladdercoolingsupportdistance[2]);
3315    endladdercoolingtubeshape[4][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3316                                                                         endladdercoolingtubeshape[4][0]->GetDz());
3317    // Ladder Cooling Tubes
3318    TGeoVolume** coolingtube[fgkcoolingtubenumber];
3319    for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtube[i] =
3320                                                                                          new TGeoVolume*[2];
3321    coolingtube[0][0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0][0],
3322                                                                           fSSDCoolingTubePhynox);
3323    coolingtube[0][1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[0][1],
3324                                                                           fSSDCoolingTubeWater);
3325    coolingtube[1][0] = new TGeoVolume("OuterCoolingTube2",coolingtubeshape[1][0],
3326                                                                           fSSDCoolingTubePhynox);
3327    coolingtube[1][1] = new TGeoVolume("InnerCoolingTube2",coolingtubeshape[1][1],
3328                                                                           fSSDCoolingTubeWater);
3329    coolingtube[2][0] = new TGeoVolume("OuterCoolingTube3",coolingtubeshape[2][0],
3330                                                                           fSSDCoolingTubePhynox);
3331    coolingtube[2][1] = new TGeoVolume("InnerCoolingTube3",coolingtubeshape[2][1],
3332                                                                           fSSDCoolingTubeWater);
3333    for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3334         coolingtube[i][0]->SetLineColor(fColorPhynox);
3335         coolingtube[i][1]->SetLineColor(fColorWater);
3336    }
3337    // End Ladder Cooling Tubes
3338    TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3339    for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3340    endladdercoolingtube[i] = new TGeoVolume*[2];
3341    endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3342                                                                 endladdercoolingtubeshape[0][0],
3343                                                                 fSSDCoolingTubePhynox);
3344    endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3345                                                                 endladdercoolingtubeshape[0][1],
3346                                                                 fSSDCoolingTubeWater);
3347    endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3348                                                                 endladdercoolingtubeshape[1][0],
3349                                                                 fSSDCoolingTubePhynox);
3350    endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3351                                                                 endladdercoolingtubeshape[1][1],
3352                                                                 fSSDCoolingTubeWater);
3353    endladdercoolingtube[2][0] = new TGeoVolume("OuterEndLadderCoolingTube3",
3354                                                                 endladdercoolingtubeshape[2][0],
3355                                                                 fSSDCoolingTubePhynox);
3356    endladdercoolingtube[2][1] = new TGeoVolume("InnerEndlLadderCoolingTube3",
3357                                                                 endladdercoolingtubeshape[2][1],
3358                                                                 fSSDCoolingTubeWater);
3359    endladdercoolingtube[3][0] = new TGeoVolume("OuterEndLadderCoolingTube4",
3360                                                                 endladdercoolingtubeshape[3][0],
3361                                                                 fSSDCoolingTubePhynox);
3362    endladdercoolingtube[3][1] = new TGeoVolume("InnerEndlLadderCoolingTube4",
3363                                                                 endladdercoolingtubeshape[3][1],
3364                                                                 fSSDCoolingTubeWater);
3365    endladdercoolingtube[4][0] = new TGeoVolume("OuterEndLadderCoolingTube5",
3366                                                                 endladdercoolingtubeshape[4][0],
3367                                                                 fSSDCoolingTubePhynox);
3368    endladdercoolingtube[4][1] = new TGeoVolume("InnerEndlLadderCoolingTube5",
3369                                                                 endladdercoolingtubeshape[4][1],
3370                                                                 fSSDCoolingTubeWater);
3371    for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3372         endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3373         endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3374    }
3375   /////////////////////////////////////////////////////////////
3376   // Virtual Volume containing Cooling Tubes
3377   /////////////////////////////////////////////////////////////
3378   // Ladder Cooling Tubes
3379   TGeoTube* virtualcoolingtubeshape[fgkcoolingtubenumber];
3380   for(Int_t i=0; i<fgkcoolingtubenumber; i++)
3381   virtualcoolingtubeshape[i] = new TGeoTube(coolingtubeshape[i][1]->GetRmin(),
3382                                                                                         coolingtubeshape[i][0]->GetRmax(),
3383                                                                                         coolingtubeshape[i][0]->GetDz());
3384   TGeoVolume* virtualcoolingtube[fgkcoolingtubenumber];
3385   virtualcoolingtube[0] = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape[0],
3386                                                                           fSSDAir);
3387   virtualcoolingtube[1] = new TGeoVolume("CoolingTube2",virtualcoolingtubeshape[1],
3388                                                                           fSSDAir);
3389   virtualcoolingtube[2] = new TGeoVolume("CoolingTube3",virtualcoolingtubeshape[2],
3390                                                                           fSSDAir);
3391   // End Ladder Cooling Tubes
3392   TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3393   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3394   endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3395                                                                                         endladdercoolingtubeshape[i][0]->GetRmax(),
3396                                                                                         endladdercoolingtubeshape[i][0]->GetDz());
3397   TGeoVolume* endladdervirtualcoolingtube[fgkendladdercoolingtubenumber];
3398   endladdervirtualcoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3399                                                                           endladdervirtualcoolingtubeshape[0],
3400                                                                           fSSDAir);
3401   endladdervirtualcoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3402                                                                           endladdervirtualcoolingtubeshape[1],
3403                                                                           fSSDAir);
3404   endladdervirtualcoolingtube[2] = new TGeoVolume("EndLadderCoolingTube3",
3405                                                                           endladdervirtualcoolingtubeshape[2],
3406                                                                           fSSDAir);
3407   endladdervirtualcoolingtube[3] = new TGeoVolume("EndLadderCoolingTube4",
3408                                                                           endladdervirtualcoolingtubeshape[3],
3409                                                                           fSSDAir);
3410   endladdervirtualcoolingtube[4] = new TGeoVolume("EndLadderCoolingTube5",
3411                                                                           endladdervirtualcoolingtubeshape[4],
3412                                                                           fSSDAir);
3413   TList* coolingtubelist = new TList();
3414   for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3415         virtualcoolingtube[i]->AddNode(coolingtube[i][0],1);
3416         virtualcoolingtube[i]->AddNode(coolingtube[i][1],1);
3417     coolingtubelist->Add(virtualcoolingtube[i]);
3418   }
3419         endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3420         endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3421     coolingtubelist->Add(endladdervirtualcoolingtube[0]);
3422         endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3423         endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
3424     coolingtubelist->Add(endladdervirtualcoolingtube[1]);
3425         endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][0],1);
3426         endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][1],1);
3427     coolingtubelist->Add(endladdervirtualcoolingtube[2]);
3428         endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][0],1);
3429         endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][1],1);
3430     coolingtubelist->Add(endladdervirtualcoolingtube[3]);
3431         endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][0],1);
3432         endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][1],1);
3433     coolingtubelist->Add(endladdervirtualcoolingtube[4]);
3434   return coolingtubelist;
3435 }
3436 ///////////////////////////////////////////////////////////////////////////////
3437 TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
3438   /////////////////////////////////////////////////////////////
3439   // Method generating SSD Cooling Block
3440   /////////////////////////////////////////////////////////////
3441   const Int_t kvertexnumber = 8;
3442   ///////////////////////////////////////
3443   // Vertex Positioning for TGeoXTru
3444   ///////////////////////////////////////
3445   TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3446   vertexposition[0] = new TVector3(0.0,0.0);
3447   vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]);
3448   vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3449                                           vertexposition[1]->Y());
3450   vertexposition[3] = new TVector3(vertexposition[2]->X(),
3451                                           vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]);
3452   vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y());
3453   vertexposition[5] = new TVector3(vertexposition[4]->X(),
3454                                         + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]);
3455   vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3456                                           vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3457                                         - fgkSSDCoolingBlockHoleLength[0]
3458                                         - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3459                                           fgkSSDCoolingBlockHeight[0]
3460                                         - fgkSSDCoolingBlockHoleRadius[1],
3461                                           fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]);
3462   vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3463                                         - fgkSSDCoolingBlockHoleLength[0]),
3464                                           vertexposition[6]->Y());
3465   Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3466                            / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3467   Double_t phi = 180.-alpha;
3468   Double_t psi = 180.+2.*alpha;
3469   Double_t deltapsi = psi/nedges;
3470   Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3471   TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3472                                                   fgkSSDCoolingBlockHoleCenter);
3473   for(Int_t i=0; i<nedges+1; i++){
3474         vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3475                                                                                                radius*SinD(phi+i*deltapsi));
3476    *vertexposition[kvertexnumber+i] += (*transvector);
3477   }
3478   Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3479   for(Int_t i=0; i<kvertexnumber; i++)
3480     vertexposition[kvertexnumber+nedges+1+i] =
3481                                                 GetReflection(vertexposition[kvertexnumber-1-i],param);
3482   ///////////////////////////////////////////////////////////////////////
3483   // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3484   ///////////////////////////////////////////////////////////////////////
3485   TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3486   Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3487   Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3488   for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3489         xvertexpoints[i] = vertexposition[i]->X();
3490         yvertexpoints[i] = vertexposition[i]->Y();
3491   }
3492   ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3493                                                                                         yvertexpoints);
3494   ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3495   ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3496   TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3497                                                                           ssdcoolingblockshape,
3498                                                                                   fSSDAlCoolBlockMedium);
3499   ssdcoolingblock->SetLineColor(fColorAl);
3500   /////////////////////////////////////////////////////////////
3501   // Deallocating memory
3502   /////////////////////////////////////////////////////////////
3503   delete [] vertexposition;
3504   delete xvertexpoints;
3505   delete yvertexpoints;
3506   /////////////////////////////////////////////////////////////
3507   return ssdcoolingblock;
3508 }
3509 /////////////////////////////////////////////////////////////////////////////////
3510 TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, Int_t nedges){
3511   ///////////////////////////////////////////////////////
3512   const Int_t kssdchipcablesnumber    = 2;
3513   const Int_t kssdchipcableslaynumber = 2;
3514   const Int_t kvertexnumber                       = 4*(nedges+1)+4;
3515   Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3516   Double_t ssdchipcablesradius[kssdchipcableslaynumber];
3517   ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeigth
3518                                                  -  fgkSSDChipCablesHeight[0]
3519                                                  -  fgkSSDChipCablesHeight[1]);
3520   ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3521   Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3522   ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3523                                                           - 2.*TMath::Pi()*ssdchipcablesradius[0]
3524                                                           - ssdchipcablesradius[0]
3525                                                           - fgkSSDChipCablesWidth[1]
3526                                                           - fgkSSDChipCablesWidth[2]);
3527   ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3528                                                           - 0.5*(fgkSSDModuleStiffenerPosition[1]
3529                                                           +      fgkSSDChipCablesHeight[1]
3530                                                           +      fgkSSDSensorHeight);
3531   ///////////////////////////////////////////////////////
3532   // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3533   ///////////////////////////////////////////////////////
3534   TVector3** vertexposition[kssdchipcableslaynumber];
3535   for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3536                                                                                                   new TVector3*[4*(nedges+1)+4];
3537   Double_t ratio[4];
3538   ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3539   ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3540                    /  ssdchipcablesradius[0];
3541   ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3542                    /  ssdchipcablesradius[0];
3543   ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3544                    +  fgkSSDChipCablesHeight[1])
3545                    /  ssdchipcablesradius[0];
3546   Double_t phi = 180.;
3547   Double_t deltaphi = 180./nedges;
3548   Double_t angle = 0.0;
3549   Double_t **xvertexpoints = new Double_t*[kssdchipcableslaynumber];
3550   Double_t **yvertexpoints = new Double_t*[kssdchipcableslaynumber];
3551   for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3552         xvertexpoints[i] = new Double_t[kvertexnumber];
3553         yvertexpoints[i] = new Double_t[kvertexnumber];
3554   }
3555   TVector3* vertex = new TVector3();
3556   TVector3* transvector[kssdchipcableslaynumber];
3557   transvector[0] = new TVector3(fgkSSDChipWidth,
3558                                                                 SSDChipCablesHeigth-ssdchipcablesradius[0]);
3559   transvector[1] = new TVector3();
3560   TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcableslaynumber];
3561   TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcableslaynumber];
3562   const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcableslaynumber] =
3563                 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3564                  "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3565   for(Int_t k=0; k<kssdchipcablesnumber; k++){
3566         transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3567         transvector[1]->SetY(ssdchipcablesradius[0]
3568                                  +               fgkSSDChipCablesHeight[0]
3569                                  +               fgkSSDChipCablesHeight[1]);
3570         for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3571                 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeigth
3572                                                          - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
3573                 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeigth
3574                                                          - i*fgkSSDChipCablesHeight[0]);
3575                 vertexposition[i][2*(nedges+1)+2] =
3576                                         new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3577                                 +                                fgkSSDChipCablesWidth[1]
3578                                 +                                fgkSSDChipCablesWidth[2],
3579                                                                 ((1.-i)*fgkSSDChipCablesHeight[i]
3580                                 +                                fgkSSDChipCablesHeight[1]));
3581         vertexposition[i][2*(nedges+1)+3] =
3582                                         new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3583                                                                  vertexposition[i][2*(nedges+1)+2]->Y()
3584                                 -                                fgkSSDChipCablesHeight[i]);
3585             for(Int_t j=0; j<nedges+1; j++){
3586                     angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3587                         vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3588                         vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3589                         vertexposition[0][(nedges+1)*i+j+2] =
3590                                                 new TVector3(*vertex+*transvector[i]);
3591                         vertexposition[1][(nedges+1)*i+j+2] =
3592                                                 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3593                                                                          vertex->Y()*ratio[2*i]+transvector[i]->Y());
3594                         vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3595                                                 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3596                         vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3597                                                 new TVector3(vertex->X()*ratio[2*i+1]
3598                                                         +                        transvector[i]->X(),
3599                                                                                  vertex->Y()*ratio[2*i+1]
3600                                                         +                transvector[i]->Y());
3601                 }
3602         }
3603         for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3604                 for(Int_t j=0; j<kvertexnumber; j++){
3605                         xvertexpoints[i][j] = vertexposition[i][j]->X();
3606                         yvertexpoints[i][j] = vertexposition[i][j]->Y();
3607                 }
3608                 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3609                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3610                                                                                 xvertexpoints[i],yvertexpoints[i]);
3611                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3612                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3613                 ssdchipcable[kssdchipcablesnumber*k+i] =
3614                                 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3615                                                            ssdchipcableshape[kssdchipcablesnumber*k+i],
3616                                                           (kssdchipcablesnumber*k+i)%2==0?
3617                                                            fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3618                 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3619         }
3620         for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3621                 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3622   }
3623   /////////////////////////////////////////////////////////////
3624   // Mother Volume definition
3625   /////////////////////////////////////////////////////////////
3626   Double_t ssdchipseparation = fgkSSDSensorLength
3627                                                          - 2.*fgkSSDModuleStiffenerPosition[1]
3628                                                          - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3629                                                          - 0.5*fgkSSDChipWidth)-fgkSSDChipWidth;
3630   Double_t boxorigin[3] = {-0.5*ssdchipseparation,0.,0.5*SSDChipCablesHeigth};
3631   Double_t dx = ssdchipseparation+2.*(fgkSSDChipWidth+ssdchipcablesradius[0]
3632                                                           +fgkSSDChipCablesWidth[1]
3633                                                           +fgkSSDChipCablesWidth[2]);
3634   Double_t dy = fgkSSDChipCablesLength[1];
3635   Double_t dz = SSDChipCablesHeigth;
3636   TGeoBBox* ssdchipcablesmotherbox = new TGeoBBox(0.5*dx,0.5*dy,0.5*dz,boxorigin);
3637   TGeoVolume* ssdchipcablesmother = new TGeoVolume("SSDChipCablesMother",
3638                           ssdchipcablesmotherbox,fSSDAir);
3639   /////////////////////////////////////////////////////////////
3640   // Rotation and Translation Definition for positioning
3641   /////////////////////////////////////////////////////////////
3642   TGeoRotation* ssdchipcablesrot[5];
3643   ssdchipcablesrot[0] = new TGeoRotation("",90.,180.,-90);
3644   ssdchipcablesrot[1] = new TGeoRotation("",0.0,90.0,0.0);
3645   ssdchipcablesrot[2] = new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0]));
3646   ssdchipcablesrot[3] = new TGeoRotation("",180.,0.0,0.0);
3647   ssdchipcablesrot[4] = new TGeoRotation((*ssdchipcablesrot[3])*(*ssdchipcablesrot[2]));
3648   TGeoCombiTrans* ssdchipcablescombitrans = new TGeoCombiTrans(-ssdchipseparation,
3649                                                                                                                 0.,0.,ssdchipcablesrot[2]);
3650   ssdchipcablesmother->AddNode(ssdchipcable[0],1,ssdchipcablesrot[4]);
3651   ssdchipcablesmother->AddNode(ssdchipcable[1],1,ssdchipcablesrot[4]);
3652   ssdchipcablesmother->AddNode(ssdchipcable[2],1,ssdchipcablescombitrans);
3653   ssdchipcablesmother->AddNode(ssdchipcable[3],1,ssdchipcablescombitrans);
3654   /////////////////////////////////////////////////////////////
3655   // Deallocating memory
3656   /////////////////////////////////////////////////////////////
3657   for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3658         delete [] xvertexpoints[i];
3659         delete [] yvertexpoints[i];
3660   }
3661   for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3662   for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3663   delete vertex;
3664   delete ssdchipcablesrot[0];
3665   delete ssdchipcablesrot[1];
3666   delete ssdchipcablesrot[3];
3667   /////////////////////////////////////////////////////////////
3668   return ssdchipcablesmother;
3669 }
3670 ///////////////////////////////////////////////////////////////////////////////
3671 TList* AliITSv11GeometrySSD::GetSSDChipSystem(){
3672   /////////////////////////////////////////////////////////////
3673   // SSD Chip Assembly
3674   /////////////////////////////////////////////////////////////
3675   TGeoVolume* ssdchipassembly = GetSSDChips();
3676   TList* ssdchipsystemlist = new TList();
3677   const Int_t knedges = 20;
3678   const Int_t kchipsystemnumber = 2;
3679   /////////////////////////////////////////////////////////////
3680   // Mother Volume containing SSDChipSystem
3681   /////////////////////////////////////////////////////////////
3682   TGeoXtru* chipsystemothershape[kchipsystemnumber];
3683   for(Int_t i=0; i<kchipsystemnumber; i++) chipsystemothershape[i] = new TGeoXtru(2);
3684   const Int_t kmothervertexnumber = 12;
3685   Double_t xmothervertex[kchipsystemnumber][kmothervertexnumber];
3686   Double_t ymothervertex[kchipsystemnumber][kmothervertexnumber];
3687   Double_t ssdchipcablesradius[kchipsystemnumber];
3688   Double_t ssdchipseparation = fgkSSDSensorLength
3689                              - 2.*fgkSSDModuleStiffenerPosition[1]
3690                              - 2.*(fgkSSDStiffenerWidth
3691                              - fgkSSDStiffenerToChipDist-0.5*fgkSSDChipWidth);
3692   for(Int_t i=0; i<kchipsystemnumber; i++)
3693         ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
3694                                                    -  fgkSSDChipCablesHeight[0]
3695                                                    -  fgkSSDChipCablesHeight[1]);
3696   ///////////////////////
3697   // Setting the vertices
3698   ///////////////////////
3699   xmothervertex[0][0]  = -0.5*fgkSSDChipCablesLength[1];
3700   xmothervertex[0][1]  = xmothervertex[0][0];
3701   xmothervertex[0][2]  = (fgkSSDChipNumber-1)*(fgkSSDChipLength
3702                                            + fgkSSDChipSeparationLength)+0.5*fgkSSDChipCablesLength[1];
3703   xmothervertex[0][3]  = xmothervertex[0][2];
3704   xmothervertex[0][4]  = 0.5*fgkSSDChipCablesLength[1];
3705   xmothervertex[0][5]  = xmothervertex[0][4];
3706   xmothervertex[0][6]  = xmothervertex[0][2]-0.5*fgkSSDChipCablesLength[1];
3707   xmothervertex[0][7]  = xmothervertex[0][6];
3708   xmothervertex[0][8]  = 0.0;
3709   xmothervertex[0][9]  = xmothervertex[0][8];
3710   xmothervertex[0][10] = xmothervertex[0][4];
3711   xmothervertex[0][11] = xmothervertex[0][10];
3712   for(Int_t i=0; i<kmothervertexnumber; i++)
3713         xmothervertex[1][i] = xmothervertex[0][i];
3714   for(Int_t i=0; i<kchipsystemnumber; i++){
3715         ymothervertex[i][0]  = -0.5*fgkSSDChipWidth-ssdchipcablesradius[i]
3716                                                  - fgkSSDChipCablesWidth[1]-fgkSSDChipCablesWidth[2];
3717         ymothervertex[i][1]  = ssdchipseparation-ymothervertex[i][0];
3718         ymothervertex[i][2]  = ymothervertex[i][1];
3719         ymothervertex[i][3]  = ymothervertex[i][0];
3720         ymothervertex[i][4]  = ymothervertex[i][0];
3721         ymothervertex[i][5]  = 0.5*fgkSSDChipWidth;
3722         ymothervertex[i][6]  = ymothervertex[i][5];
3723         ymothervertex[i][7]  = ssdchipseparation-0.5*fgkSSDChipWidth;
3724         ymothervertex[i][8]  = ymothervertex[i][7];
3725         ymothervertex[i][9]  = ymothervertex[i][5];
3726         ymothervertex[i][10] = ymothervertex[i][5];
3727         ymothervertex[i][11] = ymothervertex[i][4];
3728   }
3729   //////////////////////////////////////////////////////////
3730   TGeoVolume* chipsystemother[kchipsystemnumber];
3731   const char* chipsytemothername[kchipsystemnumber] =
3732                                         {"SSDChipSytemother1","SSDChipSytemother2"};
3733   for(Int_t i=0; i<kchipsystemnumber; i++){
3734     chipsystemothershape[i]->DefinePolygon(kmothervertexnumber,
3735                                                                         xmothervertex[i],ymothervertex[i]);
3736     chipsystemothershape[i]->DefineSection(0,-fgkSSDChipCablesHeight[i+2]
3737                                                                                   -0.5*fgkSSDChipHeight);
3738     chipsystemothershape[i]->DefineSection(1,0.5*fgkSSDChipHeight);
3739     chipsystemother[i] = new TGeoVolume(chipsytemothername[i],
3740                                                           chipsystemothershape[i],fSSDAir);
3741   }
3742   /////////////////////////////////////////////////////////////
3743   // SSD Chip Cables
3744   /////////////////////////////////////////////////////////////
3745   TGeoVolume* ssdchipcables[kchipsystemnumber];
3746   TGeoRotation** ssdchipcablesrot[kchipsystemnumber];
3747   TGeoTranslation** ssdchipcablestrans[kchipsystemnumber];
3748   TGeoCombiTrans** ssdchipcablescombitrans[kchipsystemnumber];
3749   //////////////////
3750   for(Int_t i=0; i<kchipsystemnumber; i++){
3751                 ssdchipcables[i] =
3752                 GetSSDChipCables(fgkSSDChipCablesHeight[i+2],knedges);
3753                 ssdchipcablestrans[i] = new TGeoTranslation*[fgkSSDChipNumber];
3754                 ssdchipcablesrot[i] = new TGeoRotation*[fgkSSDChipNumber];
3755                 ssdchipcablescombitrans[i] = new TGeoCombiTrans*[fgkSSDChipNumber];
3756   }
3757   for(Int_t i=0; i<kchipsystemnumber; i++){
3758         for(Int_t j=0; j<fgkSSDChipNumber; j++){
3759                 ssdchipcablestrans[i][j] = new TGeoTranslation();
3760                 ssdchipcablesrot[i][j] = new TGeoRotation();
3761                 ssdchipcablescombitrans[i][j] = new TGeoCombiTrans();
3762                 ssdchipcablesrot[i][j]->SetAngles(-90.0,0.0,0.0);
3763                 ssdchipcablestrans[i][j]->SetTranslation(j*(fgkSSDChipLength
3764                                                   +                fgkSSDChipSeparationLength),
3765                                                                                         0.5*fgkSSDChipWidth,
3766                                                   -                                     0.5*fgkSSDChipHeight
3767                                                   -                                     fgkSSDChipCablesHeight[i+2]);
3768                 ssdchipcablescombitrans[i][j]->SetRotation(*ssdchipcablesrot[i][j]);
3769                 ssdchipcablescombitrans[i][j]->SetTranslation(*ssdchipcablestrans[i][j]);
3770                 chipsystemother[i]->AddNode(ssdchipcables[i],j+1,ssdchipcablescombitrans[i][j]);
3771
3772         }
3773         chipsystemother[i]->AddNode(ssdchipassembly,i+1);
3774         ssdchipsystemlist->Add(chipsystemother[i]);
3775   }
3776   /////////////////////////////////////////////////////////////
3777   // Deallocating memory
3778   /////////////////////////////////////////////////////////////
3779   for(Int_t i=0; i<kchipsystemnumber; i++){
3780         for(Int_t j=0; j<fgkSSDChipNumber; j++){
3781                 delete ssdchipcablesrot[i][j];
3782                 delete ssdchipcablestrans[i][j];
3783         }
3784         delete ssdchipcablesrot[i];
3785         delete ssdchipcablestrans[i];
3786   }
3787   /////////////////////////////////////////////////////////////
3788   return ssdchipsystemlist;
3789 }
3790 ///////////////////////////////////////////////////////////////////////////////
3791 TGeoVolume* AliITSv11GeometrySSD::GetSSDChips() const{
3792   /////////////////////////////////////////////////////////////
3793   // SSD Chip Assembly Generation
3794   /////////////////////////////////////////////////////////////
3795   const Int_t kssdchiprownumber = 2;
3796   TGeoBBox* ssdchipcompshape[2];
3797   ssdchipcompshape[0] =  new TGeoBBox("SSDChipCompShape",
3798                                                                                 0.5*fgkSSDChipLength,
3799                                                                                 0.5*fgkSSDChipWidth,
3800                                                                                 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3801   ssdchipcompshape[1] =  new TGeoBBox("SSDChipGlueCompShape",
3802                                                                                 0.5*fgkSSDChipLength,
3803                                                                                 0.5*fgkSSDChipWidth,
3804                                                                                 0.5*fgkSSDChipGlueHeight);
3805   TGeoVolume* ssdchipcomp[2];
3806   ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3807   ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3808                                                                   fSSDChipGlueMedium);
3809   ssdchipcomp[0]->SetLineColor(fColorSilicon);
3810   ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3811   TGeoTranslation* ssdchipcomptrans[2];
3812   ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3813   ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3814   /////////////////////////////////////////////////////////////
3815   // Virtual Volume containing SSDChip
3816   /////////////////////////////////////////////////////////////
3817   TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3818                                                                                                                  0.5*fgkSSDChipWidth,
3819                                                                                                                  0.5*fgkSSDChipHeight);
3820   TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
3821   /////////////////////////////////////////////////////////////
3822   for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3823   Double_t ssdchipseparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength,
3824                                                   fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3825                                    -  2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3826                                    -  0.5*fgkSSDChipWidth)};
3827   /////////////////////////////////////////////////////////////
3828   // Virtual Volume containing SSDChipAssembly
3829   /////////////////////////////////////////////////////////////
3830   TGeoXtru* ssdchipmothershape = new TGeoXtru(2);
3831   const Int_t kssdmothervertexnumber = 2*fgkSSDChipNumber;
3832   Double_t xmothervertex[kssdmothervertexnumber];
3833   Double_t ymothervertex[kssdmothervertexnumber];
3834   ///////////////////////
3835   // Setting the vertices
3836   ///////////////////////
3837   xmothervertex[0] = -0.5*fgkSSDChipLength,ymothervertex[0] = -0.5*fgkSSDChipWidth;
3838   xmothervertex[1] = xmothervertex[0], ymothervertex[1] = ssdchipseparation[1]
3839                                    - ymothervertex[0];
3840   xmothervertex[2] = (fgkSSDChipNumber-1)*ssdchipseparation[0]-xmothervertex[0];
3841   ymothervertex[2] = ymothervertex[1];
3842   xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
3843   xmothervertex[4] = ssdchipseparation[0]+xmothervertex[0];
3844   ymothervertex[4] = ymothervertex[0];
3845   xmothervertex[5] = xmothervertex[4], ymothervertex[5] = -ymothervertex[4];
3846   xmothervertex[6] = (fgkSSDChipNumber-1)*ssdchipseparation[0]
3847                                    + (0.5*fgkSSDChipLength-fgkSSDChipWidth);
3848   ymothervertex[6] = ymothervertex[5];
3849   xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
3850                                    - fgkSSDChipWidth;
3851   xmothervertex[8] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3852   ymothervertex[8] = ymothervertex[7];
3853   xmothervertex[9] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3854   ymothervertex[9] = ymothervertex[6];
3855   xmothervertex[10] = -xmothervertex[0], ymothervertex[10] = ymothervertex[9];
3856   xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[0];
3857   //////////////////////////////////////////////////////////
3858   ssdchipmothershape->DefinePolygon(kssdmothervertexnumber,
3859                                                                         xmothervertex,ymothervertex);
3860   ssdchipmothershape->DefineSection(0,-0.5*fgkSSDChipHeight);
3861   ssdchipmothershape->DefineSection(1, 0.5*fgkSSDChipHeight);
3862   TGeoVolume* ssdchipmother = new TGeoVolume("SSDChipContainer",
3863                                                           ssdchipmothershape,fSSDAir);
3864    /////////////////////////////////////////////////////////////
3865   for(Int_t i=0; i<kssdchiprownumber; i++)
3866     for(Int_t j=0; j<fgkSSDChipNumber; j++)
3867                 ssdchipmother->AddNode(ssdchip,fgkSSDChipNumber*i+j+1,
3868                 new TGeoTranslation(j*ssdchipseparation[0],i*ssdchipseparation[1],0.));
3869   return ssdchipmother;
3870 }
3871 /////////////////////////////////////////////////////////////////////////////////
3872 TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
3873   /////////////////////////////////////////////////////////////
3874   // Method returning a List containing pointers to Ladder Cable Volumes
3875   /////////////////////////////////////////////////////////////
3876   const Int_t kladdercablesegmentnumber = 2;
3877   /////////////////////////////////////////
3878   // LadderSegmentBBox Volume
3879   /////////////////////////////////////////
3880   TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber];
3881   const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3882                                 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
3883   for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3884                                                   new TGeoBBox(laddercablesegmentbboxshapename[i],
3885                                                                            0.5*fgkSSDFlexWidth[0],
3886                                                                            0.5*fgkSSDLadderCableWidth,
3887                                                                            0.5*fgkSSDFlexHeight[i]);
3888   const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3889                                                   {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3890   TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3891   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3892                         laddercablesegmentbbox[i] =
3893                                                   new TGeoVolume(laddercablesegmentbboxname[i],
3894                                                                                  laddercablesegmentbboxshape[i],
3895                                                                                  (i==0?fSSDAlTraceLadderCableMedium:
3896             fSSDKaptonLadderCableMedium));
3897                         laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3898                                                                                                                    fColorPolyhamide);
3899   }
3900   TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber];
3901   laddercablesegmentbboxtrans[0] =
3902                                                    new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3903                                                                                            0.5*fgkSSDFlexWidth[0],
3904                                                                                            0.5*fgkSSDLadderCableWidth,
3905                                                                                            0.5*fgkSSDFlexHeight[0]);
3906   laddercablesegmentbboxtrans[1] =
3907                                                    new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3908                                                                                            0.5*fgkSSDFlexWidth[0],
3909                                                                                            0.5*fgkSSDLadderCableWidth,
3910                                                                                            fgkSSDFlexHeight[0]
3911                                                                                            +0.5*fgkSSDFlexHeight[1]);
3912   TGeoVolume* laddercablesegmentbboxassembly =
3913                                                    new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly");
3914   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3915                 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3916                                                                                             laddercablesegmentbboxtrans[i]);
3917 /////////////////////////////////////////
3918 // LadderSegmentArb8 Volume
3919 /////////////////////////////////////////
3920   const Int_t kvertexnumber = 4;
3921   TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3922   for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3923                                                                                                   new TVector3*[kvertexnumber];
3924 //Shape Vertex Positioning
3925   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3926         laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
3927         laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3928                                                                                                                   i*fgkSSDFlexHeight[0]);
3929         laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3930                                                                                    +                         fgkSSDFlexHeight[1]
3931                                                                                    +                      i*fgkSSDFlexHeight[0]);
3932         laddercablesegmentvertexposition[i][3] =
3933                                                    new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3934                                                                                 laddercablesegmentvertexposition[i][2]->Y());
3935   }
3936   Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3937                                                                             {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
3938   char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
3939                                         {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
3940   TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3941   for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3942                                         GetArbShape(laddercablesegmentvertexposition[i],
3943                                                                 laddercablesegmentwidth[i],
3944                                                                 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3945                                                                 laddercablesegmentarbshapename[i]);
3946   const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3947                                                   {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
3948   TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3949   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3950                          laddercablesegmentarb[i] =
3951                                                    new TGeoVolume(laddercablesegmentarbname[i],
3952                                                                                   laddercablesegmentarbshape[i],
3953                                                                                   (i==0?fSSDAlTraceLadderCableMedium:
3954             fSSDKaptonLadderCableMedium));
3955                          laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3956                                                                                                                    fColorPolyhamide);
3957 }
3958   TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3959   laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3960                                                                                                  90.,90,-90.);
3961   laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3962                                                                                                   0.,90.,0.);
3963   TGeoCombiTrans* laddercablesegmentarbcombitrans =
3964                                                    new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3965                                                            0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3966                                                          + fgkSSDFlexWidth[0],0.,0.,
3967                                                    new TGeoRotation((*laddercablesegmentarbrot[1])
3968                                                      *(*laddercablesegmentarbrot[0])));
3969   TGeoVolume* laddercablesegmentarbassembly =
3970                                                    new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3971   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3972   laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3973                                                                                    laddercablesegmentarbcombitrans);
3974 /////////////////////////////////////////
3975 // End Ladder Cable Volume
3976 /////////////////////////////////////////
3977   TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3978   const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3979                                 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3980   for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3981                                                   new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3982                                                                            0.5*ssdendladdercablelength,
3983                                                                            0.5*fgkSSDLadderCableWidth,
3984                                                                            0.5*fgkSSDFlexHeight[i]);
3985   const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3986                                                   {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
3987   TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
3988   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3989                         ladderendcablesegmentbbox[i] =
3990                                                   new TGeoVolume(ladderendcablesegmentbboxname[i],
3991                                                                                  ladderendcablesegmentbboxshape[i],
3992                                                                                  (i==0?fSSDAlTraceLadderCableMedium:
3993             fSSDKaptonLadderCableMedium));
3994                         ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3995                                                                                                                    fColorPolyhamide);
3996   }
3997   TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
3998   ladderendcablesegmentbboxtrans[0] =
3999                                                    new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
4000                                                                                            0.5*ssdendladdercablelength,
4001                                                                                            0.5*fgkSSDLadderCableWidth,
4002                                                                                            0.5*fgkSSDFlexHeight[0]);
4003   ladderendcablesegmentbboxtrans[1] =
4004                                                    new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
4005                                                                                            0.5*ssdendladdercablelength,
4006                                                                                            0.5*fgkSSDLadderCableWidth,
4007                                                                                            fgkSSDFlexHeight[0]
4008                                                                                            +0.5*fgkSSDFlexHeight[1]);
4009   TGeoVolume* ladderendcablesegmentbboxassembly =
4010                                                    new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
4011   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
4012                 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
4013                                                                                             ladderendcablesegmentbboxtrans[i]);
4014 /////////////////////////////////////////
4015   TList* laddercablesegmentlist = new TList();
4016   laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
4017   laddercablesegmentlist->Add(laddercablesegmentarbassembly);
4018   laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
4019   return laddercablesegmentlist;
4020   }
4021 /////////////////////////////////////////////////////////////////////////////////
4022 TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
4023   /////////////////////////////////////////////////////////////
4024   // Method generating Ladder Cable Volumes Assemblies
4025   /////////////////////////////////////////////////////////////
4026   TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
4027   TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
4028   for(Int_t i=0; i<n; i++){
4029          TGeoTranslation* laddercabletrans = new TGeoTranslation(
4030                                                         i*(fgkCarbonFiberJunctionWidth),
4031                                                         fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4032                                                         i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4033     laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
4034         if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
4035   }
4036   TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
4037                                           (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4038                                                                  fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4039                                           (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4040   laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
4041   return laddercable;
4042 }
4043 /////////////////////////////////////////////////////////////////////////////////
4044 TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
4045   /////////////////////////////////////////////////////////////
4046   // Method generating Ladder Cable Volumes Assembly
4047   /////////////////////////////////////////////////////////////
4048   TGeoVolume* laddercableassembly = new TGeoVolumeAssembly("LadderCableAssembly");
4049   char laddercabletransname[30];
4050   for(Int_t i=0; i<n; i++){
4051         sprintf(laddercabletransname,"LadderCableTrans%i",i+1);
4052     laddercableassembly->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
4053         new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0.,0.));
4054   }
4055   return laddercableassembly;
4056 }
4057 /////////////////////////////////////////////////////////////////////////////////
4058 TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
4059   /////////////////////////////////////////////////////////////
4060   // Method generating Ladder Cable List Assemblies
4061   /////////////////////////////////////////////////////////////
4062   const Int_t kladdercableassemblynumber = 2;
4063   TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
4064   TGeoVolume* ladderCable[kladdercableassemblynumber];
4065   char laddercableassemblyname[30];
4066   TList* laddercableassemblylist = new TList();
4067   for(Int_t i=0; i<kladdercableassemblynumber; i++){
4068         sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
4069         ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
4070         ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
4071                                          new TGeoCombiTrans((n-1)
4072                                          *       fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4073                                              2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
4074                                                                                         0.,new TGeoRotation("",180,0.,0.)));
4075         laddercableassemblylist->Add(ladderCable[i]);
4076 }
4077   return laddercableassemblylist;
4078 }
4079 ///////////////////////////////////////////////////////////////////////////////
4080 void AliITSv11GeometrySSD::SetLadderSegment(){
4081   /////////////////////////////////////////////////////////////
4082   // Method Generating Ladder Segment Array
4083   /////////////////////////////////////////////////////////////
4084   fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
4085   fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
4086   if(!fCreateMaterials) CreateMaterials();
4087   if(!fTransformationMatrices) CreateTransformationMatrices();
4088   if(!fBasicObjects) CreateBasicObjects();
4089   for(Int_t i=0; i<fgkladdersegmentnumber; i++){
4090   // Placing Carbon Fiber Support
4091         for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
4092                 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4093                                                                                         fcarbonfibersupportmatrix[j]);
4094                 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4095                                                                                         fcarbonfibersupportmatrix[j]);
4096   }
4097   // Placing Carbon Fiber Junction
4098     for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++)
4099         fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
4100                                                                    fcarbonfiberjunctionmatrix[j]);
4101   // Placing Carbon Fiber Lower Support
4102         for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++)
4103                 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
4104                                                            fcarbonfiberlowersupportrans[j]);
4105   // Placing SSD Sensor Support
4106     for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
4107         fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
4108                                                                      fssdsensorsupport[1][i],
4109                                                            j+1,fssdsensorsupportmatrix[j]);
4110   // Placing SSD Cooling Tube Support
4111         for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
4112                 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
4113                                                                    fcoolingtubesupportmatrix[j]);
4114   // Placing SSD Cooling Tube
4115         for(Int_t j=0; j<2; j++)
4116                 for(Int_t k=0; k<2; k++){
4117                 fladdersegment[i]->AddNode(fcoolingtube[0],2*j+k+1,fcoolingtubematrix[j][k]);
4118                 fladdersegment[i]->AddNode(fcoolingtube[j+1],k+1,fcoolingtubematrix[2+j][k]);
4119                 }
4120   // Placing SSD Hybrid
4121     switch(i){
4122         case 0:
4123                 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
4124                 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4125                 break;
4126     case 1:
4127                 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
4128                 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4129                 break;
4130         }
4131         // Placing Cooling Block System
4132     fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
4133         // Placing SSD Flex
4134         for(Int_t j=0; j<fgkflexnumber; j++){
4135       fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
4136       fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
4137         }
4138    }
4139 }
4140 ///////////////////////////////////////////////////////////////////////////////
4141 void AliITSv11GeometrySSD::SetEndLadderSegment(){
4142   /////////////////////////////////////////////////////////////
4143   // Method Generating End Ladder
4144   /////////////////////////////////////////////////////////////
4145   // End Ladder Carbon Fiber Junction
4146   /////////////////////////////////////////////////////////////
4147   fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
4148   fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
4149   if(!fCreateMaterials) CreateMaterials();
4150   if(!fTransformationMatrices) CreateTransformationMatrices();
4151   if(!fBasicObjects) CreateBasicObjects();
4152   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
4153         for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
4154                 fendladdersegment[i]->AddNode(j==2 ?
4155                                                         fendladdercarbonfiberjunction[i][1] :
4156                                                         fendladdercarbonfiberjunction[i][0],
4157                                                         j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
4158   }
4159   /////////////////////////////////////////////////////////////
4160   // End Ladder Carbon Fiber Support
4161   /////////////////////////////////////////////////////////////
4162   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
4163       for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
4164                   fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4165                   fendladdercarbonfibermatrix[i][j]);
4166           fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4167                   fendladdercarbonfibermatrix[i][j]);
4168       }
4169   /////////////////////////////////////////////////////////////
4170   // End Ladder Mounting Block
4171   /////////////////////////////////////////////////////////////
4172   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4173        fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
4174                                                                          fendladdermountingblockcombitrans[i]);
4175   /////////////////////////////////////////////////////////////
4176   // End Ladder Mounting Block
4177   /////////////////////////////////////////////////////////////
4178   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4179         for(Int_t j=0; j<2; j++)
4180                 fendladdersegment[i]->AddNode(fendladdermountingblockclip,i+1,
4181                                                                          fendladdermountingblockclipmatrix[i][j]);
4182   /////////////////////////////////////////////////////////////
4183   // End Ladder Lower Supports
4184   /////////////////////////////////////////////////////////////
4185   fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
4186                                                                 fendladderlowersupptrans[0]);
4187   fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
4188                                                                 fendladderlowersupptrans[1]);
4189   fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
4190                                                                 fendladderlowersupptrans[2]);
4191   /////////////////////////////////////////////////////////////
4192   // End Ladder Cooling Tube Support
4193   /////////////////////////////////////////////////////////////
4194   for(Int_t i=0; i<2; i++)
4195         for(Int_t j=0; j<(i==0?4:2); j++)
4196                 fendladdersegment[i]->AddNode(fcoolingtubesupport,
4197                                                                           j+1,fendladdercoolingtubesupportmatrix[i][j]);
4198   /////////////////////////////////////////////////////////////
4199   // End Ladder Cooling Tube Support
4200   /////////////////////////////////////////////////////////////
4201   fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
4202   fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
4203   fendladdersegment[0]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[0][2]);
4204   fendladdersegment[0]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[0][3]);
4205   fendladdersegment[0]->AddNode(fendladdercoolingtube[2],1,fendladdercoolingtubematrix[0][4]);
4206   fendladdersegment[0]->AddNode(fendladdercoolingtube[2],2,fendladdercoolingtubematrix[0][5]);
4207   fendladdersegment[1]->AddNode(fendladdercoolingtube[3],1,fendladdercoolingtubematrix[1][0]);
4208   fendladdersegment[1]->AddNode(fendladdercoolingtube[3],2,fendladdercoolingtubematrix[1][1]);
4209   fendladdersegment[1]->AddNode(fendladdercoolingtube[4],1,fendladdercoolingtubematrix[1][2]);
4210   fendladdersegment[1]->AddNode(fendladdercoolingtube[4],2,fendladdercoolingtubematrix[1][3]);
4211  // fendladdersegment[0]->CheckOverlaps(0.01);
4212  // fendladdersegment[1]->CheckOverlaps(0.01);
4213 }
4214 ///////////////////////////////////////////////////////////////////////////////
4215 void AliITSv11GeometrySSD::SetLadder(){
4216   /////////////////////////////////////////////////////////////
4217   // Method Generating Ladder of Layer 5 and 6
4218   /////////////////////////////////////////////////////////////
4219   Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
4220                                                                                                 fgkSSDLay6SensorsNumber};
4221   /////////////////////////////////////////////////////////////////////////////
4222   /// Generating Ladder Mother Volume Containing Ladder
4223   /////////////////////////////////////////////////////////////////////////////
4224   TGeoXtru* laddershape[fgkladdernumber];
4225   for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
4226   const Int_t kmothervertexnumber = 8;
4227   Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
4228   Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
4229   ///////////////////////
4230   // Setting the vertices
4231   ///////////////////////
4232   Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
4233                                                                 * (fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]);
4234   xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
4235   ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
4236   xmothervertex[0][1] = xmothervertex[0][0];
4237   ymothervertex[0][1] = 0.0;
4238   xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
4239                                                 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
4240   ymothervertex[0][2] = ymothervertex[0][1];
4241   ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
4242   xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
4243   xmothervertex[0][4] = -xmothervertex[0][3];
4244   ymothervertex[0][4] = ymothervertex[0][3];
4245   xmothervertex[0][5] = -xmothervertex[0][2];
4246   ymothervertex[0][5] = ymothervertex[0][2];
4247   xmothervertex[0][6] = -xmothervertex[0][1];
4248   ymothervertex[0][6] = ymothervertex[0][1];
4249   xmothervertex[0][7] = -xmothervertex[0][0];
4250   ymothervertex[0][7] = ymothervertex[0][0];
4251   for(Int_t i=0; i<kmothervertexnumber; i++){
4252         xmothervertex[1][i] = xmothervertex[0][i];
4253         ymothervertex[1][i] = ymothervertex[0][i];
4254   }
4255   const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4256   for(Int_t i=0; i<fgkladdernumber; i++){
4257         laddershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
4258                                                                     ymothervertex[i]);
4259     laddershape[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
4260     laddershape[i]->DefineSection(1,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4261                                                                                         +fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4262     fladder[i] = new TGeoVolume(laddername[i],laddershape[i],fSSDAir);
4263         fladder[i]->SetLineColor(4);
4264  }
4265 ///////////////////////////////////////////////////////////////////////////
4266  if(!fCreateMaterials) CreateMaterials();
4267  if(!fTransformationMatrices) CreateTransformationMatrices();
4268  if(!fBasicObjects) CreateBasicObjects();
4269  SetLadderSegment();
4270  SetEndLadderSegment();
4271   for(Int_t i=0; i<fgkladdernumber; i++){
4272         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4273         //////////////////////////
4274         /// Placing Ladder Segment
4275         //////////////////////////
4276                 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4277                                                                      fladdersegment[i==0 ? 1 : 0],
4278                                                                          ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4279         //////////////////////////
4280         /// Placing SSD Sensor
4281         //////////////////////////
4282                 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4283                                                         fssdsensormatrix[i][j]);
4284         }
4285         ///////////////////////////////
4286         /// Placing End Ladder Segment
4287         ///////////////////////////////
4288     fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
4289         fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4290    }
4291 /////////////////////////////////////////////////////////////////////////////
4292 /// Placing Ladder Cables
4293 /////////////////////////////////////////////////////////////////////////////
4294   Int_t sidecablenumber[2][2];
4295   sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4296   sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4297   sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4298   sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4299   Double_t carbonfibertomoduleposition[3];
4300   carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4301   carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4302                          fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4303          +               0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4304          -               0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4305          -            fgkSSDSensorCenterSupportThickness[0]);
4306   carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4307                                                                  +   0.5*fgkCoolingTubeSupportHeight
4308          -         fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4309   const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
4310   Double_t ssdendladdercablelength[4];
4311   ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
4312                                                          + fgkSSDSensorLength
4313                                                          - fgkSSDModuleStiffenerPosition[1]
4314                                                          - fgkSSDStiffenerWidth
4315                                                          - fgkSSDFlexWidth[0]
4316                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
4317   ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
4318                                                          + fgkSSDModuleStiffenerPosition[1]
4319                                                          + fgkSSDStiffenerWidth
4320                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
4321   ssdendladdercablelength[2] = ssdendladdercablelength[1]
4322                                                          - fgkEndLadderCarbonFiberLowerJunctionLength[1]
4323                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4324                                                          - kendladdercablecorrection;
4325   ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4326                                                          + carbonfibertomoduleposition[1]
4327                                                          - fgkSSDModuleStiffenerPosition[1]
4328                                                          - fgkSSDStiffenerWidth)
4329                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
4330   TList* laddercableassemblylist[4];
4331   const Int_t kendladdercablesnumber = 4;
4332   for(Int_t i=0; i<fgkladdercablesnumber; i++)
4333         for(Int_t j=0; j<kendladdercablesnumber; j++){
4334                 laddercableassemblylist[j] =
4335                 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4336                                                                    ssdendladdercablelength[j]);
4337             fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4338                                                                         j<2?1:2,fladdercablematrix[i][j]);
4339   }
4340 //  fladder[0]->CheckOverlaps(0.01);
4341 //  fladder[1]->CheckOverlaps(0.01);
4342 }
4343 ////////////////////////////////////////////////////////////////////////////////
4344 void AliITSv11GeometrySSD::SetLayer(){
4345 ////////////////////////////////////////////////////////////////////////////////
4346   // Creating Ladder of Layer 5 and Layer 6
4347   /////////////////////////////////////////////////////////////
4348   if(!fCreateMaterials) CreateMaterials();
4349   if(!fTransformationMatrices) CreateTransformationMatrices();
4350   if(!fBasicObjects) CreateBasicObjects();
4351   SetLadder(); // Generating the ladder of Layer5 and Layer6
4352   const Int_t kssdlayladdernumber[fgklayernumber] =
4353                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4354   /////////////////////////////////////////////////////////////
4355   // Generating mother volumes for Layer5 and Layer6
4356   /////////////////////////////////////////////////////////////
4357   TGeoXtru* ssdladdermothershape = (TGeoXtru*)fladder[0]->GetShape();
4358   TGeoXtru* layercontainershape[fgklayernumber];
4359   for(Int_t i=0; i<fgklayernumber; i++) layercontainershape[i] = new TGeoXtru(2);
4360   const Int_t kladdercontainernumber = 8;
4361   TVector3* laddercontainervertex[kladdercontainernumber];
4362   for(Int_t i=0; i<kladdercontainernumber; i++) laddercontainervertex[i] =
4363                 new TVector3(ssdladdermothershape->GetX(i),
4364                                          ssdladdermothershape->GetY(i)-ssdladdermothershape->GetY(0));
4365   TVector3** transvector[fgklayernumber];
4366   Double_t layerradius = 0.;
4367   Double_t layerladderangleposition[fgklayernumber] =
4368                 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
4369   Double_t** rotationangle = new Double_t*[fgklayernumber];
4370   for(Int_t i=0; i<fgklayernumber; i++) rotationangle[i] =
4371                                                                         new Double_t[kssdlayladdernumber[i]];
4372   for(Int_t i=0; i<fgklayernumber; i++) transvector[i] = new TVector3*[kssdlayladdernumber[i]];
4373   for(Int_t i=0; i<fgklayernumber; i++)
4374         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4375                 switch(i){
4376                         case 0: //Ladder of Layer5
4377                         layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
4378                         break;
4379                         case 1: //Ladder of Layer6
4380                         layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
4381                         break;
4382                 }
4383                 transvector[i][j] = new TVector3(layerradius*CosD(90.0+j*layerladderangleposition[i]),
4384                                                           layerradius*SinD(90.0+j*layerladderangleposition[i]));
4385                 rotationangle[i][j] = j*layerladderangleposition[i]*TMath::DegToRad();
4386         }
4387   TVector3** layercontainervertex[fgklayernumber];
4388   for(Int_t i=0; i<fgklayernumber; i++) layercontainervertex[i] =
4389                                         new TVector3*[5*(1+kssdlayladdernumber[i])];
4390   Int_t uplayerindex[2] = {0,7};
4391   Int_t downlayerindex[4] = {1,0,7,6};
4392   for(Int_t i=0; i<fgklayernumber; i++){
4393         Int_t vertexindex = 0;
4394         layercontainervertex[i][0] = new TVector3(0.,laddercontainervertex[0]->Y());
4395         layercontainervertex[i][1] = new TVector3(0.,laddercontainervertex[3]->Y());
4396         layercontainervertex[i][2] = new TVector3(*laddercontainervertex[3]);
4397         for(Int_t j=0; j<3; j++){
4398                 layercontainervertex[i][j]->RotateZ(rotationangle[i][0]);
4399            *layercontainervertex[i][j] += *transvector[i][0];
4400                 vertexindex++;
4401         }
4402         for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4403                 for(Int_t l=0; l<2; l++){
4404                         layercontainervertex[i][vertexindex] = new TVector3(l==0?
4405                                                                                                  * laddercontainervertex[4]:
4406                                                                                                  * laddercontainervertex[3]);
4407                         layercontainervertex[i][vertexindex]->RotateZ(rotationangle[i][j]);
4408                    *layercontainervertex[i][vertexindex] += *transvector[i][j];
4409                         vertexindex++;
4410                 }
4411         }
4412         layercontainervertex[i][vertexindex] = new TVector3(*laddercontainervertex[4]);
4413         layercontainervertex[i][vertexindex]->RotateZ(rotationangle[i][0]);
4414         *layercontainervertex[i][vertexindex]+= *transvector[i][0];
4415         layercontainervertex[i][vertexindex+1] = new TVector3(*layercontainervertex[i][1]);
4416         layercontainervertex[i][vertexindex+2] = new TVector3(*layercontainervertex[i][0]);
4417         vertexindex+=3;
4418     for(Int_t j=0; j<2; j++){
4419                 layercontainervertex[i][vertexindex] = new TVector3(*laddercontainervertex[7-j]);
4420                 layercontainervertex[i][vertexindex]->RotateZ(rotationangle[i][0]);
4421                 *layercontainervertex[i][vertexindex] += *transvector[i][0];
4422                 vertexindex++;
4423         }
4424         for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4425                 if(j%2!=0){
4426                         for(Int_t l=0; l<2; l++){
4427                                 layercontainervertex[i][vertexindex] = new TVector3(*laddercontainervertex[uplayerindex[l]]);
4428                                 layercontainervertex[i][vertexindex]->RotateZ(rotationangle[i][kssdlayladdernumber[i]-j]);
4429                            *layercontainervertex[i][vertexindex] += *transvector[i][kssdlayladdernumber[i]-j];
4430                                 vertexindex++;
4431                         }
4432                 }
4433                 else{
4434                         for(Int_t l=0; l<4; l++){
4435                                 layercontainervertex[i][vertexindex] =
4436                                                         new TVector3(*laddercontainervertex[downlayerindex[l]]);
4437                                 layercontainervertex[i][vertexindex]->RotateZ(rotationangle[i][kssdlayladdernumber[i]-j]);
4438                            *layercontainervertex[i][vertexindex] += *transvector[i][kssdlayladdernumber[i]-j];
4439                                 vertexindex++;
4440                         }
4441                 }
4442         }
4443         layercontainervertex[i][vertexindex] =
4444                                         new TVector3(*laddercontainervertex[1]);
4445         layercontainervertex[i][vertexindex+1] =
4446                                         new TVector3(*laddercontainervertex[0]);
4447         for(Int_t j=0; j<2; j++){
4448                 layercontainervertex[i][vertexindex+j]->RotateZ(rotationangle[i][0]);
4449            *layercontainervertex[i][vertexindex+j] += *transvector[i][0];
4450         }
4451         layercontainervertex[i][vertexindex+2] =
4452                                         new TVector3(*layercontainervertex[i][0]);
4453   }
4454   Double_t** xlayervertex = new Double_t*[fgklayernumber];
4455   Double_t** ylayervertex = new Double_t*[fgklayernumber];
4456   for(Int_t i=0; i<fgklayernumber; i++){
4457         xlayervertex[i] = new Double_t[5*(1+kssdlayladdernumber[i])];
4458         ylayervertex[i] = new Double_t[5*(1+kssdlayladdernumber[i])];
4459   }
4460   for(Int_t i=0; i<fgklayernumber; i++)
4461         for(Int_t j=0; j<5*(1+kssdlayladdernumber[i]); j++){
4462                 xlayervertex[i][j] = layercontainervertex[i][j]->X();
4463                 ylayervertex[i][j] = layercontainervertex[i][j]->Y();
4464         }
4465   for(Int_t i=0; i<fgklayernumber; i++){
4466         layercontainershape[i]->DefinePolygon(5*(1+kssdlayladdernumber[i]),xlayervertex[i],ylayervertex[i]);
4467     layercontainershape[i]->DefineSection(0,-0.5*(i==0?fgkSSDLay5LadderLength:fgkSSDLay6LadderLength));
4468     layercontainershape[i]->DefineSection(1,0.5*(i==0?fgkSSDLay5LadderLength:fgkSSDLay6LadderLength));
4469   }
4470   fSSDLayer5 = new TGeoVolume("ITSssdLayer5",layercontainershape[0],fSSDAir);
4471   fSSDLayer6 = new TGeoVolume("ITSssdLayer6",layercontainershape[1],fSSDAir);
4472   Int_t *ladderindex[fgklayernumber];
4473   Int_t index[fgklayernumber] = {8,9};
4474   for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4475   for(Int_t i=0; i<fgklayernumber; i++)
4476         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4477                 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4478                                                           j+index[i] : j+index[i]-kssdlayladdernumber[i];
4479                 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4480                         fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4481         }
4482   /////////////////////////////////////////////////////////////
4483   // Deallocating memory
4484   /////////////////////////////////////////////////////////////
4485   for(Int_t i=0; i<kladdercontainernumber; i++) delete laddercontainervertex[i];
4486   for(Int_t i=0; i<fgklayernumber; i++){
4487         for(Int_t j=0; j<kssdlayladdernumber[i]; j++) delete transvector[i][j];
4488         delete [] transvector[i];
4489   }
4490   for(Int_t i=0; i<fgklayernumber; i++){
4491         delete [] rotationangle[i];
4492   }
4493   delete rotationangle;
4494   for(Int_t i=0; i<fgklayernumber; i++){
4495         for(Int_t j=0; j<5*(1+kssdlayladdernumber[i]); j++)
4496                 delete layercontainervertex[i][j];
4497         delete [] layercontainervertex[i];
4498   }
4499   for(Int_t i=0; i<fgklayernumber; i++){
4500         delete [] xlayervertex[i];
4501         delete [] ylayervertex[i];
4502   }
4503   delete xlayervertex;
4504   delete ylayervertex;
4505   for(Int_t i=0; i<fgklayernumber; i++) delete ladderindex[i];
4506 }
4507 ////////////////////////////////////////////////////////////////////////////////
4508 void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
4509   /////////////////////////////////////////////////////////////
4510   // Insert the layer 5 in the mother volume.
4511   /////////////////////////////////////////////////////////////
4512   if (! moth) {
4513     printf("Error::AliITSv11GeometrySSD: Can't insert layer5, mother is null!\n");
4514     return;
4515   };
4516   if(!fSSDLayer5) SetLayer();
4517   fMotherVol = moth;
4518   TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4519                                                                                 + fgkLay5CenterITSPosition);
4520   moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
4521  }
4522 ////////////////////////////////////////////////////////////////////////////////
4523 void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
4524   /////////////////////////////////////////////////////////////
4525   // Insert the layer 6 in the mother volume.
4526   /////////////////////////////////////////////////////////////
4527   if (! moth) {
4528     printf("Error::AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
4529     return;
4530   };
4531   if(!fSSDLayer6) SetLayer();
4532   fMotherVol = moth;
4533   TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4534                                                                                 + fgkLay6CenterITSPosition);
4535   moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
4536  }
4537  ////////////////////////////////////////////////////////////////////////////////
4538  TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4539   /////////////////////////////////////////////////////////////
4540   // Method generating the Arc structure of Ladder Support
4541   /////////////////////////////////////////////////////////////
4542   const Int_t kssdlayladdernumber[fgklayernumber] =
4543                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4544   Double_t mountingsupportedge[fgklayernumber];
4545   Double_t mountingblockratio[fgklayernumber];
4546   Double_t theta[fgklayernumber];
4547   Double_t phi[fgklayernumber];
4548   Double_t psi0[fgklayernumber];
4549   Double_t deltapsi[fgklayernumber];
4550   TVector3* mountingsupportedgevector[fgklayernumber];
4551   for(Int_t i=0; i<fgklayernumber; i++){
4552         mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4553     mountingsupportedge[i]    = 0.5*fgkMountingBlockSupportRadius[i]
4554                                                           *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
4555                                                           * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4556                                                           - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4557                                                           / kssdlayladdernumber[i])));
4558     theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4559     phi[i]   = TMath::ASin(0.5*mountingblockratio[i]);
4560         mountingsupportedgevector[i] = new TVector3();
4561     mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4562         mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(1.
4563                                                                  -TMath::Power(mountingsupportedgevector[i]->X()
4564                                                                  /                         fgkMountingBlockSupportRadius[i],2)));
4565     psi0[i] = 0.5*TMath::Pi()-phi[i];
4566     deltapsi[i] = (theta[i]+phi[i])/nedges;
4567   }
4568   TVector3** vertex[fgklayernumber];
4569   TList* vertexlist[fgklayernumber];
4570   Int_t indexedge[fgklayernumber] = {0,0};
4571   for(Int_t i=0; i<fgklayernumber; i++){
4572         vertex[i] = new TVector3*[nedges+1];
4573         vertexlist[i] = new TList();
4574   }
4575   for(Int_t i=0; i<fgklayernumber; i++){
4576         for(Int_t j=0; j<nedges+1; j++){
4577                 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
4578                                                                     fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]));
4579                 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4580                 vertexlist[i]->Add(vertex[i][j]);
4581         }
4582         vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4583   }
4584   Double_t** xsidevertex = new Double_t*[fgklayernumber];
4585   Double_t** ysidevertex = new Double_t*[fgklayernumber];
4586   Double_t** xcentervertex = new Double_t*[fgklayernumber];
4587   Double_t** ycentervertex = new Double_t*[fgklayernumber];
4588   Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4589   Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4590   Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4591   Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4592   for(Int_t i=0; i<fgklayernumber; i++){
4593     xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4594     ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4595     xcentervertex[i] = new Double_t[indexedge[i]+3];
4596     ycentervertex[i] = new Double_t[indexedge[i]+3];
4597         xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4598         ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4599         xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4600         ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4601         for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4602                 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4603                                                                                 ((TVector3*)vertexlist[i]->At(j))->X();
4604                 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4605                                                                                 ((TVector3*)vertexlist[i]->At(j))->Y();
4606                 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4607                 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4608                 if(j<indexedge[i]+1){
4609                         xcentervertex[i][j!=indexedge[i]?j+3:0] =
4610                                                                                 ((TVector3*)vertexlist[i]->At(j))->X();
4611                         ycentervertex[i][j!=indexedge[i]?j+3:0] =
4612                                                                                 ((TVector3*)vertexlist[i]->At(j))->Y();
4613                         xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4614                         ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4615                 }
4616         }
4617         xsidevertex[i][1] = xsidevertex[i][0];
4618         ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4619         xsidevertex[i][2] = xsidevertex[i][3];
4620         ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4621         xcentervertex[i][1] = xcentervertex[i][0];
4622         ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4623         xcentervertex[i][2] = xcentervertex[i][3];
4624         ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4625         xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4626         ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4627         xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4628         ycenterlowervertex[i][0] = ysidevertex[i][0];
4629         xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4630         ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4631   }
4632   /////////////////////////////////////////////////////////////
4633   // Building the Arc Structure of Ladder Supports
4634   /////////////////////////////////////////////////////////////
4635   TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4636   TGeoXtru* centermountingsupportshape[fgklayernumber];
4637   TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4638   TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4639   TGeoVolume* sidemountingblocksupport[fgklayernumber];
4640   TGeoVolume* centermountingblocksupport[fgklayernumber];
4641   TGeoVolume* sideladdersupportpiece[fgklayernumber];
4642   TGeoVolume* centerladdersupportpiece[fgklayernumber];
4643   char sidemountingblockname[40];
4644   char centermountingblockname[40];
4645   char sideladdersupportpiecename[40];
4646   char centerladdersupportpiecename[40];
4647   for(Int_t i=0; i<fgklayernumber; i++){
4648         sprintf(sidemountingblockname,"MountingBlockSupportSideLay%dArc",i+5);
4649         sprintf(centermountingblockname,"MountingBlockSupportCenterLay%dArc",i+5);
4650         sprintf(sideladdersupportpiecename,"SideLadderSupportPieceLay%d",i+5);
4651         sprintf(centerladdersupportpiecename,"CenterLadderSupportPieceLay%d",i+5);
4652         sidemountingblocksupportshape[i] = new TGeoXtru(2);
4653     sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4654                                                                                                 xsidevertex[i],ysidevertex[i]);
4655     sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4656                                                                                                          -fgkMountingBlockSupportWidth[0]);
4657     sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4658     sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4659                                                                           sidemountingblocksupportshape[i],
4660                                                                                   fSSDAlCoolBlockMedium);
4661         sidemountingblocksupport[i]->SetLineColor(9);
4662         centermountingsupportshape[i] = new TGeoXtru(2);
4663     centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4664                                                                                                 xcentervertex[i],ycentervertex[i]);
4665         centermountingsupportshape[i]->DefineSection(0,0.);
4666     centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4667                                                                                                   -fgkMountingBlockSupportWidth[0]);
4668     centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4669                                                                           centermountingsupportshape[i],
4670                                                                                   fSSDAlCoolBlockMedium);
4671         centermountingblocksupport[i]->SetLineColor(9);
4672         sideladdersupportpieceshape[i] = new TGeoXtru(2);
4673     sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4674                                                                                                 xsidelowervertex[i],ysidelowervertex[i]);
4675         sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4676                                                                                                          -fgkMountingBlockSupportWidth[0]);
4677     sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4678     sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4679                                                                           sideladdersupportpieceshape[i],
4680                                                                                   fSSDSupportRingAl);
4681         sideladdersupportpiece[i]->SetLineColor(fColorAl);
4682         centerladdersupportpieceshape[i] = new TGeoXtru(2);
4683     centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4684                                                                                                 xcenterlowervertex[i],ycenterlowervertex[i]);
4685         centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4686     centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4687                                                                                                   -fgkMountingBlockSupportWidth[0]);
4688     centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4689                                                                           centerladdersupportpieceshape[i],
4690                                                                                   fSSDSupportRingAl);
4691         centerladdersupportpiece[i]->SetLineColor(fColorAl);
4692   }
4693   /////////////////////////////////////////////////////////////
4694   // Building the Up Structure of Ladder Supports
4695   /////////////////////////////////////////////////////////////
4696   TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4697   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4698   TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4699   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4700   TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4701   //////////////////////////////////////////////////////////
4702   // Setting the volume for TGeoXtru Mounting Block Piece
4703   //////////////////////////////////////////////////////////
4704   TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4705   TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4706   TGeoVolume* mountingblockpiecedown[fgklayernumber];
4707   TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4708   TGeoVolume* mountingblockpieceup[fgklayernumber];
4709   Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4710   Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4711   Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4712   Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
4713   char mountingblockpiecedownname[34];
4714   char mountingblockpieceupname[34];
4715   for(Int_t i=0; i<fgklayernumber; i++){
4716     ///////////////////////////
4717     // Mounting Block Down Vertex
4718     ///////////////////////////
4719         mountingblockpiecedownshape[i] = new TGeoXtru(2);
4720     sprintf(mountingblockpiecedownname,"MountingBlockPieceDownLay%d",i+5);
4721         mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4722         mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4723                                                                                 + fgkMountingBlockSupportDownHeight;
4724         mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4725         mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4726                                                                                 + fgkSSDMountingBlockHeight[1]
4727                                                                                 - 0.5*fgkCoolingTubeSupportHeight
4728                                                                                 - fgkSSDModuleCoolingBlockToSensor;
4729         mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4730         mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4731         mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4732         mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4733         mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4734         mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4735         mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4736         mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4737                                                                                 + fgkSSDMountingBlockHeight[2]
4738                                                                                 - fgkSSDMountingBlockHeight[0];
4739         mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4740         mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4741         mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4742         mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4743         mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4744                                                                                                          mountingblockpiecedownyvertex[i]);
4745         mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4746         mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4747         mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
4748                                                                  mountingblockpiecedownshape[i],fSSDSupportRingAl);
4749         mountingblockpiecedown[i]->SetLineColor(fColorG10);
4750     ///////////////////////////
4751     // Mounting Block Up Vertex
4752     ///////////////////////////
4753         mountingblockpieceupshape[i] = new TGeoXtru(2);
4754         sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5);
4755         mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4756         mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4757                                                                                 + fgkMountingBlockSupportUpHeight[i];
4758         mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4759         mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4760                                                                                 + fgkSSDMountingBlockHeight[1]
4761                                                                                 - 0.5*fgkCoolingTubeSupportHeight
4762                                                                                 - fgkSSDModuleCoolingBlockToSensor;
4763         mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4764         mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4765         mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4766         mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4767         mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4768         mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4769         mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4770         mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4771                                                                                 + fgkSSDMountingBlockHeight[2]
4772                                                                                 - fgkSSDMountingBlockHeight[0];
4773         mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4774         mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4775         mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4776         mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
4777         mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4778                                                                                                          mountingblockpieceupyvertex[i]);
4779         mountingblockpieceupshape[i]->DefineSection(0,0.0);
4780         mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4781         mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
4782                                                                 mountingblockpieceupshape[i],fSSDSupportRingAl);
4783         mountingblockpieceup[i]->SetLineColor(fColorG10);
4784  }
4785   ///////////////////////////////////////////////////////////////////
4786   // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4787   ///////////////////////////////////////////////////////////////////
4788   TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4789   TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4790   TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4791   TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4792   Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4793   Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4794   Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4795   Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
4796   char mountingblocksupportrapezoidowname[40];
4797   char mountingblocksupportrapezoidupname[40];
4798   Double_t scalefactor = 3./4.;
4799   for(Int_t i=0; i<fgklayernumber; i++){
4800   ////////////////////////////////////////////
4801   // Mounting Block Support Down Trapezoid Vertex
4802   ////////////////////////////////////////////
4803         mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4804         mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4805                                                                                                  - mountingsupportedge[i];
4806         mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4807         mountingblocksupportrapezoidownxvertex[i][1] =
4808                                                                                 mountingblocksupportrapezoidownxvertex[i][0];
4809         mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4810                                                                                                  + scalefactor*(mountingblockpiecedownyvertex[i][1]
4811                                                                                              - mountingblockpiecedownyvertex[i][0]);
4812         mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4813         mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4814         mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4815         mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4816         mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4817         mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
4818         mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4819                                                                                                                mountingblocksupportrapezoidownyvertex[i]);
4820         mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4821                                                                                                                         -fgkMountingBlockSupportWidth[0]);
4822         mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4823         sprintf(mountingblocksupportrapezoidowname,"MountingBlockSuppTrapezoidDownLay%d",i+5);
4824         mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
4825                                                                 mountingblocksupportrapezoidownshape[i],fSSDMountingBlockMedium);
4826         mountingblocksupportrapezoidown[i]->SetLineColor(9);
4827   ////////////////////////////////////////////
4828   // Mounting Block Support Up Trapezoid Vertex
4829   ////////////////////////////////////////////
4830         mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4831         mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4832                                                                                                  - mountingsupportedge[i];
4833         mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4834         mountingblocksupportrapezoidupxvertex[i][1] =
4835                                                                                 mountingblocksupportrapezoidupxvertex[i][0];
4836         mountingblocksupportrapezoidupyvertex[i][1] =
4837                                                                                                mountingblockpieceupyvertex[i][0]
4838                                                                                                  + scalefactor*(mountingblockpieceupyvertex[i][1]
4839                                                                                              - mountingblockpieceupyvertex[i][0]);
4840         mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4841         mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4842         mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4843         mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4844         mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4845         mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
4846         mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4847                                                                                                                mountingblocksupportrapezoidupyvertex[i]);
4848         mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4849                                                                                                                         -fgkMountingBlockSupportWidth[0]);
4850         mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4851         sprintf(mountingblocksupportrapezoidupname,"MountingBlockSuppTrapezoidUpLay%d",i+5);
4852         mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
4853                                                                 mountingblocksupportrapezoidupshape[i],fSSDMountingBlockMedium);
4854         mountingblocksupportrapezoidup[i]->SetLineColor(9);
4855   }
4856   ///////////////////////////////////////////////////////////////////
4857   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4858   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4859   Double_t boxoriginup[fgklayernumber][2][3];
4860   Double_t boxorigindown[fgklayernumber][2][3];
4861   char mountingblocksupportboxdownname[34];
4862   char mountingblocksupportboxupname[34];
4863   TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4864   mountingblocksupportrot->SetAngles(90.,180.,-90);
4865   TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4866   globalrefladdersupportrot->SetAngles(0.,90.,0.);
4867   TGeoHMatrix* laddersupportmatrix[2];
4868   laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4869   laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4870   /////////////////////////////////////////////////////////////
4871   // Creating Mother Volume for Containment
4872   /////////////////////////////////////////////////////////////
4873   Double_t *xmothervertex[fgklayernumber];
4874   Double_t *ymothervertex[fgklayernumber];
4875   for(Int_t i=0; i<fgklayernumber; i++){
4876         xmothervertex[i] = new Double_t[8];
4877         ymothervertex[i] = new Double_t[8];
4878   }
4879   TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4880   TGeoVolume* downmotherladdersupport[fgklayernumber];
4881   TGeoXtru* upmotherladdersupportshape[fgklayernumber];
4882   TGeoVolume* upmotherladdersupport[fgklayernumber];
4883   char upmotheladdersupportname[30];
4884   char downmotheladdersupportname[30];
4885   for(Int_t i=0; i<fgklayernumber; i++){
4886         xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4887                                                     -  mountingsupportedge[i];
4888         ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4889         xmothervertex[i][1] = xmothervertex[i][0];
4890         ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4891                                                         + fgkMountingBlockSupportWidth[0];
4892         xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4893         ymothervertex[i][2] = ymothervertex[i][1];
4894         xmothervertex[i][3] = xmothervertex[i][2];
4895         ymothervertex[i][3] = -ymothervertex[i][0];
4896         xmothervertex[i][4] = -xmothervertex[i][0];
4897         ymothervertex[i][4] = ymothervertex[i][3];
4898         xmothervertex[i][5] = xmothervertex[i][4];
4899         ymothervertex[i][5] = -ymothervertex[i][1];
4900         xmothervertex[i][6] = -xmothervertex[i][2];
4901         ymothervertex[i][6] = ymothervertex[i][5];
4902         xmothervertex[i][7] = xmothervertex[i][6];
4903         ymothervertex[i][7] = ymothervertex[i][0];
4904         sprintf(downmotheladdersupportname,"LadderSupportDownLay%d",i+5);
4905         sprintf(upmotheladdersupportname,"LadderSupportUpLay%d",i+5);
4906     downmotherladdersupportshape[i] = new TGeoXtru(2);
4907         downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4908         downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4909     downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4910                                                                    +                       fgkMountingBlockSupportDownHeight
4911                                                                    +                       fgkSSDMountingBlockHeight[1]
4912                                                                    -                       0.5*fgkCoolingTubeSupportHeight
4913                                                                    -                       fgkSSDModuleCoolingBlockToSensor);
4914     downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4915                                                                           downmotherladdersupportshape[i],fSSDAir);
4916     upmotherladdersupportshape[i] = new TGeoXtru(2);
4917         upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4918         upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4919     upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4920                                                                    +                       fgkMountingBlockSupportUpHeight[i]
4921                                                                    +                       fgkSSDMountingBlockHeight[1]
4922                                                                    -                       0.5*fgkCoolingTubeSupportHeight
4923                                                                    -                       fgkSSDModuleCoolingBlockToSensor);
4924     upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4925                                                                                           upmotherladdersupportshape[i],fSSDAir);
4926   }
4927   for(Int_t i=0; i<fgklayernumber; i++){
4928         /////////////////////////
4929         // Setting the box origin
4930         /////////////////////////
4931         boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4932         boxorigindown[i][0][1] =  fgkMountingBlockSupportRadius[i]
4933                                                    +  0.5*fgkMountingBlockSupportDownHeight;
4934         boxorigindown[i][0][2] =  fgkMountingBlockSupportWidth[1]
4935                                                    -  0.5*fgkMountingBlockSupportWidth[0];
4936
4937         boxorigindown[i][1][0] = 0.0;
4938         boxorigindown[i][1][1] = boxorigindown[i][0][1];
4939         boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4940                                                    -      fgkMountingBlockSupportWidth[0]);
4941
4942         boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4943         boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
4944                                                  + 0.5*fgkMountingBlockSupportUpHeight[i];
4945         boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4946                                                  - 0.5*fgkMountingBlockSupportWidth[0];
4947
4948         boxoriginup[i][1][0] = 0.0;
4949         boxoriginup[i][1][1] = fgkMountingBlockSupportRadius[i]
4950                                                  + 0.5*fgkMountingBlockSupportUpHeight[i];
4951         boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4952                                                  - fgkMountingBlockSupportWidth[0]);
4953
4954         /////////////////////////
4955     // Setting the boxes
4956         /////////////////////////
4957         mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4958                                                                                  +  fgkSSDMountingBlockLength[0]),
4959                                                                                         0.5*fgkMountingBlockSupportDownHeight,
4960                                                                                         0.5*fgkMountingBlockSupportWidth[0],
4961                                                                                         boxorigindown[i][0]);
4962     mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4963                                                                                         0.5*fgkMountingBlockSupportDownHeight,
4964                                                                                         0.5*(fgkMountingBlockSupportWidth[1]
4965                                                                                  -  fgkMountingBlockSupportWidth[0]),
4966                                                                                         boxorigindown[i][1]);
4967
4968         mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4969                                                                                  +  fgkSSDMountingBlockLength[0]),
4970                                                                                         0.5*fgkMountingBlockSupportUpHeight[i],
4971                                                                                         0.5*fgkMountingBlockSupportWidth[0],
4972                                                                                         boxoriginup[i][0]);
4973
4974         mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4975                                                                                         0.5*fgkMountingBlockSupportUpHeight[i],
4976                                                                                         0.5*(fgkMountingBlockSupportWidth[1]
4977                                                                      -  fgkMountingBlockSupportWidth[0]),
4978                                                                                         boxoriginup[i][1]);
4979         ///////////////////////////////////////
4980     // Adding the Volumes to Mother Volume
4981         ///////////////////////////////////////
4982         for(Int_t j=0; j<2; j++){
4983                 sprintf(mountingblocksupportboxdownname,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4984                 sprintf(mountingblocksupportboxupname,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4985                 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4986                                                                                   mountingblocksupportboxdownshape[i][j],
4987                                                                                   fSSDMountingBlockMedium);
4988                 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4989                                                                                   mountingblocksupportboxupshape[i][j],
4990                                                                                   fSSDMountingBlockMedium);
4991                 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4992                 mountingblocksupportboxup[i][j]->SetLineColor(9);
4993                 for(Int_t k=0; k<2; k++){
4994                         downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
4995                         upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
4996                 }
4997         }
4998         for(Int_t k=0; k<2; k++){
4999                 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
5000                 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
5001                 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
5002                 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
5003             downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
5004                 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
5005                 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
5006                 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
5007                 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
5008                 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
5009                 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
5010                 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
5011         }
5012   }
5013   TList* laddersupportlist = new TList();
5014   laddersupportlist->Add(downmotherladdersupport[0]);
5015   laddersupportlist->Add(upmotherladdersupport[0]);
5016   laddersupportlist->Add(downmotherladdersupport[1]);
5017   laddersupportlist->Add(upmotherladdersupport[1]);
5018   /////////////////////////////////////////////////////////////
5019   // Deallocating memory
5020   /////////////////////////////////////////////////////////////
5021   for(Int_t i=0; i<fgklayernumber; i++){
5022         for(Int_t j=0; j<nedges+1; j++)
5023                 delete vertex[i][j];
5024         delete mountingsupportedgevector[i];
5025         delete [] vertex[i];
5026         delete vertexlist[i];
5027         delete [] xsidevertex[i];
5028         delete [] ysidevertex[i];
5029         delete [] xcentervertex[i];
5030         delete [] ycentervertex[i];
5031         delete [] xsidelowervertex[i];
5032         delete [] ysidelowervertex[i];
5033         delete [] xcenterlowervertex[i];
5034         delete [] ycenterlowervertex[i];
5035   }
5036   delete xsidevertex;
5037   delete ysidevertex;
5038   delete xcentervertex;
5039   delete ycentervertex;
5040   delete xsidelowervertex;
5041   delete ysidelowervertex;
5042   delete xcenterlowervertex;
5043   delete ycenterlowervertex;
5044   delete globalrefladdersupportrot;
5045   delete mountingblocksupportrot;
5046   /////////////////////
5047   return laddersupportlist;
5048 }
5049  ////////////////////////////////////////////////////////////////////////////////
5050 void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
5051 //////////////////////////////////////////
5052 // Method Generating Ladder Support Ring
5053 //////////////////////////////////////////
5054   if(!fCreateMaterials) CreateMaterials();
5055   if(!fTransformationMatrices) CreateTransformationMatrices();
5056   if(!fBasicObjects) CreateBasicObjects();
5057   fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
5058   fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
5059     const Int_t kssdlayladdernumber[fgklayernumber] =
5060                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
5061   Double_t mountingsupportedge[fgklayernumber];
5062   Double_t mountingblockratio[fgklayernumber];
5063   Double_t theta[fgklayernumber];
5064   Double_t phi[fgklayernumber];
5065   for(Int_t i=0; i<fgklayernumber; i++){
5066         mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
5067     mountingsupportedge[i]    = 0.5*fgkMountingBlockSupportRadius[i]
5068                                                           *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
5069                                                           * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
5070                                                           - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
5071                                                           / kssdlayladdernumber[i])));
5072     theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
5073                          / fgkMountingBlockSupportRadius[i]);
5074     phi[i]   = TMath::ASin(0.5*mountingblockratio[i]);
5075   }
5076   TGeoRotation* globalrot = new TGeoRotation();
5077   globalrot->SetAngles(0.,-90.,0.);
5078   TGeoRotation** laddersupportrot[fgklayernumber];
5079   TGeoHMatrix**  laddersupportmatrix[fgklayernumber];
5080   for(Int_t i=0; i<fgklayernumber; i++){
5081         laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
5082         laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
5083         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
5084                 laddersupportrot[i][j] = new TGeoRotation();
5085                 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
5086                 switch(i){
5087                         case 0: //Ladder of Layer5
5088                                 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
5089                                 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
5090                                                                             laddersupportmatrix[i][j]);
5091                         break;
5092                         case 1: //Ladder of Layer6
5093                                 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
5094                                 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
5095                                                                               laddersupportmatrix[i][j]);
5096                         break;
5097                 }
5098     }
5099   }
5100   /////////////////////////////////////////////////////////////
5101   // Creating Lower Ladder Support
5102   /////////////////////////////////////////////////////////////
5103   TVector3** ringsupportvertex[fgklayernumber];
5104   Double_t angle = 360./nedges;
5105   for(Int_t i=0; i<fgklayernumber; i++){
5106     ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
5107         ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
5108                                                         *                          TMath::Cos(theta[i]));
5109         ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
5110                                                         -                          mountingsupportedge[i],
5111                                                                                    ringsupportvertex[i][0]->Y());
5112         ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
5113                                                                                    ringsupportvertex[i][1]->Y());
5114     ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
5115         for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
5116            ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
5117            ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
5118            ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
5119            ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
5120         }
5121         ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
5122     for(Int_t j=0; j<nedges+1; j++){
5123                 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
5124                         new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*CosD(90.0-j*angle),
5125                                                  (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*SinD(90.0-j*angle));
5126         }
5127   }
5128   Double_t **xmothervertex = new Double_t*[fgklayernumber];
5129   Double_t **ymothervertex = new Double_t*[fgklayernumber];
5130   for(Int_t i=0; i<fgklayernumber; i++){
5131         xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5132         ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5133         for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
5134                 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
5135                 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
5136         }
5137   }
5138   char lowerladdersupportname[30];
5139   TGeoXtru* lowerladdersupportshape[fgklayernumber];
5140   TGeoVolume* lowerladdersupport[fgklayernumber];
5141   TGeoRotation* lowerladdersupportrot = new TGeoRotation();
5142   lowerladdersupportrot->SetAngles(90.,180.,-90);
5143   for(Int_t i=0; i<fgklayernumber; i++){
5144         lowerladdersupportshape[i] = new TGeoXtru(2);
5145         lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
5146                                                                                           xmothervertex[i],ymothervertex[i]);
5147         lowerladdersupportshape[i]->DefineSection(0,0.);
5148     lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
5149         sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
5150     lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
5151                                                         lowerladdersupportshape[i],fSSDSupportRingAl);
5152         lowerladdersupport[i]->SetLineColor(fColorAl);
5153         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
5154         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
5155   }
5156   /////////////////////////////////////////////////////////////
5157   // Deallocating memory
5158   /////////////////////////////////////////////////////////////
5159   for(Int_t i=0; i<fgklayernumber; i++){
5160         for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
5161                 delete ringsupportvertex[i][j];
5162         delete [] ringsupportvertex[i];
5163   }
5164   for(Int_t i=0; i<fgklayernumber; i++){
5165         delete [] xmothervertex[i];
5166         delete [] ymothervertex[i];
5167   }
5168   delete xmothervertex;
5169   delete ymothervertex;
5170   delete globalrot;
5171   for(Int_t i=0; i<fgklayernumber; i++){
5172         for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
5173                 delete laddersupportrot[i][j];
5174         delete [] laddersupportrot[i];
5175   }
5176  }
5177  ////////////////////////////////////////////////////////////////////////////////
5178  TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
5179   /////////////////////////////////////////////////////////////
5180   // Method generating Endcap CoverPlate
5181   /////////////////////////////////////////////////////////////
5182   // Holes Definition
5183   ///////////////////
5184   Int_t nendcapcoverplateholedges = 30;
5185   const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
5186   Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
5187                                                           0.5*fgkEndCapCoverPlateThickness};
5188   TGeoXtru* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
5189                                                                                                               nendcapcoverplateholedges,holesection);
5190   TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
5191                                                                                   endcapcoverplatesmallholeshape,fSSDAir);
5192   endcapcoverplatesmallhole->SetLineColor(6);
5193   TGeoXtru* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
5194                                                                                                               nendcapcoverplateholedges,holesection);
5195   TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
5196                                                                                   endcapcoverplatebigholeshape,fSSDAir);
5197   endcapcoverplatebighole->SetLineColor(6);
5198   //////////////////////////
5199   // Screw Piece Definition
5200   //////////////////////////
5201   Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
5202   TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
5203                                                                                                       CosD(0.5*smallscrewangle),
5204                                                                                                       0.5*fgkEndCapCoverPlateThickness);
5205   TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
5206                                                                                                 endcapsmallscrewpieceshape,
5207                                                                                                 fSSDCoolingTubePhynox);
5208   endcapsmallscrewpiece->SetLineColor(fColorPhynox);
5209   ///////////////////
5210   // Box Definition
5211   ///////////////////
5212   TGeoBBox* endcapcoverplateboxshape[4];
5213   TGeoVolume* endcapcoverplatebox[4];
5214   Double_t boxorigin[5][3];
5215   boxorigin[0][0] = 0.;
5216   boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
5217   boxorigin[0][2] = 0.;
5218
5219   boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
5220   boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
5221   boxorigin[1][2] = 0.;
5222
5223   boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
5224                                   + fgkEndCapCoverPlateSmallHoleSeparation[1];
5225   boxorigin[2][1] = boxorigin[1][1];
5226   boxorigin[2][2] = 0.;
5227
5228   boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
5229                                   + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
5230   boxorigin[3][1] = boxorigin[1][1];
5231   boxorigin[3][2] = 0.;
5232
5233   endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5234                                                                                 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
5235                                                  -              2.*fgkEndCapCoverPlateSmallHoleRadius),
5236                                                                             0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
5237
5238   endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5239                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
5240                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5241                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
5242                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
5243
5244   endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5245                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
5246                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5247                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
5248                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
5249
5250   endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
5251                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
5252                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5253                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
5254                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
5255
5256   endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
5257                                                                            fSSDAir);
5258   endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
5259                                                                            fSSDAir);
5260   endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
5261                                                                            fSSDAir);
5262   endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
5263                                                                            fSSDAir);
5264   endcapcoverplatebox[0]->SetLineColor(6);
5265   endcapcoverplatebox[1]->SetLineColor(6);
5266   endcapcoverplatebox[2]->SetLineColor(6);
5267   endcapcoverplatebox[3]->SetLineColor(6);
5268   Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
5269   TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5270                                                                                         fgkEndCapCoverPlateSmallHoleRadius,
5271                                                                                         0.5*fgkEndCapCoverPlateThickness,
5272                                                                                         endcapfillingboxorigin);
5273   TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
5274                                                                            fSSDAir);
5275   endcapfillingbox->SetLineColor(6);
5276   ////////////////////////////
5277   // Contour Xtru Definition
5278   ////////////////////////////
5279   const Int_t kcontourvertexnumber = 10;
5280   Double_t xcontourvertex[kcontourvertexnumber];
5281   Double_t ycontourvertex[kcontourvertexnumber];
5282   xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
5283   xcontourvertex[1] = xcontourvertex[0];
5284   xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5285   xcontourvertex[3] = xcontourvertex[2];
5286   xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
5287   xcontourvertex[5] = xcontourvertex[4];
5288   xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5289   xcontourvertex[7] = xcontourvertex[6];
5290   xcontourvertex[8] = xcontourvertex[4];
5291   xcontourvertex[9] = xcontourvertex[8];
5292   ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5293                                         - (kendcapcoverplatesmallholenumber[1]-1)
5294                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5295   ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
5296                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5297   ycontourvertex[2] = ycontourvertex[1];
5298   ycontourvertex[3] = ycontourvertex[0];
5299   ycontourvertex[4] = ycontourvertex[3];
5300   ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
5301   ycontourvertex[6] = ycontourvertex[5];
5302   ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
5303                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]
5304                                         + fgkEndCapCoverPlateSmallHoleRadius;
5305   ycontourvertex[8] = ycontourvertex[7];
5306   ycontourvertex[9] = ycontourvertex[0];
5307   TGeoXtru* contourshape = new TGeoXtru(2);
5308   contourshape->DefinePolygon(kcontourvertexnumber,xcontourvertex,ycontourvertex);
5309   contourshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5310   contourshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5311   TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,fSSDAir);
5312   contour->SetLineColor(6);
5313   /////////////////////////////
5314   // Hole Contour Xtru Definition
5315   ////////////////////////////
5316   const Int_t kholecontourvertexnumber = 10;
5317   Double_t xholecontourvertex[2][kcontourvertexnumber];
5318   Double_t yholecontourvertex[2][kcontourvertexnumber];
5319   xholecontourvertex[0][0] = xcontourvertex[0];
5320   xholecontourvertex[0][1] = xholecontourvertex[0][0];
5321   xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5322   xholecontourvertex[0][3] = xholecontourvertex[0][2];
5323   xholecontourvertex[0][4] = xholecontourvertex[0][0]
5324                                                    + 0.5*(fgkEndCapCoverPlateLength[2]
5325                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5326   xholecontourvertex[0][5] = xholecontourvertex[0][4];
5327   xholecontourvertex[0][6] = xholecontourvertex[0][5]
5328                                                    + 2.*fgkEndCapCoverPlateBigHoleRadius;
5329   xholecontourvertex[0][7] = xholecontourvertex[0][6];
5330   xholecontourvertex[0][8] = xholecontourvertex[0][4];
5331   xholecontourvertex[0][9] = xholecontourvertex[0][8];
5332
5333   yholecontourvertex[0][0] = ycontourvertex[1];
5334   yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5335   yholecontourvertex[0][2] = yholecontourvertex[0][1];
5336   yholecontourvertex[0][3] = yholecontourvertex[0][0];
5337   yholecontourvertex[0][4] = yholecontourvertex[0][3];
5338   yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5339                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5340   yholecontourvertex[0][6] = yholecontourvertex[0][5];
5341   yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5342   yholecontourvertex[0][8] = yholecontourvertex[0][7];
5343   yholecontourvertex[0][9] = yholecontourvertex[0][0];
5344
5345   xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5346   xholecontourvertex[1][1] = xholecontourvertex[1][0];
5347   xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5348   xholecontourvertex[1][3] = xholecontourvertex[1][2];
5349   xholecontourvertex[1][4] = xholecontourvertex[1][0]
5350                                                    + 0.5*(fgkEndCapCoverPlateLength[2]
5351                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5352   xholecontourvertex[1][5] = xholecontourvertex[1][4];
5353   xholecontourvertex[1][6] = xholecontourvertex[1][5]
5354                                                    + 2.*fgkEndCapCoverPlateBigHoleRadius;
5355   xholecontourvertex[1][7] = xholecontourvertex[1][6];
5356   xholecontourvertex[1][8] = xholecontourvertex[1][4];
5357   xholecontourvertex[1][9] = xholecontourvertex[1][8];
5358
5359   yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5360                                                    - fgkEndCapCoverPlateWidth[0]);
5361   yholecontourvertex[1][1] = ycontourvertex[0];
5362   yholecontourvertex[1][2] = yholecontourvertex[1][1];
5363   yholecontourvertex[1][3] = yholecontourvertex[1][0];
5364   yholecontourvertex[1][4] = yholecontourvertex[1][3];
5365   yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5366                                                    - fgkEndCapCoverPlateWidth[0]
5367                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5368   yholecontourvertex[1][6] = yholecontourvertex[1][5];
5369   yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5370   yholecontourvertex[1][8] = yholecontourvertex[1][7];
5371   yholecontourvertex[1][9] = yholecontourvertex[1][0];
5372
5373   TGeoXtru* holecontourshape[2];
5374   holecontourshape[0] = new TGeoXtru(2);
5375   holecontourshape[0]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[0],
5376                                                                   yholecontourvertex[0]);
5377   holecontourshape[0]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5378   holecontourshape[0]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5379
5380   holecontourshape[1] = new TGeoXtru(2);
5381   holecontourshape[1]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[1],
5382                                                                   yholecontourvertex[1]);
5383   holecontourshape[1]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5384   holecontourshape[1]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5385
5386   TGeoVolume* holecontour[2];
5387   holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",holecontourshape[0],fSSDAir);
5388   holecontour[0]->SetLineColor(6);
5389   holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",holecontourshape[1],fSSDAir);
5390   holecontour[1]->SetLineColor(6);
5391   TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5392                                                                         +     fgkEndCapCoverPlateLength[2],0.,0.);
5393   TGeoTranslation*  bigholetrans[3];
5394   bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5395                                                                                 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5396   bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5397                                   +                     fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5398                                   -                                             fgkEndCapCoverPlateBigHoleRadius,0.0);
5399   bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5400                                                                                 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5401   /////////////////////////////////
5402   // Mother Volume Xtru Definition
5403   /////////////////////////////////
5404   const Int_t kmothervertexnumber = 12;
5405   Double_t xmothervertex[kmothervertexnumber];
5406   Double_t ymothervertex[kmothervertexnumber];
5407   xmothervertex[0]  = xcontourvertex[0];
5408   xmothervertex[1]  = xmothervertex[0];
5409   xmothervertex[2]  = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5410   xmothervertex[3]  = xmothervertex[2];
5411   xmothervertex[4]  = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5412   xmothervertex[5]  = xmothervertex[4];
5413   xmothervertex[6]  = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5414   xmothervertex[7]  = xmothervertex[6];
5415   xmothervertex[8]  = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5416                                         + fgkEndCapCoverPlateLength[2];
5417   xmothervertex[9]  = xmothervertex[8];
5418   xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5419   xmothervertex[11] = xmothervertex[10];
5420
5421   ymothervertex[0]  = ycontourvertex[0];
5422   ymothervertex[1]  = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5423   ymothervertex[2]  = ymothervertex[1];
5424   ymothervertex[3]  = ycontourvertex[1];
5425   ymothervertex[4]  = ymothervertex[3];
5426   ymothervertex[5]  = ymothervertex[1];
5427   ymothervertex[6]  = ymothervertex[5];
5428   ymothervertex[7]  = ymothervertex[0];
5429   ymothervertex[8]  = ymothervertex[7];
5430   ymothervertex[9]  = ymothervertex[8]
5431                                    - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5432   ymothervertex[10] = ymothervertex[9];
5433   ymothervertex[11] = ymothervertex[8];
5434   TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5435   mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5436   mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5437   mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5438   TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5439   ////////////////////////////////////////
5440   // Adding Nodes
5441   ////////////////////////////////////////
5442 //  TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5443   TGeoTranslation*** endcapcoverplatesmallholetrans;
5444   endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5445   Double_t transx[4] = {0,
5446                                                 fgkEndCapCoverPlateSmallHoleSeparation[0],
5447                                                 fgkEndCapCoverPlateSmallHoleSeparation[0]
5448                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1],
5449                                          2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5450                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1]};
5451   Int_t index = 0;
5452   for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5453         endcapcoverplatesmallholetrans[i] =
5454                                         new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5455     for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5456                 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5457             endcapcoverplatesmallholetrans[i][j] =
5458                 new TGeoTranslation(transx[i],
5459                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5460             if(index!=10){
5461                         mothercoverplate->AddNode(endcapcoverplatesmallhole,
5462                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5463                         mothercoverplate->AddNode(endcapsmallscrewpiece,
5464                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5465                 }
5466                 if(j<kendcapcoverplatesmallholenumber[1]-1)
5467                         mothercoverplate->AddNode(endcapcoverplatebox[0],
5468                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5469     }
5470   }
5471   mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5472   mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5473   mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5474   mothercoverplate->AddNode(endcapfillingbox,1);
5475   mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5476   mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5477   mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5478   mothercoverplate->AddNode(holecontour[0],1);
5479   mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5480   mothercoverplate->AddNode(holecontour[1],1);
5481   mothercoverplate->AddNode(contour,1);
5482   /////////////////////////////////
5483   return mothercoverplate;
5484  }
5485  ////////////////////////////////////////////////////////////////////////////////
5486  TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5487   /////////////////////////////////////////////////////////////
5488   // Getting EndCap Cooling Tube
5489   /////////////////////////////////////////////////////////////
5490   TGeoTorus* endcapcoolingtubetorushape[5];
5491   TGeoVolume* endcapcoolingtubetorus[5];
5492   TGeoTube* endcapcoolingtubeshape[4];
5493   TGeoVolume* endcapcoolingtube[4];
5494   char endcapcoolingtubetorusname[30];
5495   char endcapcoolingtubename[30];
5496   TGeoTorus* endcapcoolingwatertubetorushape[5];
5497   TGeoVolume* endcapcoolingwatertubetorus[5];
5498   TGeoTube* endcapcoolingwatertubeshape[4];
5499   TGeoVolume* endcapcoolingwatertube[4];
5500   char endcapcoolingwatertubetorusname[30];
5501   char endcapcoolingwatertubename[30];
5502   for(Int_t i=0; i<5; i++){
5503         sprintf(endcapcoolingtubetorusname,"EndCapCoolingTubeTorus%d",i+1);
5504         sprintf(endcapcoolingtubename,"EndCapCoolingTube%d",i+1);
5505         sprintf(endcapcoolingwatertubetorusname,"EndCapCoolingWaterTubeTorus%d",i+1);
5506         sprintf(endcapcoolingwatertubename,"EndCapCoolingWaterTube%d",i+1);
5507         if(i==3){
5508                 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5509                                                                                 fgkEndCapCoolingTubeRadiusMin,
5510                                                                                 fgkEndCapCoolingTubeRadiusMax,
5511                                                                                 90.0,fgkEndCapCoolingTubeAngle[3]);
5512                 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5513                                                                                 0.,fgkEndCapCoolingTubeRadiusMin,
5514                                                                                 90.0,fgkEndCapCoolingTubeAngle[3]);
5515     }
5516         else{
5517                 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5518                                                                           :fgkEndCapCoolingTubeAxialRadius[1],
5519                                                                            fgkEndCapCoolingTubeRadiusMin,
5520                                                                            fgkEndCapCoolingTubeRadiusMax,
5521                                                                     0.,fgkEndCapCoolingTubeAngle[i]);
5522                 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5523                                                                                :fgkEndCapCoolingTubeAxialRadius[1],
5524                                                                                  0.,fgkEndCapCoolingTubeRadiusMin,
5525                                                                          0.,fgkEndCapCoolingTubeAngle[i]);
5526         }
5527         endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5528                                                                                            endcapcoolingtubetorushape[i],
5529                                                                                            fSSDCoolingTubePhynox);
5530         endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5531                                                                                                         endcapcoolingwatertubetorushape[i],
5532                                                                                                         fSSDCoolingTubeWater);
5533     endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5534     endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5535     if(i<4){
5536                 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5537                                                                   fgkEndCapCoolingTubeRadiusMax,
5538                                                           0.5*fgkEndCapCoolingTubeLength[i]);
5539                 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5540                                                           0.5*fgkEndCapCoolingTubeLength[i]);
5541         endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5542                                                          endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5543         endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5544                                                          endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5545                 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5546                 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5547         }
5548   }
5549   TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5550   /////////////////////////////////////////
5551   // Transformation for Volume Positioning
5552   /////////////////////////////////////////
5553   TGeoCombiTrans* coolingtubecombitrans[6];
5554   TGeoRotation* coolingtuberot[8];
5555   TGeoTranslation* coolingtubetrans[6];
5556   TGeoHMatrix* coolingtubematrix[4];
5557   TGeoCombiTrans* torustubecombitrans[4];
5558   TGeoRotation* torustuberot[7];
5559   TGeoTranslation* torustubetrans[4];
5560   TGeoHMatrix* torustubematrix[5];
5561   TGeoCombiTrans* coolingwatertubecombitrans[6];
5562   TGeoRotation* coolingwatertuberot[8];
5563   TGeoTranslation* coolingwatertubetrans[6];
5564   TGeoHMatrix* coolingwatertubematrix[4];
5565   TGeoCombiTrans* toruswatertubecombitrans[4];
5566   TGeoRotation* toruswatertuberot[7];
5567   TGeoTranslation* toruswatertubetrans[4];
5568   TGeoHMatrix* toruswatertubematrix[5];
5569   for(Int_t i=0; i<8; i++){
5570     if(i<6){
5571          coolingtubetrans[i] = new TGeoTranslation();
5572          coolingwatertubetrans[i] = new TGeoTranslation();
5573     }
5574     if(i<8){
5575          coolingtuberot[i] = new TGeoRotation();
5576          coolingwatertuberot[i] = new TGeoRotation();
5577     }
5578     if(i<4){
5579          torustubetrans[i] = new TGeoTranslation();
5580          toruswatertubetrans[i] = new TGeoTranslation();
5581     }
5582     if(i<7){
5583          torustuberot[i] = new TGeoRotation();
5584          toruswatertuberot[i] = new TGeoRotation();
5585         }
5586   }
5587   /////////////////////////////////////////
5588   // Transformation for Inox Volume Positioning
5589   /////////////////////////////////////////
5590   coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5591                                                                           -endcapcoolingtubeshape[0]->GetDz(),0.);
5592   coolingtuberot[0]->SetAngles(0.,90.,0.);
5593   coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5594                                                                                                 *coolingtuberot[0]);
5595
5596   coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5597   coolingtuberot[1]->SetAngles(0.,90.,0.);
5598   coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5599                                                                                                 *coolingtuberot[1]);
5600
5601   coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5602                                                                          *CosD(fgkEndCapCoolingTubeAngle[0]),
5603                                                                           fgkEndCapCoolingTubeAxialRadius[0]
5604                                                                          *SinD(fgkEndCapCoolingTubeAngle[0]),
5605                                                                           0.);
5606   coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5607   coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5608                                                                                                 *coolingtuberot[2]);
5609
5610   coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5611                                            *                             (*coolingtubecombitrans[1]));
5612
5613   torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5614                                                                          endcapcoolingtubeshape[1]->GetDz());
5615   torustuberot[0]->SetAngles(0.,90.,0.);
5616   torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5617
5618   torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5619
5620   coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5621                                                                           -endcapcoolingtubeshape[2]->GetDz(),0.);
5622   coolingtuberot[3]->SetAngles(0.,90.,0.);
5623   coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5624                                                                                                 *coolingtuberot[3]);
5625   coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5626   coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5627   coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5628
5629   torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5630                                                                         endcapcoolingtubeshape[2]->GetDz());
5631   torustuberot[1]->SetAngles(0.,90.,0.);
5632   torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5633   torustuberot[2]->SetAngles(180.,0.,0.);
5634   torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5635   torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5636
5637   torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5638                                                                         -fgkEndCapCoolingTubeAxialRadius[0]);
5639   torustuberot[3]->SetAngles(0.,90.,0.);
5640   torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5641   torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5642   torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5643   torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5644
5645   coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5646                                                                           fgkEndCapCoolingTubeAxialRadius[0],0.);
5647   coolingtuberot[5]->SetAngles(90.,90.,-90.);
5648   coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5649                                                                                                 *coolingtuberot[5]);
5650   coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5651   coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5652   coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5653
5654   torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5655                                                                         endcapcoolingtubeshape[0]->GetDz());
5656   torustuberot[5]->SetAngles(0.,90.,0.);
5657   torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5658   torustuberot[6]->SetAngles(-90.,0.,0.);
5659   torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5660   torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5661
5662   coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5663                                                                           endcapcoolingtubeshape[3]->GetDz(),0.);
5664   coolingtuberot[6]->SetAngles(0.,90.,0.);
5665   coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5666                                                                                                 *coolingtuberot[6]);
5667   coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5668   coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5669   coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5670     /////////////////////////////////////////
5671   // Transformation for Water Volume Positioning
5672   /////////////////////////////////////////
5673   coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5674                                                                           -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5675   coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5676   coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5677                                                                                                      *coolingwatertuberot[0]);
5678
5679   coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5680   coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5681   coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5682                                                                                                      *coolingwatertuberot[1]);
5683
5684   coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5685                                                                                   *CosD(fgkEndCapCoolingTubeAngle[0]),
5686                                                                                   fgkEndCapCoolingTubeAxialRadius[0]
5687                                                                                   *SinD(fgkEndCapCoolingTubeAngle[0]),
5688                                                                               0.);
5689   coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5690   coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5691                                                                                                     *coolingwatertuberot[2]);
5692
5693   coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5694                                            *                                 (*coolingwatertubecombitrans[1]));
5695
5696   toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5697                                                                          endcapcoolingwatertubeshape[1]->GetDz());
5698   toruswatertuberot[0]->SetAngles(0.,90.,0.);
5699   toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5700                                                                                                    *toruswatertuberot[0]);
5701
5702   toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5703                                                   *                                     (*toruswatertubecombitrans[0]));
5704
5705   coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5706                                                                           -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5707   coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5708   coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5709                                                                                                      *coolingwatertuberot[3]);
5710   coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5711   coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5712                                                         *                                 (*coolingwatertubecombitrans[3]));
5713   coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5714
5715   toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5716                                                                         endcapcoolingwatertubeshape[2]->GetDz());
5717   toruswatertuberot[1]->SetAngles(0.,90.,0.);
5718   toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5719                                                                                                    *toruswatertuberot[1]);
5720   toruswatertuberot[2]->SetAngles(180.,0.,0.);
5721   toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5722                                                   *                 (*toruswatertubecombitrans[1]));
5723   toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5724
5725   toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5726                                                                                    -fgkEndCapCoolingTubeAxialRadius[0]);
5727   toruswatertuberot[3]->SetAngles(0.,90.,0.);
5728   toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5729                                                                                                    *toruswatertuberot[3]);
5730   toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5731   toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5732                                                   *                                     (*toruswatertubecombitrans[2]));
5733   toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5734
5735   coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5736                                                                                 fgkEndCapCoolingTubeAxialRadius[0],0.);
5737   coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5738   coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5739                                                                                                      *coolingwatertuberot[5]);
5740   coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5741   coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5742                                                         *                                 (*coolingwatertubecombitrans[4]));
5743   coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5744
5745   toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5746                                                                               endcapcoolingwatertubeshape[0]->GetDz());
5747   toruswatertuberot[5]->SetAngles(0.,90.,0.);
5748   toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5749                                                                                                    *toruswatertuberot[5]);
5750   toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5751   toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5752                                                   *                 (*toruswatertubecombitrans[3]));
5753   toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5754
5755   coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5756                                                                           endcapcoolingwatertubeshape[3]->GetDz(),0.);
5757   coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5758   coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5759                                                                                                      *coolingwatertuberot[6]);
5760   coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5761   coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5762                                                         *                                 (*coolingwatertubecombitrans[5]));
5763   coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5764   /////////////////////////////////////////
5765   // Positioning Volumes
5766   /////////////////////////////////////////
5767   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5768   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5769
5770   endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5771   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5772
5773   endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5774   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5775
5776   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5777   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5778
5779   endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5780   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5781
5782   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5783   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5784
5785   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5786   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5787
5788   endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5789   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5790
5791   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5792   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5793
5794   endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5795   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5796   /////////////////////////////////////////////////////////////
5797   // Deallocating memory
5798   /////////////////////////////////////////////////////////////
5799   for(Int_t i=0; i<8; i++){
5800     if(i<6){
5801          delete coolingtubetrans[i];
5802          delete coolingwatertubetrans[i];
5803          if(i!=0){
5804           delete coolingtubecombitrans[i];
5805           delete coolingwatertubecombitrans[i];
5806          }
5807         }
5808     if(i<8){
5809           delete coolingtuberot[i];
5810           delete coolingwatertuberot[i];
5811     }
5812     if(i<4){
5813                 delete torustubetrans[i];
5814                 delete toruswatertubetrans[i];
5815                 delete torustubecombitrans[i];
5816                 delete toruswatertubecombitrans[i];
5817         }
5818     if(i<7){
5819          delete torustuberot[i];
5820          delete toruswatertuberot[i];
5821         }
5822   }
5823   /////////////////////////////////////////////////////////////
5824   return endcapcoolingtubemother;
5825  }
5826  ////////////////////////////////////////////////////////////////////////////////
5827  TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5828   /////////////////////////////////////////////////////////////
5829   // Getting EndCap Cover Side
5830   /////////////////////////////////////////////////////////////
5831   const Int_t kendcapcoverholenumber[2] = {7,5};
5832   const Int_t kvertexnumber = 15;
5833   Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5834   xvertex[0]  = 0.0;
5835   xvertex[1]  = xvertex[0];
5836   xvertex[2]  = fgkEndCapSideCoverLength[0];
5837   xvertex[3]  = fgkEndCapSideCoverLength[1];
5838   xvertex[4]  = xvertex[3];
5839   xvertex[5]  = fgkEndCapSideCoverLength[2];
5840   xvertex[6]  = xvertex[5];
5841   xvertex[7]  = xvertex[2];
5842   xvertex[8]  = xvertex[7];
5843   xvertex[9]  = xvertex[6]-fgkEndCapSideCoverLength[0];
5844   xvertex[10] = xvertex[9];
5845   xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5846                           * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5847                           * fgkEndCapSideCoverLength[4];
5848   xvertex[12] = xvertex[11];
5849   xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5850                           * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5851                           * fgkEndCapSideCoverLength[4];
5852   xvertex[14] = xvertex[13];
5853   yvertex[0]  = 0.0;
5854   yvertex[1]  = fgkEndCapSideCoverWidth[0];
5855   yvertex[2]  = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5856   yvertex[3]  = yvertex[2];
5857   yvertex[4]  = fgkEndCapSideCoverWidth[1];
5858   yvertex[5]  = yvertex[4];
5859   yvertex[6]  = yvertex[0];
5860   yvertex[7]  = yvertex[6];
5861   yvertex[8]  = fgkEndCapSideCoverWidth[6];
5862   yvertex[9]  = yvertex[8];
5863   yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5864   yvertex[11] = yvertex[10];
5865   yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5866   yvertex[13] = yvertex[12];
5867   yvertex[14] = yvertex[6];
5868   TGeoXtru* endcapsidecovershape = new TGeoXtru(2);
5869   endcapsidecovershape->DefinePolygon(kvertexnumber,xvertex,yvertex);
5870   endcapsidecovershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5871   endcapsidecovershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5872   TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5873                                                                 endcapsidecovershape,fSSDCoolingTubePhynox);
5874   endcapsidecover->SetLineColor(fColorPhynox);
5875   ////////////////////////////////////////////
5876   // Defininition of Mother Volume
5877   ////////////////////////////////////////////
5878   const Int_t kmothervertexnumber = 7;
5879   Double_t xmothervertex[kmothervertexnumber];
5880   Double_t ymothervertex[kmothervertexnumber];
5881   for(Int_t i=0; i<kmothervertexnumber; i++){
5882         xmothervertex[i] = xvertex[i];
5883         ymothervertex[i] = yvertex[i];
5884   }
5885   TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5886   endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5887   endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5888   endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5889   TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5890                                                                 endcapsidecovermothershape,fSSDAir);
5891   ////////////////////////////////////////////
5892   endcapsidecovermother->AddNode(endcapsidecover,1);
5893   TGeoBBox* endcapsidecoverboxshape[4];
5894   endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5895                                                          +     (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5896                                                                0.5*fgkEndCapSideCoverLength[4],
5897                                                                    0.5*fgkEndCapSideCoverThickness);
5898   endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5899                                                          +     (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5900                                                                0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5901                                                          -     fgkEndCapSideCoverLength[4]),
5902                                                                    0.5*fgkEndCapSideCoverThickness);
5903   endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5904                                                                0.5*fgkEndCapSideCoverLength[4],
5905                                                                    0.5*fgkEndCapSideCoverThickness);
5906   endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5907                                                                0.5*fgkEndCapSideCoverWidth[5],
5908                                                                    0.5*fgkEndCapSideCoverThickness);
5909   TGeoVolume* endcapsidecoverbox[4];
5910   endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5911   endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5912   endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5913   endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5914   for(Int_t i=0; i<4; i++)   endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5915 //  TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5916   TGeoTranslation** endcapsidecoverboxtrans;
5917   endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5918   endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5919                                                          +                                         fgkEndCapSideCoverLength[0],
5920                                                                                                    endcapsidecoverboxshape[0]->GetDY()
5921                                                          +                     yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5922   endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5923                                                          +                     xvertex[11],
5924                                                                                                    endcapsidecoverboxshape[1]->GetDY()
5925                                                          +                     yvertex[12],0.);
5926   endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5927                                                          +                     xvertex[11],
5928                                                                                                    endcapsidecoverboxshape[2]->GetDY()
5929                                                          +                     yvertex[12]
5930                                                          +                                         2.*endcapsidecoverboxshape[1]->GetDY()
5931                                                          +                     fgkEndCapSideCoverWidth[5],0.);
5932   endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5933   endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5934   endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5935   for(Int_t i=0; i<2; i++)
5936         for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5937                 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5938                         new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5939                                                                 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5940                                                                 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5941                                                                 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5942                 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5943                                                                 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5944         }
5945   for(Int_t i=0; i<2; i++)
5946         for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5947                 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5948                 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5949                                                         +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5950                                                         endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5951                                                         +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5952                                                         +fgkEndCapSideCoverLength[4]),0.0);
5953                 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5954                                                                 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5955                                                                 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5956                                                                 +i*(kendcapcoverholenumber[1]-1)+j]);
5957         }
5958         return endcapsidecovermother;
5959  }
5960  ////////////////////////////////////////////////////////////////////////////////
5961  TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5962  ////////////////////////////////////////////////////////////////////////////////
5963  // Method returning Interface Card A, Interface Card B, Supply Card
5964  ////////////////////////////////////////////////////////////////////////////////
5965  /////////////////////
5966  // Supply Card
5967  /////////////////////
5968  // Electronic Board Back Al Plane
5969  const Int_t kelectboardbackvertexnumber = 8;
5970  Double_t xelectboardback[kelectboardbackvertexnumber];
5971  Double_t yelectboardback[kelectboardbackvertexnumber];
5972  xelectboardback[0] = 0.0;
5973  xelectboardback[1] = xelectboardback[0];
5974  xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5975  xelectboardback[3] = xelectboardback[2];
5976  xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5977  xelectboardback[5] = xelectboardback[4];
5978  xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5979  xelectboardback[7] = xelectboardback[6];
5980
5981  yelectboardback[0] = 0.0;
5982  yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5983  yelectboardback[2] = yelectboardback[1];
5984  yelectboardback[3] = yelectboardback[0];
5985  yelectboardback[4] = yelectboardback[3];
5986  yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5987  yelectboardback[6] = yelectboardback[5];
5988  yelectboardback[7] = yelectboardback[4];
5989  TGeoXtru* electboardbackshape = new TGeoXtru(2);
5990  electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5991                                                                         xelectboardback,yelectboardback);
5992  electboardbackshape->DefineSection(0,0.0);
5993  electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5994  TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5995                                                                                          electboardbackshape,fSSDSupportRingAl);
5996  electboardback->SetLineColor(fColorAl);
5997  // Electronic Board Kapton Layer
5998  const Int_t kelectlayervertexnumber = 8;
5999  Double_t xelectlayer[kelectlayervertexnumber];
6000  Double_t yelectlayer[kelectlayervertexnumber];
6001  xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
6002  xelectlayer[1] = xelectlayer[0];
6003  xelectlayer[2] = fgkEndCapCardElectBoardLength;
6004  xelectlayer[3] = xelectlayer[2];
6005  for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
6006
6007  yelectlayer[0] = 0.0;
6008  yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
6009  yelectlayer[2] = yelectlayer[1];
6010  yelectlayer[3] = yelectlayer[0];
6011  yelectlayer[4] = yelectlayer[3];
6012  yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
6013  yelectlayer[6] = yelectlayer[5];
6014  yelectlayer[7] = yelectlayer[4];
6015  TGeoXtru* electlayershape = new TGeoXtru(2);
6016  electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
6017  electlayershape->DefineSection(0,0.0);
6018  electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
6019  TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
6020                                                                                          electlayershape,fSSDKaptonFlexMedium);
6021  electlayer->SetLineColor(fColorKapton);
6022  // JMD Connector Female
6023  const Int_t kjmdconnectorvertexnumber = 6;
6024  Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
6025  Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
6026  xjmdconnectorvertex[0] = 0.0;
6027  xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
6028  xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
6029  xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
6030  xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
6031  xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
6032
6033  yjmdconnectorvertex[0] = 0.0;
6034  yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
6035  yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
6036  yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
6037  yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
6038  yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
6039  TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
6040  jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
6041                                                                   yjmdconnectorvertex);
6042  jmdconnectorshape->DefineSection(0,0.0);
6043  jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
6044  TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
6045                                                                                    jmdconnectorshape,fSSDMountingBlockMedium);
6046  jmdconnector->SetLineColor(fColorG10);
6047  // Top Cable Connector
6048  const Int_t kcableconnectorvertexnumber = 8;
6049  Double_t xconnectorvertex[kcableconnectorvertexnumber];
6050  Double_t yconnectorvertex[kcableconnectorvertexnumber];
6051  xconnectorvertex[0] = 0.0;
6052  xconnectorvertex[1] = xconnectorvertex[0];
6053  xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
6054  xconnectorvertex[3] = xconnectorvertex[2];
6055  xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
6056                                          - fgkEndCapCardCableConnectorLength[2];
6057  xconnectorvertex[5] = xconnectorvertex[4];
6058  xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
6059  xconnectorvertex[7] = xconnectorvertex[6];
6060
6061  yconnectorvertex[0] = 0.0;
6062  yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
6063  yconnectorvertex[2] = yconnectorvertex[1];
6064  yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
6065  yconnectorvertex[4] = yconnectorvertex[3];
6066  yconnectorvertex[5] = yconnectorvertex[1];
6067  yconnectorvertex[6] = yconnectorvertex[5];
6068  yconnectorvertex[7] = yconnectorvertex[0];
6069  TGeoXtru* cableconnectorshape = new TGeoXtru(2);
6070  cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
6071                                                                     yconnectorvertex);
6072  cableconnectorshape->DefineSection(0,0.0);
6073  cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
6074  TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
6075                                                                                    cableconnectorshape,fSSDMountingBlockMedium);
6076  cableconnector->SetLineColor(fColorG10);
6077  // Strip Connection
6078  TGeoBBox* endcapstripconnectionshape =
6079                                                                 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
6080                                                                                          0.5*fgkEndCapStripConnectionThickness,
6081                                                                                          0.5*fgkEndCapStripConnectionWidth);
6082  TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
6083                                                                                                         endcapstripconnectionshape,
6084                                                                                                         fSSDSupportRingAl);
6085  endcapstripconnection->SetLineColor(fColorAl);
6086  // Interface Card B
6087  const Int_t kcardBvertexnumber = 12;
6088  Double_t xcardBvertexnumber[kcardBvertexnumber];
6089  Double_t ycardBvertexnumber[kcardBvertexnumber];
6090
6091  xcardBvertexnumber[0]  = 0.0;
6092  xcardBvertexnumber[1]  = xcardBvertexnumber[0];
6093  xcardBvertexnumber[2]  = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
6094  xcardBvertexnumber[3]  = xcardBvertexnumber[2];
6095  xcardBvertexnumber[4]  = xcardBvertexnumber[1];
6096  xcardBvertexnumber[5]  = xcardBvertexnumber[4];
6097  xcardBvertexnumber[6]  = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
6098  xcardBvertexnumber[7]  = xcardBvertexnumber[6];
6099  xcardBvertexnumber[8]  = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
6100  xcardBvertexnumber[9]  = xcardBvertexnumber[8];
6101  xcardBvertexnumber[10] = xcardBvertexnumber[7];
6102  xcardBvertexnumber[11] = xcardBvertexnumber[10];
6103
6104  ycardBvertexnumber[0]  = 0.0;
6105  ycardBvertexnumber[1]  = fgkEndCapInterfaceCardBWidth[0];
6106  ycardBvertexnumber[2]  = ycardBvertexnumber[1];
6107  ycardBvertexnumber[3]  = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
6108  ycardBvertexnumber[4]  = ycardBvertexnumber[3];
6109  ycardBvertexnumber[5]  = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
6110  ycardBvertexnumber[6]  = ycardBvertexnumber[5];
6111  ycardBvertexnumber[7]  = ycardBvertexnumber[4];
6112  ycardBvertexnumber[8]  = ycardBvertexnumber[7];
6113  ycardBvertexnumber[9]  = ycardBvertexnumber[1];
6114  ycardBvertexnumber[10] = ycardBvertexnumber[9];
6115  ycardBvertexnumber[11] = ycardBvertexnumber[0];
6116
6117  TGeoXtru* interfacecardBshape = new TGeoXtru(2);
6118  interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
6119  interfacecardBshape->DefineSection(0,0.);
6120  interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
6121  TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
6122                                                                                          fSSDMountingBlockMedium);
6123  interfacecardB->SetLineColor(46);
6124  // Interface Card B Electronic Board
6125  const Int_t kelectboardcardBvertexnumber = 14;
6126  Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
6127  Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
6128
6129  xelectboardcardBvertex[0]  = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
6130  xelectboardcardBvertex[1]  = xelectboardcardBvertex[0];
6131  xelectboardcardBvertex[2]  = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
6132  xelectboardcardBvertex[3]  = xelectboardcardBvertex[2];
6133  xelectboardcardBvertex[4]  = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
6134  xelectboardcardBvertex[5]  = xelectboardcardBvertex[4];
6135  xelectboardcardBvertex[6]  = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
6136  xelectboardcardBvertex[7]  = xelectboardcardBvertex[6];
6137  xelectboardcardBvertex[8]  = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
6138  xelectboardcardBvertex[9]  = xelectboardcardBvertex[8];
6139  xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
6140  xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
6141  xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
6142  xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
6143
6144  yelectboardcardBvertex[0]  = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
6145  yelectboardcardBvertex[1]  = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
6146  yelectboardcardBvertex[2]  = yelectboardcardBvertex[1];
6147  yelectboardcardBvertex[3]  = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
6148  yelectboardcardBvertex[4]  = yelectboardcardBvertex[3];
6149  yelectboardcardBvertex[5]  = yelectboardcardBvertex[2];
6150  yelectboardcardBvertex[6]  = yelectboardcardBvertex[5];
6151  yelectboardcardBvertex[7]  = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
6152  yelectboardcardBvertex[8]  = yelectboardcardBvertex[7];
6153  yelectboardcardBvertex[9]  = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
6154  yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
6155  yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
6156  yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
6157  yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
6158
6159  TGeoXtru* electboardcardBshape = new TGeoXtru(2);
6160  electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
6161                                                                          xelectboardcardBvertex,yelectboardcardBvertex);
6162  electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
6163  electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
6164                                                                          + fgkEndCapInterfaceElectBoardCardBThickness);
6165  TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
6166                                                                                           fSSDSupportRingAl);
6167  electboardcardB->SetLineColor(fColorAl);
6168  // Generating Stiffener 2
6169  TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
6170                                                                                            0.5*fgkEndCapStiffenerThickness,
6171                                                                                            0.5*fgkEndCapStiffenerLength);
6172  TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
6173  endcapstiffener->SetLineColor(fColorAl);
6174  // Generating Mother Interface Card B Container
6175  const Int_t kinterfacecardBmothervertexnumber = 10;
6176  Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6177  Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6178
6179  xinterfacecardBmothervertex[0] = 0.0;
6180  xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
6181  xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
6182                                                                 + fgkEndCapInterfaceCardBThickness;
6183  xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
6184  xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
6185                                                                 + fgkEndCapInterfaceElectBoardCardBThickness;
6186  xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
6187  xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
6188  xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
6189  xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
6190                                                                 + fgkEndCapCardJMDConnectorLength[0];
6191  xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
6192
6193  yinterfacecardBmothervertex[0] = 0.0;
6194  yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
6195                                                                 + fgkEndCapInterfaceCardBWidth[1]
6196                                                                 + fgkEndCapInterfaceCardBWidth[2];
6197  yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
6198  yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
6199  yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
6200  yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
6201  yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
6202  yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
6203                                                                 + fgkEndCapCardJMDConnectorWidth[0]
6204                                                                 + fgkEndCapCardJMDConnectorWidth[1];
6205  yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
6206  yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
6207  TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
6208  interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
6209                                                                                   xinterfacecardBmothervertex,
6210                                                                                   yinterfacecardBmothervertex);
6211  interfacecardBmothershape->DefineSection(0,-1.e-15);
6212  interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
6213  TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
6214                                                                                                    interfacecardBmothershape,fSSDAir);
6215  electboardcardB->SetLineColor(fColorAl);
6216  // Positioning Volumes Mother Interface Card B Container
6217  TGeoRotation* interfacecardBrot = new TGeoRotation();
6218  TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
6219  interfacecardBrot->SetAngles(90.,-90.,-90.);
6220  interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
6221  TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
6222  TGeoRotation* electboardcardBrot = new TGeoRotation();
6223  TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
6224  electboardcardBrot->SetAngles(90.,90.,-90.);
6225  electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
6226  TGeoCombiTrans* electboardcardBcombitrans =
6227                                   new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6228  interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6229  interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6230  TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6231  jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6232  TGeoTranslation* jmdconnectorcardBtrans[3];
6233  TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6234  for(Int_t i=0; i<3; i++){
6235    jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6236                                                          + fgkEndCapCardJMDConnectorLength[0],
6237                                                            fgkEndCapCardElectBoardLayerWidth[1],
6238                                                            0.5*fgkEndCapCardJMDConnectorThickness
6239                                                          + 0.5*(fgkEndCapInterfaceCardBLength[1]
6240                                                          - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6241                                                          + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6242    jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6243                                                                                                            *jmdconnectorcardBrot);
6244    interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6245  }
6246  // Mother Supply Card Container
6247  TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6248  // Interface Card Container
6249  TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6250  // Placing Volumes in Mother Supply Card Container
6251  // JMD Connector Positioning
6252  TGeoTranslation* jmdconnectortrans[2];
6253  for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6254  jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6255                                                                                         fgkEndCapCardElectBoardBackLength[0]
6256                                           -                                             fgkEndCapCardJMDConnectorThickness
6257                                           -                                             fgkEndCapCardJMDConnectorToLayer);
6258  TGeoRotation* jmdconnectorot = new TGeoRotation();
6259  jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6260                                                                  + 2.*fgkEndCapCardJMDConnectorLength[0]
6261                                                                  + 2.*fgkEndCapCardElectBoardLayerThickness,
6262                                                                           fgkEndCapCardElectBoardLayerWidth[1],
6263                                                                       fgkEndCapCardJMDConnectorThickness
6264                                                                  +    fgkEndCapCardJMDConnectorToLayer);
6265  jmdconnectorot->SetAngles(90.,180.,-90);
6266  TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6267                                                                                 * jmdconnectorot);
6268  mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6269  mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6270  // Top Cable Connector Placing
6271  TGeoRotation* cableconnectorot[2];
6272  for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6273  TGeoTranslation* cableconnectortrans[3];
6274  for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6275  cableconnectorot[0]->SetAngles(90.,0.,0.);
6276  cableconnectorot[1]->SetAngles(0.,-90.,0.);
6277  cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6278  TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6279                                                                                                                            *cableconnectorot[0]);
6280  TGeoHMatrix* cableconnectormatrix[2];
6281  for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6282                                                         new TGeoHMatrix((*cableconnectorot[1])
6283                                                                                    *(*cableconnectorcombitrans));
6284  cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6285                                            -                               fgkEndCapCardCableConnectorThickness,
6286                                                                                 fgkEndCapCardCableConnectorLength[0]
6287                                            +                            fgkEndCapCardCableConnectorToLayer);
6288  cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6289                                            -                2.*fgkEndCapCardCableConnectorThickness
6290                                            -                            fgkEndCapCardCableConnectorDistance,
6291                                                                                 fgkEndCapCardCableConnectorLength[0]
6292                                            +                            fgkEndCapCardCableConnectorToLayer);
6293  for(Int_t i=0; i<2; i++){
6294         cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6295     mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6296  }
6297  TGeoRotation* electboardbackrot = new TGeoRotation();
6298  TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6299  electboardbackrot->SetAngles(90.,-90.,-90.);
6300  electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6301                                                         +                fgkEndCapCardJMDConnectorLength[0]
6302                                                         +                fgkEndCapCardElectBoardLayerThickness,0.,0.);
6303  TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6304                                                                                                                            *electboardbackrot);
6305  mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6306  // Electronic Board Kapton Layer Positioning
6307  TGeoRotation* electlayerrot = new TGeoRotation();
6308  TGeoTranslation* electlayertrans[2];
6309  TGeoCombiTrans* electlayercombitrans[2];
6310  for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6311  electlayerrot->SetAngles(90.,-90.,-90.);
6312  electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6313                                                                  + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6314  electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6315                                                                  + 2.*fgkEndCapCardElectBoardLayerThickness
6316                                                                  + fgkEndCapCardElectBoardBackThickness,0.,0.);
6317  for(Int_t i=0; i<2; i++){
6318         electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6319         mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6320  }
6321  // Placing Volumes in Mother Interface Card Container
6322  motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6323  motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6324  for(Int_t i=0; i<2; i++){
6325         motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6326  }
6327  /////////////////////////////////////////////////////////////
6328  // Generation of Card Interface Container
6329  /////////////////////////////////////////////////////////////
6330  Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6331                                                   - fgkEndCapCardJMDConnectorLength[0]
6332                                                   - fgkEndCapInterfaceCardBThickness
6333                                                   - 9.*fgkEndCapStripConnectionThickness
6334                                                   - 8.*fgkEndCapCardElectBoardBackThickness;
6335  const Int_t kcardinterfacecontainervertexnumber = 14;
6336  Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6337  Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6338  xcardinterfacecontainervertex[0]  =-6.5*fgkEndCapCardElectBoardBackThickness
6339                                                                    - 7.0*fgkEndCapStripConnectionThickness;
6340  xcardinterfacecontainervertex[1]  = xcardinterfacecontainervertex[0];
6341  xcardinterfacecontainervertex[2]  = xcardinterfacecontainervertex[1]
6342                                                                    + fgkEndCapStripConnectionThickness
6343                                                                    - fgkEndCapCardElectBoardLayerThickness
6344                                                                    - fgkEndCapCardCableConnectorWidth[0];
6345  xcardinterfacecontainervertex[3]  = xcardinterfacecontainervertex[2];
6346  xcardinterfacecontainervertex[4]  = xcardinterfacecontainervertex[1];
6347  xcardinterfacecontainervertex[5]  = xcardinterfacecontainervertex[4];
6348  xcardinterfacecontainervertex[6]  = 1.5*fgkEndCapCardElectBoardBackThickness
6349                                                                    + 2.0*fgkEndCapStripConnectionThickness;
6350  xcardinterfacecontainervertex[7]  = xcardinterfacecontainervertex[6];
6351  xcardinterfacecontainervertex[8]  = xcardinterfacecontainervertex[7]
6352                                                                    + fgkEndCapInterfaceCardBThickness;
6353  xcardinterfacecontainervertex[9]  = xcardinterfacecontainervertex[8];
6354  xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6355                                                                    + fgkEndCapInterfaceElectBoardCardBThickness;
6356  xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6357  xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6358                                    - fgkEndCapInterfaceElectBoardCardBThickness
6359                                                                    + fgkEndCapCardJMDConnectorLength[0]
6360                                                                    + stiffenertransx+fgkEndCapStiffenerWidth;
6361  xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6362
6363  ycardinterfacecontainervertex[0]  = 0.;
6364  ycardinterfacecontainervertex[1]  = fgkEndCapCardElectBoardLayerWidth[1]
6365                                                                    + fgkEndCapCardJMDConnectorWidth[0]
6366                                                                    + fgkEndCapCardJMDConnectorWidth[1];
6367  ycardinterfacecontainervertex[2]  = ycardinterfacecontainervertex[1];
6368  ycardinterfacecontainervertex[3]  = fgkEndCapCardElectBoardBackWidth[0]
6369                                                                    - fgkEndCapStripConnectionWidth;
6370  ycardinterfacecontainervertex[4]  = ycardinterfacecontainervertex[3];
6371  ycardinterfacecontainervertex[5]  = fgkEndCapCardElectBoardBackWidth[0];
6372  ycardinterfacecontainervertex[6]  = ycardinterfacecontainervertex[5];
6373  ycardinterfacecontainervertex[7]  = fgkEndCapInterfaceCardBWidth[0]
6374                                                                    + fgkEndCapInterfaceCardBWidth[1]
6375                                                                    + fgkEndCapInterfaceCardBWidth[2];
6376  ycardinterfacecontainervertex[8]  = ycardinterfacecontainervertex[7];
6377  ycardinterfacecontainervertex[9]  = yelectboardcardBvertex[3];
6378  ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6379  ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6380  ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6381  ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6382
6383  TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6384  interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6385                                                                                   xcardinterfacecontainervertex,
6386                                                                                   ycardinterfacecontainervertex);
6387  interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6388                                                                            -    fgkEndCapCardElectBoardBackLength[0]));
6389  interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6390                                                                            +    fgkEndCapCardElectBoardBackLength[0]));
6391  TGeoVolume** cardinterfacecontainer;
6392  cardinterfacecontainer = new TGeoVolume*[4];
6393  cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6394                                                                                         interfacecardmothershape,fSSDAir);
6395  cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6396                                                                                         interfacecardmothershape,fSSDAir);
6397  cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6398                                                                                         interfacecardmothershape,fSSDAir);
6399  cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6400                                                                                         interfacecardmothershape,fSSDAir);
6401  /////////////////////////////////
6402  // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6403  // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6404  // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6405  // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6406  /////////////////////////////////
6407  TGeoRotation* endcapstripconnectionrot[2];
6408  for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6409  endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6410  endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6411  TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6412                                                                         *                                 (*endcapstripconnectionrot[0]));
6413  TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6414  endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6415                                                                                         -0.5*fgkEndCapCardElectBoardBackThickness,
6416                                                                                          fgkEndCapCardElectBoardBackWidth[0]
6417                                                                                         -endcapstripconnectionshape->GetDZ(),
6418                                                                                          0.5*fgkEndCapCardElectBoardBackLength[0]);
6419  endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6420  TGeoTranslation* cardinterfacetrans[9];
6421  TGeoHMatrix* cardinterfacematrix[9];
6422  for(Int_t i=0; i<7; i++){
6423         cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6424                                                   +                                                     fgkEndCapCardElectBoardBackThickness),
6425                                                                                                 0.0,0.0);
6426         cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6427                                                    *                             (*endcapstripconnectionmatrix));
6428  }
6429  cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6430                                                   +                                             fgkEndCapCardElectBoardBackThickness),
6431                                                                                                 0.0,0.0);
6432  cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6433                                                 *                                 (*endcapstripconnectionmatrix));
6434  cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6435                                                   +                                             fgkEndCapCardElectBoardBackThickness),
6436                                                                                                 0.0,0.0);
6437  cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6438                                                 *                                 (*endcapstripconnectionmatrix));
6439
6440  for(Int_t i=0; i<4; i++){
6441         cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6442                                                                            cardinterfacematrix[7]);
6443         cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6444                                                                            cardinterfacematrix[8]);
6445  }
6446  TGeoTranslation* mothersupplycardtrans =
6447                                         new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6448                                                                                 + 2.*fgkEndCapCardJMDConnectorLength[0]
6449                                                                                 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6450  TGeoHMatrix* mothersupplycardmatrix[7];
6451  Int_t index[4] = {1,1,1,1};
6452  for(Int_t i=0; i<7; i++){
6453         mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6454                                                         *                                 (*mothersupplycardtrans));
6455         for(Int_t j=0; j<4; j++){
6456                 switch(j){
6457                         case 0: //Layer5 EndCap Left Side
6458                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6459                                                                                                    cardinterfacematrix[i]);
6460                                 if(i!=0){
6461                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6462                                                                                                            mothersupplycardmatrix[i]);
6463                                         index[j]++;
6464
6465                                 }
6466                         break;
6467                         case 1: //Layer5 EndCap Rigth Side
6468                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6469                                                                                                    cardinterfacematrix[i]);
6470                                 if(i>0&&i<6){
6471                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6472                                                                                                            mothersupplycardmatrix[i]);
6473                                         index[j]++;
6474                                 }
6475                         break;
6476                         case 2: //Layer6 EndCap Left Side
6477                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6478                                                                                                    cardinterfacematrix[i]);
6479                                 if(i!=6){
6480                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6481                                                                                                            mothersupplycardmatrix[i]);
6482                                         index[j]++;
6483                                 }
6484                         break;
6485                         case 3: //Layer6 EndCap Right Side
6486                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6487                                                                                                    cardinterfacematrix[i]);
6488                                 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6489                                                                                                    mothersupplycardmatrix[i]);
6490                                 index[j]++;
6491                         break;
6492                 }
6493         }
6494  }
6495  // Positioning Interface
6496  TGeoTranslation* motherinterfacecardtrans =
6497                 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6498                                                          +0.5*fgkEndCapCardElectBoardBackThickness
6499                                                          -fgkEndCapCardElectBoardLayerThickness
6500                                                          +fgkEndCapStripConnectionThickness,0.,0.);
6501  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6502                                         motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6503  // Positioning Interface Card B
6504  TGeoTranslation* interfacecardBmothertrans =
6505                                         new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6506                                                                                 + 2.*fgkEndCapStripConnectionThickness
6507                                                                                         + fgkEndCapCardElectBoardBackThickness,0.,
6508                                                                            -0.5 * (fgkEndCapInterfaceCardBLength[1]
6509                                                                                         -  fgkEndCapCardElectBoardBackLength[0]));
6510  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6511                                                                                                                          interfacecardBmothertrans);
6512  // Positioning Stiffener
6513  TGeoTranslation* endcapstiffenertrans =
6514                                                 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6515                                                                            +    2.0*fgkEndCapStripConnectionThickness
6516                                                                            +    fgkEndCapInterfaceCardBThickness
6517                                                                            +    fgkEndCapCardJMDConnectorLength[0]
6518                                                                            +    stiffenertransx
6519                                                                            +    endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6520                                                                                         endcapstiffenershape->GetDZ()
6521                                                                            -    0.5*(fgkEndCapStiffenerLength
6522                                                                            -    fgkEndCapCardElectBoardBackLength[0]));
6523  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6524  /////////////////////////////////////////////////////////////
6525  // Deallocating memory
6526  /////////////////////////////////////////////////////////////
6527  delete interfacecardBrot;
6528  delete interfacecardBtrans;
6529  delete electboardcardBtrans;
6530  delete electboardcardBrot;
6531  delete jmdconnectorcardBrot;
6532  for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6533  delete jmdconnectorot;
6534  delete jmdconnectortrans[1];
6535  for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6536  delete cableconnectorcombitrans;
6537  delete electboardbacktrans;
6538  delete electboardbackrot;
6539  delete electlayerrot;
6540  for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6541  for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6542  delete mothersupplycardtrans;
6543  for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6544  /////////////////////////////////////////////////////////////
6545  return cardinterfacecontainer;
6546  }
6547  ////////////////////////////////////////////////////////////////////////////////
6548  TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6549   /////////////////////////////////////////////////////////////
6550   // Method returning EndCap Mother Volume
6551   /////////////////////////////////////////////////////////////
6552   const Int_t kendcapcoverplatesmallholenumber = 9;
6553   Double_t endcapmotherorigin[3];
6554   endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6555                                                 +  0.5 *(fgkEndCapCoverPlateLength[3]
6556                                             +  2.0 * fgkEndCapCoverPlateLength[2]);
6557   endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6558                                           -                      fgkEndCapCoverPlateWidth[2]
6559                                           -       (kendcapcoverplatesmallholenumber-1)
6560                                           *        fgkEndCapCoverPlateSmallHoleSeparation[2])
6561                                           +  0.5*(fgkEndCapSideCoverLength[2]
6562                                           +               fgkEndCapCoverPlateWidth[1]
6563                                           -       fgkEndCapCoverPlateWidth[0])
6564                                           -      (fgkEndCapCoverPlateWidth[1]
6565                                           -       fgkEndCapCoverPlateWidth[0]);
6566   endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6567                                                 + 2.*fgkEndCapCoolingTubeRadiusMax
6568                                                 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6569                                                 +      fgkEndCapSideCoverWidth[1]
6570                                                 +      fgkEndCapSideCoverThickness
6571                                                 +      fgkEndCapKaptonFoilThickness);
6572   TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6573                                                           +                              2.0* fgkEndCapCoverPlateLength[2]
6574                                                           +              2.0* fgkEndCapSideCoverThickness),
6575                                                                          0.5* (fgkEndCapSideCoverLength[2]
6576                                                           +                    fgkEndCapCoverPlateWidth[1]
6577                                                           -                                        fgkEndCapCoverPlateWidth[0]),
6578                                                                                          0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6579                                                       +                                    fgkEndCapSideCoverWidth[1]
6580                                                           +                                       fgkEndCapSideCoverThickness
6581                                                       +                                   fgkEndCapKaptonFoilThickness),
6582                                                                                          endcapmotherorigin);
6583   TGeoVolume** endcapassembly;
6584   endcapassembly = new TGeoVolume*[4];
6585   endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6586                                                                                         endcapmothershape,fSSDAir);
6587   endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6588                                                                                         endcapmothershape,fSSDAir);
6589   endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6590                                                                                         endcapmothershape,fSSDAir);
6591   endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6592                                                                                         endcapmothershape,fSSDAir);
6593  /////////////////////////////////
6594  // endcapassembly[0]:  Container End Cap Layer 5 Bellegarde Side
6595  // endcapassembly[1]:  Container End Cap Layer 5 Gex Side
6596  // endcapassembly[2]:  Container End Cap Layer 6 Bellegarde Side
6597  // endcapassembly[3]:  Container End Cap Layer 6 Gex Side
6598  /////////////////////////////////
6599   /////////////////////////////////////////////////////
6600   // Placing Endcap Cover Plate
6601   /////////////////////////////////////////////////////
6602   TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6603   TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6604   endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6605   TGeoCombiTrans* endcapcoverplatecombitrans =
6606                                                   new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6607                                                                                          endcapcoverplaterot);
6608   TGeoTranslation* endcapcoverplatetrans =
6609                                                   new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6610   TGeoHMatrix* endcapcoverplatematrix =
6611                                                   new TGeoHMatrix((*endcapcoverplatetrans)
6612                                                                           *       (*endcapcoverplatecombitrans));
6613   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6614   /////////////////////////////////////////////////////
6615   // Placing Endcap Side Cover
6616   /////////////////////////////////////////////////////
6617   TGeoVolume* endcapsidecover = GetEndCapSideCover();
6618   TGeoRotation* endcapsidecoverot[2];
6619   TGeoCombiTrans* endcapsidecovercombitrans[3];
6620   for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6621   endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6622   endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6623                                                                                         - 0.5*(fgkEndCapCoverPlateWidth[0]
6624                                                                                         - fgkEndCapCoverPlateWidth[2]
6625                                                                                     - (kendcapcoverplatesmallholenumber-1)
6626                                                                                         * fgkEndCapCoverPlateSmallHoleSeparation[2])
6627                                                                                         + 0.*fgkEndCapCoverPlateWidth[0]
6628                                                                                         + fgkEndCapSideCoverLength[2],
6629                                                                                           0.5*(fgkEndCapSideCoverThickness
6630                                                                                         + fgkEndCapCoverPlateThickness)
6631                                                                                         - 0.5*fgkEndCapCoverPlateThickness,
6632                                                                                           endcapsidecoverot[0]);
6633   endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6634   endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6635                                                                                                         0.5*fgkEndCapCoverPlateThickness
6636                                                                                                         -fgkEndCapSideCoverWidth[1],
6637                                                                                                         endcapsidecoverot[1]);
6638   endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6639                                                                                                         +fgkEndCapCoverPlateLength[3]
6640                                                                                                         +2.*fgkEndCapCoverPlateLength[2]
6641                                                                                                         +fgkEndCapSideCoverThickness,0.0,
6642                                                                                                         0.5*fgkEndCapCoverPlateThickness
6643                                                                                                         -fgkEndCapSideCoverWidth[1],
6644                                                                                                         endcapsidecoverot[1]);
6645   TGeoHMatrix* endcapsidecovermatrix[2];
6646   for(Int_t i=0; i<2; i++){
6647    endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6648                                                         *                                 (*endcapsidecovercombitrans[0]));
6649         for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6650                                                                                                                 endcapsidecovermatrix[i]);
6651   }
6652   /////////////////////////////////////////////////////
6653   // Placing Endcap Cooling Tube
6654   /////////////////////////////////////////////////////
6655   TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6656   TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6657   endcapcoolingtuberot->SetAngles(0.,180.,0.);
6658   TGeoCombiTrans* endcapccolingtubecombitrans
6659                                                 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6660                                                 + fgkEndCapCoolingTubeAxialRadius[1])
6661                                                 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6662                                                 - fgkEndCapCoolingTubeToCoverSide,
6663                                                   fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6664                                                 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6665   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6666                                                                                                           endcapccolingtubecombitrans);
6667   /////////////////////////////////////////////////////
6668   // Placing Screws
6669   /////////////////////////////////////////////////////
6670   Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6671                                                                            fgkEndCapCoverPlateScrewRadiusMin};
6672   Int_t screwcoverplatedgesnumber[2] = {20,20};
6673   Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6674                                                                                 fgkEndCapCoverPlateThickness
6675                                                                          +  fgkEndCapCoolingTubeRadiusMax};
6676   TGeoXtru* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
6677                                                                                                  screwcoverplatedgesnumber,
6678                                                                                                  screwcoverplatesection);
6679   TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6680                                                                                            screwcoverplateshape,
6681                                                                                            fSSDCoolingTubePhynox);
6682   screwcoverplate->SetLineColor(12);
6683   Double_t transx[4] = {0,
6684                                                 fgkEndCapCoverPlateSmallHoleSeparation[0],
6685                                                 fgkEndCapCoverPlateSmallHoleSeparation[0]
6686                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1],
6687                                          2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6688                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1]};
6689   const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6690 //  TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6691   TGeoTranslation*** endcapcoverplatescrewtrans;
6692   endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6693   Int_t index = 0;
6694   for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6695         endcapcoverplatescrewtrans[i] =
6696                                         new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6697     for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6698                 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6699         if(index==1||index==9||index==28||index==36){
6700                         endcapcoverplatescrewtrans[i][j] =
6701                                 new TGeoTranslation(transx[i],
6702                                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6703                                                                         fgkEndCapSideCoverThickness);
6704                 }
6705                 else{
6706                         endcapcoverplatescrewtrans[i][j] =
6707                                 new TGeoTranslation(transx[i],
6708                                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6709                                                                         0.);
6710                 }
6711             if(index!=19)
6712                 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6713                                                                                           endcapcoverplatescrewtrans[i][j]);
6714         }
6715   }
6716   /////////////////////////////////////////////////////
6717   // Placing Cover Plate Clips
6718   /////////////////////////////////////////////////////
6719   TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6720                                                                                                          0.5*fgkEndCapCoverPlateClipWidth,
6721                                                                                                          0.5*fgkEndCapSideCoverThickness);
6722   TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6723                                                                                                         endcapcoverplateclipshape,
6724                                                                                                         fSSDCoolingTubePhynox);
6725   TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6726                                                                                                          0.5*fgkEndCapCoverPlateDownClipWidth,
6727                                                                                                          0.5*fgkEndCapSideCoverThickness);
6728   TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6729                                                                                                         endcapcoverplatedownclipshape,
6730                                                                                                         fSSDCoolingTubePhynox);
6731   TGeoTranslation* endcapcoverplatecliptrans[4];
6732   endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6733                                                            -                     fgkEndCapCoverPlateLength[0]
6734                                                            -                     fgkEndCapSideCoverThickness,
6735                                                                                                          0.0,
6736                                                                                                  0.5*(fgkEndCapSideCoverThickness
6737                                                            +                                              fgkEndCapCoverPlateThickness));
6738   endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6739                                                            -                     fgkEndCapCoverPlateLength[0]
6740                                                            -                     fgkEndCapSideCoverThickness,
6741                                                                                                          (kendcapcoverplatescrewnumber[1]-1)
6742                                                            *                                     fgkEndCapSideCoverWidth[5],
6743                                                                                                  0.5*(fgkEndCapSideCoverThickness
6744                                                            +                                              fgkEndCapCoverPlateThickness));
6745   endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6746                                                            -                     fgkEndCapCoverPlateLength[0]
6747                                                            +                                     fgkEndCapCoverPlateLength[1]
6748                                                            +                              2.*fgkEndCapCoverPlateLength[0]
6749                                                            -                                     fgkEndCapCoverPlateClipLength
6750                                                            +                                 fgkEndCapSideCoverThickness,
6751                                                                                                          0.0,
6752                                                                                                  0.5*(fgkEndCapSideCoverThickness
6753                                                            +                                              fgkEndCapCoverPlateThickness));
6754   endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6755                                                            -                     fgkEndCapCoverPlateLength[0]
6756                                                            +                                     fgkEndCapCoverPlateLength[1]
6757                                                            +                              2.*fgkEndCapCoverPlateLength[0]
6758                                                            -                                     fgkEndCapCoverPlateClipLength
6759                                                            +                                 fgkEndCapSideCoverThickness,
6760                                                                                                          (kendcapcoverplatescrewnumber[1]-1)
6761                                                            *                                     fgkEndCapSideCoverWidth[5],
6762                                                                                                  0.5*(fgkEndCapSideCoverThickness
6763                                                            +                                              fgkEndCapCoverPlateThickness));
6764   endcapcoverplateclip->SetLineColor(fColorPhynox);
6765   endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6766   for(Int_t i=0; i<4; i++)
6767         for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6768                                                                                                    endcapcoverplatecliptrans[i]);
6769   TGeoTranslation* endcapcoverplatedowncliptrans[4];
6770   endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6771                                                                    -                     fgkEndCapCoverPlateLength[0]
6772                                                                    -                     fgkEndCapSideCoverThickness,
6773                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6774                                                                    -                                 fgkEndCapCoverPlateClipWidth),
6775                                                                                                         0.5*(fgkEndCapSideCoverThickness
6776                                                                +                                         fgkEndCapCoverPlateThickness)
6777                                                                    -                     fgkEndCapSideCoverWidth[1]
6778                                                                    -                                     fgkEndCapSideCoverThickness);
6779   endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6780                                                                    -                     fgkEndCapCoverPlateLength[0]
6781                                                                    -                     fgkEndCapSideCoverThickness,
6782                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6783                                                                    -                                 fgkEndCapCoverPlateClipWidth)
6784                                                                    +                            fgkEndCapSideCoverLength[2]
6785                                                                    -                            fgkEndCapCoverPlateDownClipWidth,
6786                                                                                                         0.5*(fgkEndCapSideCoverThickness
6787                                                                +                                         fgkEndCapCoverPlateThickness)
6788                                                                    -                     fgkEndCapSideCoverWidth[1]
6789                                                                    -                                     fgkEndCapSideCoverThickness);
6790   endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6791                                                                    -                     fgkEndCapCoverPlateLength[0]
6792                                                                    +                     fgkEndCapSideCoverThickness
6793                                                                    +                     fgkEndCapCoverPlateLength[1]
6794                                                                    +                 2.0*fgkEndCapCoverPlateLength[0]
6795                                                                    -                     fgkEndCapCoverPlateDownClipLength,
6796                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6797                                                                    -                                 fgkEndCapCoverPlateClipWidth),
6798                                                                                                         0.5*(fgkEndCapSideCoverThickness
6799                                                                +                                         fgkEndCapCoverPlateThickness)
6800                                                                    -                     fgkEndCapSideCoverWidth[1]
6801                                                                    -                                     fgkEndCapSideCoverThickness);
6802   endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6803                                                                    -                     fgkEndCapCoverPlateLength[0]
6804                                                                    +                     fgkEndCapSideCoverThickness
6805                                                                    +                     fgkEndCapCoverPlateLength[1]
6806                                                                    +                 2.0*fgkEndCapCoverPlateLength[0]
6807                                                                    -                     fgkEndCapCoverPlateDownClipLength,
6808                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6809                                                                    -                                 fgkEndCapCoverPlateClipWidth)
6810                                                                    +                                 fgkEndCapSideCoverLength[2]
6811                                                                    -                                 fgkEndCapCoverPlateDownClipWidth,
6812                                                                                                         0.5*(fgkEndCapSideCoverThickness
6813                                                                +                                         fgkEndCapCoverPlateThickness)
6814                                                                    -                     fgkEndCapSideCoverWidth[1]
6815                                                                    -                                     fgkEndCapSideCoverThickness);
6816   for(Int_t i=0; i<4; i++)
6817         for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6818                                                                                                    endcapcoverplatedowncliptrans[i]);
6819   /////////////////////////////////////////////////////
6820   // Placing Kapton Foil
6821   /////////////////////////////////////////////////////
6822   TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6823                                                                                                  0.5*fgkEndCapKaptonFoilWidth,
6824                                                                                                  0.5*fgkEndCapKaptonFoilThickness);
6825   TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6826                                                                                                 endcapkaptonfoilshape,
6827                                                                                                 fSSDKaptonFlexMedium);
6828   endcapkaptonfoil->SetLineColor(8);
6829   TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6830                                                                                                                            0.5*fgkEndCapKaptonFoilWidth
6831                                                                                  -                     0.5*fgkEndCapCoverPlateClipWidth,
6832                                                                                                                            0.5*fgkEndCapCoverPlateThickness
6833                                                                                  -                     0.5*fgkEndCapKaptonFoilThickness
6834                                                                              -                     fgkEndCapSideCoverWidth[1]
6835                                                                                  -                     fgkEndCapSideCoverThickness);
6836   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6837   /////////////////////////////////////////////////////////////
6838   // Placing Electronic Tubes
6839   /////////////////////////////////////////////////////////////
6840   Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6841                                                                              - fgkEndCapInterfaceCardBThickness
6842                                                                              - 9.*fgkEndCapStripConnectionThickness
6843                                                                              - 8.*fgkEndCapCardElectBoardBackThickness,
6844                                                                                fgkEndCapKaptonFoilWidth
6845                                                                              - fgkEndCapInterfaceCardBThickness
6846                                                                              - 9.*fgkEndCapStripConnectionThickness
6847                                                                              - 8.*fgkEndCapCardElectBoardBackThickness
6848                                                                                  - fgkEndCapInterfaceElectBoardCardBThickness};
6849   TGeoVolume* endcapeffectivecables[2];
6850   endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6851                                                                                          fgkEndCapEffectiveCableRadiusMax,
6852                                                                                          endcapeffectivecableswidth[0],
6853                                                                                          10,"EndCapEffectiveCables1");
6854   endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6855                                                                                          fgkEndCapEffectiveCableRadiusMax,
6856                                                                                          endcapeffectivecableswidth[1],
6857                                                                                          25,"EndCapEffectiveCables2");
6858   TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6859   TGeoTranslation* endcapeffectivecablestrans[2];
6860   endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6861                                           -                                                        0.5*endcapeffectivecableswidth[0]
6862                                           -                            0.5*(fgkEndCapCoverPlateWidth[0]
6863                                           -                                                               fgkEndCapCoverPlateWidth[2]
6864                                           -                                             (kendcapcoverplatesmallholenumber-1)
6865                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6866                                           +                                             fgkEndCapSideCoverLength[2],
6867                                           -                     0.5*fgkEndCapCoverPlateThickness
6868                                           -                                             (fgkEndCapCardElectBoardBackWidth[0]
6869                                           -                                              fgkEndCapInterfaceCardBWidth[0]
6870                                           -                                              fgkEndCapInterfaceCardBWidth[1]));
6871   endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6872                                           -                                                        0.5*endcapeffectivecableswidth[1]
6873                                           -                            0.5*(fgkEndCapCoverPlateWidth[0]
6874                                           -                                                               fgkEndCapCoverPlateWidth[2]
6875                                           -                                             (kendcapcoverplatesmallholenumber-1)
6876                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6877                                           +                                         fgkEndCapSideCoverLength[2],
6878                                           -                     0.5*fgkEndCapCoverPlateThickness
6879                                           -                                             (fgkEndCapCardElectBoardBackWidth[0]
6880                                           -                                              fgkEndCapInterfaceCardBWidth[0])
6881                                           -                     0.5*fgkEndCapInterfaceCardBWidth[2]);
6882   endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6883   TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6884   endcapeffectivecablescombitrans[0]  = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6885                                                                                                                    *endcapeffectivecablesrot);
6886   endcapeffectivecablescombitrans[1]  = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6887                                                                                                                    *endcapeffectivecablesrot);
6888   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6889                                                                                                           endcapeffectivecablescombitrans[0]);
6890   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6891                                                                                                           endcapeffectivecablescombitrans[1]);
6892   /////////////////////////////////////////////////////////////
6893   // Placing End Cap Cards
6894   /////////////////////////////////////////////////////////////
6895   TGeoVolume** endcapcards = GetEndCapCards();
6896   TGeoRotation* endcapcardsrot[2];
6897   for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6898   endcapcardsrot[0]->SetAngles(90.,0.,0.);
6899   TGeoTranslation* endcapcardstrans[2];
6900   endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6901                                                                                         -  fgkEndCapCardElectBoardBackLength[0]));
6902   TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6903   endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6904   TGeoHMatrix* endcapcardsmatrix[2];
6905   endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6906   Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6907                                                   - fgkEndCapCardJMDConnectorLength[0]
6908                                                   - fgkEndCapInterfaceCardBThickness
6909                                                   - 9.*fgkEndCapStripConnectionThickness
6910                                                   - 8.*fgkEndCapCardElectBoardBackThickness;
6911   endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6912                                           -                                             fgkEndCapCoverPlateLength[0]
6913                                           + 0.5 *              (fgkEndCapCoverPlateLength[3]
6914                                           + 2.0 *                               fgkEndCapCoverPlateLength[2]),
6915                                           -                                                     stiffenertransx-fgkEndCapStiffenerWidth
6916                                           -                                                               fgkEndCapCardJMDConnectorLength[0]
6917                                           -                                                               fgkEndCapInterfaceCardBThickness
6918                                           -     2.0 *                                             fgkEndCapStripConnectionThickness
6919                                           - 1.5 *                                             fgkEndCapInterfaceCardBThickness
6920                                           - 0.5 *                                                (fgkEndCapCoverPlateWidth[0]
6921                                           -                                                               fgkEndCapCoverPlateWidth[2]
6922                                           -                                             (kendcapcoverplatesmallholenumber-1)
6923                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6924                                           +                     fgkEndCapKaptonFoilWidth,
6925                                                                                           0.5*fgkEndCapCoverPlateThickness
6926                                           -                                                     fgkEndCapSideCoverWidth[1]);
6927   endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6928   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6929    /////////////////////////////////////////////////////////////
6930   // Deallocating memory
6931   /////////////////////////////////////////////////////////////
6932   delete endcapcoverplaterot;
6933   delete endcapcoverplatecombitrans;
6934   delete endcapcoverplatetrans;
6935   for(Int_t i=0; i<3; i++){
6936    delete endcapsidecovercombitrans[i];
6937    if(i<2) delete endcapsidecoverot[i];
6938   }
6939   for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6940   for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6941   delete endcapcardsmatrix[0];
6942   return endcapassembly;
6943  }
6944  ////////////////////////////////////////////////////////////////////////////////
6945  TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6946                                                                                                                         Double_t radiusmax,
6947                                                                                                                         Double_t width,
6948                                                                                                                         Int_t ncables,
6949                                                                                                                         char* volname){
6950   /////////////////////////////////////////////////////////////
6951   // Generating EndCap High Voltage Tubes
6952   /////////////////////////////////////////////////////////////
6953   Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
6954   Double_t effectiveouteradius = TMath::Sqrt(TMath::Power(effectiveinneradius,2.)
6955                                                            +             TMath::Power(radiusmax,2.)
6956                                -             TMath::Power(radiusmin,2.));
6957   TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6958   TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6959                                                                                                    effectiveouteradius,0.5*width);
6960   TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6961                                                                                                 effectiveinnertubeshape,
6962                                                                                                 fSSDStiffenerConnectorMedium);
6963   effectiveinnertube->SetLineColor(41);
6964   TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6965                                                                                                 effectiveoutertubeshape,
6966                                                                                                 fSSDKaptonChipCableMedium);
6967   effectiveoutertube->SetLineColor(39);
6968   TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6969   TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6970   effectivemothertube->AddNode(effectiveinnertube,1);
6971   effectivemothertube->AddNode(effectiveoutertube,1);
6972   return effectivemothertube;
6973  }
6974  ////////////////////////////////////////////////////////////////////////////////
6975  TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6976   /////////////////////////////////////////////////////////////
6977   // Generating EndCap Support Layer 5 and Layer 6
6978   /////////////////////////////////////////////////////////////
6979   const Int_t knedges = 5;
6980   ///////////////////////////////////////////////
6981   // Setting the vertices for TGeoXtru Up Volume
6982   ///////////////////////////////////////////////
6983   const Int_t klayernumber = 2;
6984   Double_t xupvertex[klayernumber][knedges+3];
6985   Double_t yupvertex[klayernumber][knedges+3];
6986   Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6987   Double_t middledgeangle[klayernumber] = {0.0,0.0};
6988   Double_t middlepsi[klayernumber] = {0.0,0.0};
6989   for(Int_t i=0; i<klayernumber; i++){
6990         xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6991         xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6992         xupvertex[i][2] = -xupvertex[i][1];
6993         xupvertex[i][3] = -xupvertex[i][0];
6994
6995         yupvertex[i][0] =  fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6996         yupvertex[i][1] =  0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6997         yupvertex[i][2] =  yupvertex[i][1];
6998         yupvertex[i][3] =  yupvertex[i][0];
6999
7000     middledgeangle[i] = upedgeangle[i]/knedges;
7001     middlepsi[i] = 90.0-0.5*upedgeangle[i];
7002     for(Int_t j=1; j<knedges; j++){
7003                 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
7004                 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
7005         }
7006   }
7007   ////////////////////////////////////
7008   // Generating Up TGeoXtru
7009   ////////////////////////////////////
7010   TGeoXtru* upendcapsupportshape[klayernumber];
7011   TGeoVolume* upendcapsupport[klayernumber];
7012   char upendcapsupportname[30];
7013   for(Int_t i=0; i<klayernumber; i++){
7014    upendcapsupportshape[i] = new TGeoXtru(2);
7015    sprintf(upendcapsupportname,"UpEndCapSupportPieceLayer%i",i+5);
7016    upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
7017    upendcapsupportshape[i]->DefineSection(0,0.);
7018    upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
7019    upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
7020                                                                         fSSDCoolingTubePhynox);
7021 //   upendcapsupport[i]->SetLineColor(fColorPhynox);
7022    upendcapsupport[i]->SetLineColor(5);
7023   }
7024   ///////////////////////////////////////////////
7025   // Setting the vertices for TGeoXtru Down Volume
7026   ///////////////////////////////////////////////
7027   Double_t xdownvertex[klayernumber][2*(knedges+1)];
7028   Double_t ydownvertex[klayernumber][2*(knedges+1)];
7029   for(Int_t i=0; i<klayernumber; i++){
7030         xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
7031         xdownvertex[i][1] =  xupvertex[i][0];
7032         ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
7033         ydownvertex[i][1] =  yupvertex[i][0];
7034         for(Int_t j=0; j<knedges; j++){
7035                 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
7036                 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
7037         }
7038         for(Int_t j=0; j<knedges; j++){
7039                 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
7040                                                                         * CosD(middlepsi[i]+j*middledgeangle[i]);
7041                 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
7042                                                                         * SinD(middlepsi[i]+j*middledgeangle[i]);
7043         }
7044   }
7045   ////////////////////////////////////
7046   // Generating Down TGeoXtru
7047   ////////////////////////////////////
7048   TGeoXtru* downendcapsupportshape[klayernumber];
7049   TGeoVolume* downendcapsupport[klayernumber];
7050   char downendcapsupportname[30];
7051   for(Int_t i=0; i<klayernumber; i++){
7052         downendcapsupportshape[i] = new TGeoXtru(2);
7053     sprintf(downendcapsupportname,"DownEndCapSupportPieceLayer%i",i+5);
7054         downendcapsupportshape[i] = new TGeoXtru(2);
7055         downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
7056     if(i==0){
7057                 downendcapsupportshape[i]->DefineSection(0,0.);
7058                 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
7059     }
7060         else{
7061                 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
7062                                                                  -                 fgkEndCapSupportLowWidth[i]);
7063                 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
7064         }
7065     downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
7066                                                                 downendcapsupportshape[i],fSSDCoolingTubePhynox);
7067 //      downendcapsupport[i]->SetLineColor(fColorPhynox);
7068         downendcapsupport[i]->SetLineColor(5);
7069   }
7070   ///////////////////////////////////////////////
7071   // Setting TGeoPgon Volume
7072   ///////////////////////////////////////////////
7073   const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
7074                                                                                                    fgkSSDLay6LadderNumber};
7075   TGeoPgon* endcapsupportmothershape[klayernumber];
7076   TGeoVolume** endcapsupportmother;
7077   endcapsupportmother = new TGeoVolume*[klayernumber];
7078   char endcapsupportmothername[30];
7079   for(Int_t i=0; i<klayernumber; i++){
7080         endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
7081     sprintf(endcapsupportmothername,"EndCapSupportMotherLayer%i",i+5);
7082         endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
7083     endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
7084                                                                                           ydownvertex[i][0],yupvertex[i][1]);
7085     endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
7086                                                                                         fSSDCoolingTubePhynox);
7087   }
7088   ////////////////////////////////////
7089   TGeoRotation** endcapsupportrot[klayernumber];
7090   for(Int_t i=0; i<2; i++){
7091         endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
7092         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
7093            endcapsupportrot[i][j] = new TGeoRotation();
7094            endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
7095        endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
7096        endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
7097         }
7098   }
7099   return endcapsupportmother;
7100  }
7101  ////////////////////////////////////////////////////////////////////////////////
7102  void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
7103   /////////////////////////////////////////////////////////////
7104   // Setting End Cap Support Layer 5 and 6.
7105   /////////////////////////////////////////////////////////////
7106   const Int_t kendcapcoverplatesmallholenumber = 9;
7107   const Int_t klayernumber = 2;
7108   const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
7109                                                                                                    fgkSSDLay6LadderNumber};
7110   Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
7111                                                                                 360.0/kssdlayladdernumber[1]};
7112   TGeoVolume** endcapsupport = EndCapSupport();
7113   TGeoVolume** endcapassembly = GetEndCapAssembly();
7114   TGeoPgon* endcapsupportshape[klayernumber];
7115   Double_t* radiusmin[klayernumber];
7116   Double_t* radiusmax[klayernumber];
7117   for(Int_t i=0; i<klayernumber; i++){
7118     endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
7119         radiusmin[i] = endcapsupportshape[i]->GetRmin();
7120         radiusmax[i] = endcapsupportshape[i]->GetRmax();
7121   }
7122   TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
7123   Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
7124                                                                           endcapassemblyshape->GetDY(),
7125                                                                           endcapassemblyshape->GetDZ()};
7126   ///////////////////////////////////////////////
7127   // Setting TGeoPgon Volume for Mother Container
7128   ///////////////////////////////////////////////
7129   TGeoPgon* endcapsupportsystemshape[klayernumber];
7130   char endcapsupportsystemothername[30];
7131   for(Int_t i=0; i<klayernumber; i++){
7132         endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
7133     sprintf(endcapsupportsystemothername,"EndCapSupportSystemLayer%i",i+5);
7134         endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
7135                                                                                              - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
7136                                                                                           (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7137                                                                                            +2.*endcapassemblycenter[2])
7138                                                                                            /CosD(0.5*upedgeangle[i]));
7139     endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
7140                                                                                                  -(fgkEndCapCoverPlateWidth[1]
7141                                                                                              - fgkEndCapCoverPlateWidth[0]),
7142                                                                                            *radiusmin[i],
7143                                                                                           (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7144                                                                                            +2.*endcapassemblycenter[2])
7145                                                                                            /CosD(0.5*upedgeangle[i]));
7146   }
7147   fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
7148                                                                           endcapsupportsystemshape[0],fSSDAir);
7149   fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
7150                                                                           endcapsupportsystemshape[0],fSSDAir);
7151   fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
7152                                                                           endcapsupportsystemshape[1],fSSDAir);
7153   fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
7154                                                                           endcapsupportsystemshape[1],fSSDAir);
7155   ///////////////////////////////////////////////
7156   TGeoTranslation* endcapassemblytrans[klayernumber];
7157   for(Int_t i=0; i<klayernumber; i++)
7158         endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
7159                                                                            -  fgkEndCapSideCoverThickness
7160                                                                            +  endcapassemblycenter[0],
7161                                                                            -  0.5*fgkEndCapCoverPlateThickness
7162                                                                            -  2.0*fgkEndCapCoolingTubeRadiusMax
7163                                                                            +  2.0*endcapassemblycenter[2]
7164                                                                            +  0.5*fgkEndCapSupportLength[i]
7165                                                                            /  TanD(0.5*upedgeangle[i]),
7166                                                                                   0.5*(fgkEndCapCoverPlateWidth[0]
7167                                                                            -  fgkEndCapCoverPlateWidth[2]
7168                                                                            - (kendcapcoverplatesmallholenumber-1)
7169                                                                            *  fgkEndCapCoverPlateSmallHoleSeparation[2]));
7170   TGeoRotation** endcapassemblyrot[klayernumber];
7171   TGeoHMatrix** endcapassemblymatrix[klayernumber];
7172   for(Int_t i=0; i<klayernumber; i++){
7173    endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
7174    endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
7175    for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
7176    endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
7177    endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
7178    endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
7179    endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
7180    for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
7181         endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
7182         endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
7183    }
7184   }
7185   TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
7186                                                         fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
7187   for(Int_t i=0; i<2*klayernumber; i++){
7188         for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
7189                 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
7190                                                                                                                                            endcapassemblymatrix[1][j+2]);
7191         }
7192         fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
7193   }
7194    /////////////////////////////////////////////////////////////
7195   // Deallocating memory
7196   /////////////////////////////////////////////////////////////
7197   for(Int_t i=0; i<klayernumber; i++){
7198         for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
7199                 delete endcapassemblyrot[i][j];
7200         }
7201         delete endcapassemblyrot[i];
7202         delete endcapassemblymatrix[i][0];
7203         delete endcapassemblymatrix[i][1];
7204   }
7205   /////////////////////////////////////////////////////////////
7206   }
7207   void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
7208   /////////////////////////////////////////////////////////////
7209   // Setting End Cap Support + End Cap Assembly of Layer 5.
7210   /////////////////////////////////////////////////////////////
7211   if (! moth) {
7212     printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer5, mother is null!\n");
7213     return;
7214   };
7215   if(!fgkEndCapSupportSystem[0]) SetEndCapSupportAssembly();
7216   if(!fgkEndCapSupportSystem[1]) SetEndCapSupportAssembly();
7217   TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7218   endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7219                                                                                                 fgkEndCapSupportCenterLay5ITSPosition
7220                                                                            +            fgkEndCapSupportCenterLay5Position
7221                                                                            -            fgkEndCapSideCoverLength[2]);
7222   endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7223                                                                                                 fgkEndCapSideCoverLength[2]
7224                                                                            -        fgkEndCapSupportCenterLay5Position
7225                                                                            -        fgkEndCapSupportCenterLay5ITSPosition);
7226   TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7227   endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7228   TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7229         new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7230   moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7231   moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7232    /////////////////////////////////////////////////////////////
7233   // Deallocating memory
7234   /////////////////////////////////////////////////////////////
7235   delete endcapsupportsystemrot;
7236   delete endcapsupportsystemITSCentertrans[1];
7237  }
7238   /////////////////////////////////////////////////////////////
7239   void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7240   /////////////////////////////////////////////////////////////
7241   // Setting End Cap Support + End Cap Assembly of Layer 6.
7242   /////////////////////////////////////////////////////////////
7243   if (! moth) {
7244     printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer6, mother is null!\n");
7245     return;
7246   };
7247   if(!fgkEndCapSupportSystem[2]) SetEndCapSupportAssembly();
7248   if(!fgkEndCapSupportSystem[3]) SetEndCapSupportAssembly();
7249   TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7250   endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7251                                                                                                 fgkEndCapSupportCenterLay6ITSPosition
7252                                                                            +            fgkEndCapSupportCenterLay6Position
7253                                                                            -            fgkEndCapSideCoverLength[2]);
7254   endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7255                                                                                                 fgkEndCapSideCoverLength[2]
7256                                                                            -        fgkEndCapSupportCenterLay6Position
7257                                                                            -        fgkEndCapSupportCenterLay6ITSPosition);
7258   TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7259   endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7260   TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7261         new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7262   moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7263   moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7264    /////////////////////////////////////////////////////////////
7265   // Deallocating memory
7266   /////////////////////////////////////////////////////////////
7267   delete endcapsupportsystemrot;
7268   delete endcapsupportsystemITSCentertrans[1];
7269  }
7270  ////////////////////////////////////////////////////////////////////////////////
7271  void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7272   /////////////////////////////////////////////////////////////
7273   // Setting Ladder Support of Layer 5.
7274   /////////////////////////////////////////////////////////////
7275   if (! moth) {
7276     printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer5, mother is null!\n");
7277     return;
7278   };
7279   if(!fLay5LadderSupportRing) SetLadderSupport(100);
7280   fMotherVol = moth;
7281   TGeoTranslation* centerITSRingSupportLay5trans[2];
7282   for(Int_t i=0; i<2; i++){
7283         centerITSRingSupportLay5trans[i] =
7284                 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7285     moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7286   }
7287  }
7288  ////////////////////////////////////////////////////////////////////////////////
7289  void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7290   /////////////////////////////////////////////////////////////
7291   // Setting Ladder Support of Layer 6.
7292   /////////////////////////////////////////////////////////////
7293   if (! moth) {
7294     printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer6, mother is null!\n");
7295     return;
7296   };
7297   if(!fLay6LadderSupportRing) SetLadderSupport(100);
7298   fMotherVol = moth;
7299   TGeoTranslation* centerITSRingSupportLay6trans[2];
7300   for(Int_t i=0; i<2; i++){
7301         centerITSRingSupportLay6trans[i] =
7302                 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7303     moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7304   }
7305  }
7306  ////////////////////////////////////////////////////////////////////////////////
7307 TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
7308                                                                         Double_t height, char* shapename, Int_t isign) const{
7309   /////////////////////////////////////////////////////////////
7310   // Method generating an Arb shape
7311   /////////////////////////////////////////////////////////////
7312   const Int_t kvertexnumber = 8;
7313   const Int_t ktransvectnumber = 2;
7314   TVector3* vertex[kvertexnumber];
7315   TVector3* transvector[2];
7316   for(Int_t i=0; i<ktransvectnumber; i++) transvector[i] = new TVector3(0.,width[i]);
7317   /////////////////////////////////////////////////////////////
7318   //Setting the vertices for TGeoArb8
7319   /////////////////////////////////////////////////////////////
7320   vertex[0] = new TVector3(*vertexpos[0]);
7321   vertex[1] = new TVector3(*vertexpos[1]);
7322   vertex[2] = new TVector3(*vertex[1]+isign*(*transvector[0]));
7323   vertex[3] = new TVector3(*vertex[0]+isign*(*transvector[0]));
7324   vertex[4] = new TVector3(*vertexpos[2]);
7325   vertex[5] = new TVector3(*vertexpos[3]);
7326   vertex[6] = new TVector3(*vertex[5]+isign*(*transvector[1]));
7327   vertex[7] = new TVector3(*vertex[4]+isign*(*transvector[1]));
7328   /////////////////////////////////////////////////////////////
7329   TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
7330   for(Int_t i = 0; i<kvertexnumber;i++)
7331                                                         arbshape->SetVertex(i,vertex[i]->X(),vertex[i]->Y());
7332   /////////////////////////////////////////////////////////////
7333   // Deallocating memory
7334   /////////////////////////////////////////////////////////////
7335   for(Int_t i=0; i< kvertexnumber; i++) delete vertex[i];
7336   for(Int_t i=0; i< ktransvectnumber; i++) delete transvector[i];
7337   /////////////////////////////////////////////////////////////
7338   return arbshape;
7339 }
7340 ///////////////////////////////////////////////////////////////////////////////
7341 TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
7342                                                                 Double_t rmax, Int_t nedges, Double_t height){
7343   /////////////////////////////////////////////////////////////
7344   // Method generating Arc shape
7345   /////////////////////////////////////////////////////////////
7346         const Int_t kvertexnumber = 2*nedges+2;
7347         TGeoXtru* arcshape = new TGeoXtru(2);
7348         TVector3** vertexposition[2];
7349         for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
7350         Double_t angle = 0.;
7351     for(Int_t i=0; i<nedges+1; i++){
7352                 angle = 90.+0.5*phi-i*(phi/nedges);
7353                 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
7354                 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
7355         }
7356         Double_t *xvertexpoints = new Double_t[kvertexnumber];
7357         Double_t *yvertexpoints = new Double_t[kvertexnumber];
7358         for(Int_t i=0; i<kvertexnumber; i++){
7359                 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
7360                                   yvertexpoints[i] = vertexposition[0][i]->Y();
7361                 }
7362                 else if(i>=1&&i<nedges+2)
7363                 {
7364                         xvertexpoints[i] = vertexposition[1][i-1]->X();
7365                         yvertexpoints[i] = vertexposition[1][i-1]->Y();
7366                 }
7367         else
7368                 {
7369                         xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
7370                         yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
7371                 }
7372     }
7373   arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
7374   arcshape->DefineSection(0,-0.5*height);
7375   arcshape->DefineSection(1,0.5*height);
7376   /////////////////////////////////////////////////////////////
7377   // Deallocating memory
7378   /////////////////////////////////////////////////////////////
7379   for(Int_t i=0; i<2; i++){
7380         for(Int_t j=0; j<nedges+1; j++)
7381                 delete vertexposition[i][j];
7382         delete [] vertexposition[i];
7383   }
7384   delete [] xvertexpoints;
7385   delete [] yvertexpoints;
7386   /////////////////////////////////////////////////////////////
7387         return arcshape;
7388 }
7389 ////////////////////////////////////////////////////////////////////////////////
7390 TGeoXtru* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
7391   ///////////////////////////////////////////////////////////////////////
7392   // Method Generating the Screw Shape
7393   // radius[0]: outer radius
7394   // radius[1]: inner radius
7395   // edgesnumber[0]: outer number of edges
7396   // edgesnumber[1]: inner number of edges
7397   // section[0]: lower section position
7398   // section[1]: higher section position
7399   ///////////////////////////////////////////////////////////////////////
7400   Double_t outradius = radius[0];
7401   Double_t inradius = radius[1];
7402   Int_t outvertexnumber = edgesnumber[0];
7403   Int_t invertexnumber = edgesnumber[1];
7404   Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
7405   Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
7406   for(Int_t i=0; i<outvertexnumber+1; i++){
7407         xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
7408         yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
7409   }
7410   for(Int_t i=0; i<invertexnumber+1; i++){
7411         xscrewvertex[outvertexnumber+i+1] = inradius*CosD(90.-i*360./invertexnumber);
7412         yscrewvertex[outvertexnumber+i+1] = inradius*SinD(90.-i*360./invertexnumber);
7413   }
7414   TGeoXtru* screwshape = new TGeoXtru(2);
7415   screwshape->DefinePolygon(outvertexnumber+invertexnumber+2,xscrewvertex,yscrewvertex);
7416   screwshape->DefineSection(0,section[0]);
7417   screwshape->DefineSection(1,section[1]);
7418   delete [] xscrewvertex;
7419   delete [] yscrewvertex;
7420   return screwshape;
7421 }
7422 ////////////////////////////////////////////////////////////////////////////////
7423 TGeoXtru* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
7424   ///////////////////////////////////////////////////////////////////////
7425   // Method Generating the Hole Shape
7426   // radius of the Hole
7427   // nedges: number of edges to approximate the circle
7428   ///////////////////////////////////////////////////////////////////////
7429   Int_t vertexnumber = nedges+6;
7430   Double_t* xholevertex = new Double_t[vertexnumber];
7431   Double_t* yholevertex = new Double_t[vertexnumber];
7432   xholevertex[0] = radius;
7433   xholevertex[1] = xholevertex[0];
7434   xholevertex[2] = -xholevertex[1];
7435   xholevertex[3] = xholevertex[2];
7436   xholevertex[4] = xholevertex[0];
7437   yholevertex[0] = 0.;
7438   yholevertex[1] = -radius;
7439   yholevertex[2] = yholevertex[1];
7440   yholevertex[3] = -yholevertex[1];
7441   yholevertex[4] = yholevertex[3];
7442   for(Int_t i=0; i<nedges+1; i++){
7443         xholevertex[i+5] = radius*CosD(i*360./nedges);
7444         yholevertex[i+5] = radius*SinD(i*360./nedges);
7445   }
7446   TGeoXtru* holeshape = new TGeoXtru(2);
7447   holeshape->DefinePolygon(vertexnumber,xholevertex,yholevertex);
7448   holeshape->DefineSection(0,section[0]);
7449   holeshape->DefineSection(1,section[1]);
7450   delete [] xholevertex;
7451   delete [] yholevertex;
7452   return holeshape;
7453 }
7454 ////////////////////////////////////////////////////////////////////////////////
7455 TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
7456   /////////////////////////////////////////////////////////////
7457   // Given an axis specified by param, it gives the reflection of the point
7458   // respect to the axis
7459   /////////////////////////////////////////////////////////////
7460   TVector3* n = new TVector3(param[0],param[1],param[2]);
7461   Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
7462   TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
7463   /////////////////////////////////////////////////////////////
7464   // Deallocating memory
7465   /////////////////////////////////////////////////////////////
7466   delete n;
7467   /////////////////////////////////////////////////////////////
7468   return reflectedvector;
7469 }
7470 ////////////////////////////////////////////////////////////////////////////////
7471 TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct,
7472                                                        Double_t dx,
7473                                                        Double_t dy,
7474                                                        Double_t dz) const{
7475   /////////////////////////////////////////////////////////////
7476   // Add a dx,dy,dz translation to the initial TGeoCombiTrans
7477   /////////////////////////////////////////////////////////////
7478   TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
7479   const Double_t *vect = hmatrix->GetTranslation();
7480   Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
7481   hmatrix->SetTranslation(newvect);
7482   TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
7483   delete hmatrix;
7484   return matrix;
7485 }
7486 ////////////////////////////////////////////////////////////////////////////////
7487 TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
7488   /////////////////////////////////////////////////////////////
7489   // Method returning the Medium type
7490   /////////////////////////////////////////////////////////////
7491   char ch[30];
7492   sprintf(ch, "ITS_%s",mediumName);
7493   TGeoMedium* medium =  gGeoManager->GetMedium(ch);
7494   if (! medium)
7495     printf("Error(AliITSv11GeometrySSD)::medium %s not found !\n", mediumName);
7496   return medium;
7497 }
7498 ////////////////////////////////////////////////////////////////////////////////
7499 void AliITSv11GeometrySSD::CreateMaterials(){
7500 ///////////////////////////////////
7501 // This part has to be modified
7502 ///////////////////////////////////
7503   ///////////////////////////////////
7504   // Silicon for Sensor
7505   ///////////////////////////////////
7506   fSSDSensorMedium = GetMedium("SI$");
7507   ///////////////////////////////////
7508   // Silicon Mixture for Sensor
7509   ///////////////////////////////////
7510   fSSDChipMedium = GetMedium("SPD SI CHIP$");
7511   fSSDChipGlueMedium = GetMedium("EPOXY$");
7512   ///////////////////////////////////
7513   // Stiffener Components Materials
7514   ///////////////////////////////////
7515   fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
7516   ///////////////////////////
7517   // Stiffener Connectors
7518   ///////////////////////////
7519   fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
7520   ////////////////////////////////
7521   // Stiffener 0603-1812 Capacitor
7522   ////////////////////////////////
7523   fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
7524   fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
7525   ///////////////////////////
7526   // Stiffener Hybrid Wire
7527   ///////////////////////////
7528   fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
7529   ///////////////////////////
7530   // Al for Cooling Block
7531   ///////////////////////////
7532   fSSDAlCoolBlockMedium = GetMedium("AL$");
7533   //////////////////////////////////////////////////////
7534   // Kapton and Al for Chip Cable Flex and Ladder Cables
7535   //////////////////////////////////////////////////////
7536   fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
7537   fSSDAlTraceChipCableMedium = GetMedium("AL$");
7538   fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
7539   fSSDAlTraceFlexMedium = GetMedium("AL$");
7540   fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
7541   fSSDAlTraceLadderCableMedium = GetMedium("AL$");
7542   /////////////////////////////////////////////////////////////////
7543   // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
7544   //////////////////////////////////////////////////////////////////
7545   fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
7546   /////////////////////////////////////////////////////////////////
7547   // G10 for Detector Leg, TubeHolder
7548   //////////////////////////////////////////////////////////////////
7549   fSSDTubeHolderMedium = GetMedium("G10FR4$");
7550   fSSDSensorSupportMedium = GetMedium("G10FR4$");
7551   fSSDMountingBlockMedium = GetMedium("G10FR4$");
7552   fSSDMountingBlockMedium = GetMedium("G10FR4$");
7553   /////////////////////////////////////////////////////////////////
7554   // Water and Phynox for Cooling Tube
7555   //////////////////////////////////////////////////////////////////
7556   fSSDCoolingTubeWater = GetMedium("WATER$");
7557   fSSDCoolingTubePhynox = GetMedium("INOX$");
7558   /////////////////////////////////////////////////////////////////////
7559   // Material for Support Rings
7560   /////////////////////////////////////////////////////////////////////
7561   fSSDSupportRingAl = GetMedium("AL$");
7562   /////////////////////////////////////////////////////////////////////
7563   fSSDAir = GetMedium("SDD AIR$");
7564   fCreateMaterials = kTRUE;
7565 }
7566 /////////////////////////////////////////////////////////////////////