ITS/AliITSv11GeometrySSD.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 //*************************************************************************
  19 // SSD geometry, based on ROOT geometrical modeler
  20 //
  21 // Enrico Cattaruzza                                    ecattar@ts.infn.it
  22 //*************************************************************************
  23 #include "TMath.h"
  24 #include "TGeoVolume.h"
  25 #include "TGeoMatrix.h"
  26 #include <TGeoManager.h>
  27 #include "TVector3.h"
  28 #include "TGeoArb8.h"
  29 #include "TList.h"
  30 #include "TGeoMatrix.h"
  31 #include "TGeoCompositeShape.h"
  32 #include "TGeoTube.h"
  33 #include "TGeoBBox.h"
  34 #include "TGeoXtru.h"
  35 #include "TGeoTorus.h"
  36 #include "TGeoPgon.h"
  37 #include "TRotation.h"
  38 #include "AliITSv11GeometrySSD.h"
  39 /////////////////////////////////////////////////////////////////////////////////
  40 // Names of the Sensitive Volumes of Layer 5 and Layer 6
  41 /////////////////////////////////////////////////////////////////////////////////
  42 const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName5 = "ITSssdSensitivL5";
  43 const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName6 = "ITSssdSensitivL6";
  44 /////////////////////////////////////////////////////////////////////////////////
  45 //Parameters for SSD Geometry
  46 /////////////////////////////////////////////////////////////////////////////////
  47 // Variable for Vertical Disalignement of Modules
  48 /////////////////////////////////////////////////////////////////////////////////
  49 const Double_t AliITSv11GeometrySSD::fgkSSDModuleVerticalDisalignment = 0.2*fgkmm;
  50 /////////////////////////////////////////////////////////////////////////////////
  51 // Layer5 (lengths are in mm and angles in degrees)
  52 /////////////////////////////////////////////////////////////////////////////////
  53 const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength      = 950.7*fgkmm;
  54 const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber        =  22;
  55 const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber         =  34;
  56 const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin         = 378.0*fgkmm;
  57 const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax         = 384.0*fgkmm;
  58 const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition    = 467.85*fgkmm;
  59 /////////////////////////////////////////////////////////////////////////////////
  60 // Layer6 (lengths are in mm and angles in degrees)
  61 /////////////////////////////////////////////////////////////////////////////////
  62 const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength      = 1068.0*fgkmm;
  63 const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber        =   25;
  64 const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber         =   38;
  65 const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin         =  428.0*fgkmm;
  66 const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax         =  434.0*fgkmm;
  67 const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition    = 526.50*fgkmm;
  68 /////////////////////////////////////////////////////////////////////////////////
  69 // SSD Chips and Hybrid (lengths are in mm and angles in degrees)
  70 /////////////////////////////////////////////////////////////////////////////////
  71 const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber               =   6;
  72 const Double_t AliITSv11GeometrySSD::fgkSSDChipLength            =  11.100*fgkmm;
  73 const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth             =   3.850*fgkmm;
  74 const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight            =   0.180*fgkmm;
  75 const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength  =   1.000*fgkmm;
  76 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength     = fgkSSDChipLength;
  77 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth      =  fgkSSDChipWidth;
  78 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight        =   0.030*fgkmm;
  79 /////////////////////////////////////////////////////////////////////////////////
  80 // Stiffener (lengths are in mm and angles in degrees)
  81 /////////////////////////////////////////////////////////////////////////////////
  82 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength       =  73.000*fgkmm;
  83 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth        =   6.500*fgkmm;
  84 //const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight       =   3.315;
  85 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight       =   0.315*fgkmm;
  86 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist   =   2.500*fgkmm;
  87 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length   = 1.600*fgkmm;
  88 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width    =   0.870*fgkmm;
  89 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height   =   0.800*fgkmm;
  90 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length   =   4.600*fgkmm;
  91 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width    =   3.400*fgkmm;
  92 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height   =   0.700*fgkmm; // multiplied by 0.5
  93 const Double_t AliITSv11GeometrySSD::fgkSSDWireLength            =  30.000*fgkmm;
  94 const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius            =   0.185*fgkmm;
  95 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2]  =
  96                                                                                                            {44.32*fgkmm, 0.33*fgkmm};
  97 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation   =        0.44*fgkmm;
  98 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength       =        2.16*fgkmm;
  99 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth        =        3.60*fgkmm;
 100 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight       =
 101                                                                                                           0.25*fgkSSDStiffenerHeight;
 102 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight     =       0.030*fgkmm;
 103 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight     =   0.002*fgkmm;
 104 /////////////////////////////////////////////////////////////////////////////////
 105 // Cooling Block (lengths are in mm and angles in degrees)
 106 /////////////////////////////////////////////////////////////////////////////////
 107 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength    =   3.000*fgkmm;
 108 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth     =   4.000*fgkmm;
 109 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
 110                                                                                  {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
 111 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
 112                                                                                                           {1.000*fgkmm, 0.120*fgkmm};
 113 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
 114                                                                                                           {1.900*fgkmm, 0.400*fgkmm};
 115 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter    =
 116                                                                                                                                          1.500*fgkmm;
 117 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight    =
 118                                                                                                                                          0.300*fgkmm;
 119 /////////////////////////////////////////////////////////////////////////////////
 120 // SSD Sensor (lengths are in mm and angles in degrees)
 121 /////////////////////////////////////////////////////////////////////////////////
 122 const char*  AliITSv11GeometrySSD::fgkSSDSensitiveVolName       =
 123                                                                                                                  "SSDSensorSensitiveVol";
 124 const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength          =  42.000*fgkmm;
 125 const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight          =   0.300*fgkmm;
 126 const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth           =  75.000*fgkmm;
 127 const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap         =
 128                                                                                                    fgkSSDSensorLength-39.1*fgkmm;
 129 const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength    = 1.*fgkmm;
 130 const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth     = 1.*fgkmm;
 131 /////////////////////////////////////////////////////////////////////////////////
 132 // Flex (lengths are in mm and angles in degrees)
 133 /////////////////////////////////////////////////////////////////////////////////
 134 const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength       =  106.000*fgkmm;
 135 const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4]        =
 136                         {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
 137                                  + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
 138                          0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
 139                                  + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)
 140                                                                            - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm};
 141 const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2]         =
 142                                                                                                    {  9.340*fgkmm,  5.380*fgkmm};
 143 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2]        =
 144                                                                                                    {  0.030*fgkmm,  0.020*fgkmm};
 145 const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle            =   30.000;
 146 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength       =    1.430*fgkmm;
 147 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth        =    3.000*fgkmm;
 148 const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
 149                          {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
 150 const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
 151                                                                                    {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
 152 /////////////////////////////////////////////////////////////////////////////////
 153 // SSD Ladder Cable (lengths are in mm and angles in degrees)
 154 /////////////////////////////////////////////////////////////////////////////////
 155 const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth     =     23.5*fgkmm;
 156 /////////////////////////////////////////////////////////////////////////////////
 157 // SSD Module (lengths are in mm and angles in degrees)
 158 /////////////////////////////////////////////////////////////////////////////////
 159 const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2]  =
 160                                                                                                          { 1.000*fgkmm, 3.900*fgkmm};
 161 const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
 162                                                                                                                                         45.600*fgkmm;
 163 const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor  =
 164                                                                                                                                          5.075*fgkmm;
 165 /////////////////////////////////////////////////////////////////////////////////
 166 // Sensor Support (lengths are in mm and angles in degrees)
 167 /////////////////////////////////////////////////////////////////////////////////
 168 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength                     =
 169                                                                                                                                          5.800*fgkmm;
 170 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth          =
 171                                                                                                                                          2.000*fgkmm;
 172 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2]      =
 173                                                                                                      { 4.620*fgkmm, 5.180*fgkmm};
 174 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2]   =
 175                                                                                                          { 0.450*fgkmm, 0.450*fgkmm};
 176 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition
 177                                                                 = 0.5 * (fgkSSDModuleSensorSupportDistance
 178                                                             +  fgkSSDSensorSideSupportThickness[0])
 179                                                                 -  fgkSSDSensorSideSupportLength;
 180 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength       =
 181                                                                                                                                     5.250*fgkmm;
 182 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth        =
 183                                                                                                                                         1.680*fgkmm;
 184 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]
 185                                                                   = {fgkSSDSensorSideSupportHeight[0]
 186                                                                   +  fgkSSDSensorSideSupportThickness[0],
 187                                                                          fgkSSDSensorSideSupportHeight[1]
 188                                                                   +  fgkSSDSensorSideSupportThickness[1]};
 189 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2]
 190                                                                   =  {fgkSSDSensorSideSupportThickness[0],
 191                                                                           fgkSSDSensorSideSupportThickness[1]};
 192 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition     =
 193                                                                                                                                    19.000*fgkmm;
 194 /////////////////////////////////////////////////////////////////////////////////
 195 // Chip Cables (lengths are in mm and angles in degrees)
 196 /////////////////////////////////////////////////////////////////////////////////
 197 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2]   =
 198                                   {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
 199 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4]   =
 200                                   {  0.014*fgkmm,  0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
 201                                                                   -  (fgkSSDSensorSideSupportHeight[1]
 202                                                                   -   fgkSSDSensorSideSupportHeight[0])
 203                                                                   -   fgkSSDCoolingBlockHoleCenter
 204                                                                   -   fgkSSDStiffenerHeight
 205                                                                   -   fgkSSDChipHeight-fgkSSDSensorHeight,
 206                                                                           fgkSSDModuleCoolingBlockToSensor
 207                                                                   -   fgkSSDCoolingBlockHoleCenter
 208                                                                   -       fgkSSDStiffenerHeight
 209                                                                   -   fgkSSDChipHeight-fgkSSDSensorHeight};
 210 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3]    =
 211                                             { 11.000*fgkmm,  0.800*fgkmm,  0.600*fgkmm};
 212 /////////////////////////////////////////////////////////////////////////////////
 213 // Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
 214 /////////////////////////////////////////////////////////////////////////////////
 215 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          =
 216                                                                                                                                         3.820*fgkmm;
 217 //const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          =
 218 //                                                                                                                                         3.780;
 219 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth           =
 220                                                                                  fgkSSDSensorLength-fgkSSDSensorOverlap;
 221 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2]         =
 222                                                                                                         {  0.86*fgkmm,  0.30*fgkmm};
 223 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2]        =
 224                                                                                                                                 { 30.00, 90.00};
 225 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
 226                                                                                                                                          1.78*fgkmm;
 227 /////////////////////////////////////////////////////////////////////////////////
 228 //Carbon Fiber Parameters (lengths are in mm and angles in degrees)
 229 /////////////////////////////////////////////////////////////////////////////////
 230 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength
 231                                                                    = fgkSSDModuleSensorSupportDistance
 232                                                                    - 2. * fgkCarbonFiberJunctionToSensorSupport;
 233 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
 234 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2]   =
 235                                                                                                   {  0.751*fgkmm,  0.482*fgkmm};
 236 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength  =
 237                                                                                                                                         1.630*fgkmm;
 238 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth =   0.950*fgkmm;
 239 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength
 240                                                                         = fgkCarbonFiberTriangleLength
 241                                                                         - 0.5*fgkCarbonFiberSupportTopEdgeDist[1]
 242                                                                         / TMath::Cos(fgkCarbonFiberTriangleAngle
 243                                                                         * TMath::DegToRad());
 244 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength
 245                                                                         = 0.5*(fgkCarbonFiberJunctionWidth
 246                                                                         - fgkCarbonFiberSupportWidth)
 247                                                                         - fgkCarbonFiberSupportTopEdgeDist[0]
 248                                                                         - fgkCarbonFiberSupportWidth;
 249 /////////////////////////////////////////////////////////////////////////////////
 250 // Carbon Fiber Lower Support Parameters (lengths are in mm)
 251 /////////////////////////////////////////////////////////////////////////////////
 252 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
 253                                                                                                                                           =  0.950*fgkmm;
 254 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
 255                                                                                                                                           =  1.600*fgkmm;
 256 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
 257                                                                                                                                           =  0.830*fgkmm;
 258 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
 259                                                                                           = 0.5*fgkCarbonFiberSupportWidth;
 260 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
 261                                                                         = fgkCarbonFiberJunctionWidth
 262                                                                         - 2. * (fgkCarbonFiberLowerSupportWidth
 263                                                                         + fgkCarbonFiberLowerSupportVolumeSeparation);
 264 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
 265                                                                         = {fgkCarbonFiberLowerSupportWidth
 266                                                                         +  fgkCarbonFiberLowerSupportVolumeSeparation,
 267                                                                            fgkCarbonFiberLowerSupportWidth
 268                                                                         +  fgkCarbonFiberLowerSupportVolumeSeparation
 269                                                                         +  fgkCarbonFiberLowerSupportTransverseWidth};
 270 /////////////////////////////////////////////////////////////////////////////////
 271 // End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
 272 /////////////////////////////////////////////////////////////////////////////////
 273 const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
 274                                                            {0.5 * (fgkSSDLay5LadderLength
 275                                                                         -  fgkSSDLay5SensorsNumber
 276                                                                         *  fgkCarbonFiberJunctionWidth
 277                                                                         -  fgkCarbonFiberLowerSupportWidth),
 278                                                                 0.5 * (fgkSSDLay5LadderLength
 279                                                                         -  fgkSSDLay5SensorsNumber
 280                                                                         *  fgkCarbonFiberJunctionWidth
 281                                                                         +  fgkCarbonFiberLowerSupportWidth)};
 282 const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
 283                                                 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
 284                                                  fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
 285 const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
 286                                                 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
 287                                                  fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
 288 const Double_t AliITSv11GeometrySSD::fgkendladdercoolingsupportdistance[3] =
 289                                                                                         {15.0*fgkmm, 13.5*fgkmm, 14.5*fgkmm};
 290 /////////////////////////////////////////////////////////////////////////////////
 291 // Cooling Tube Support (lengths are in mm and angles in degrees)
 292 /////////////////////////////////////////////////////////////////////////////////
 293 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax      =  1.45*fgkmm;
 294 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
 295                                                                                           = fgkSSDCoolingBlockHoleRadius[0];
 296 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength    =  8.55*fgkmm;
 297 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight    =  0.85*fgkmm;
 298 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth     =  2.00*fgkmm;
 299 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation    =
 300                                         fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
 301 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber =
 302                                                                                                                                           11.70*fgkmm;
 303 /////////////////////////////////////////////////////////////////////////////////
 304 // Cooling Tube (lengths are in mm and angles in degrees)
 305 /////////////////////////////////////////////////////////////////////////////////
 306 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
 307 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin =  0.96*fgkmm;
 308 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
 309                                                                                                         fgkCarbonFiberJunctionWidth;
 310 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
 311                                                                          fgkSSDModuleSensorSupportDistance
 312                                                                   +      fgkSSDCoolingBlockLength;
 313 const Double_t AliITSv11GeometrySSD::fgkMountingBlockToSensorSupport = 30.7*fgkmm;
 314 /////////////////////////////////////////////////////////////////////////////////
 315 // SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
 316 /////////////////////////////////////////////////////////////////////////////////
 317 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3]            =
 318                                                                                    { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
 319 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4]            =
 320                                                            {  4.0*fgkmm,  8.0*fgkmm,  5.0*fgkmm,  0.2*fgkmm};
 321 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth                =
 322                                                                                                                                           20.0*fgkmm;
 323 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle   =
 324                                                                                                                                                     40.0;
 325 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight  =
 326                    0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
 327 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
 328                                                                                                                                           2.5*fgkmm;
 329 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2]    =
 330                                                                                                           { 56.0*fgkmm, 12.0*fgkmm};
 331 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2]     =
 332                                                                                                       {  5.0*fgkmm,  2.9*fgkmm};
 333 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius           =
 334                                                                                                                                           1.0*fgkmm;
 335 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge        =
 336                                                                                                                                           6.0*fgkmm;
 337 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth      =
 338                                                                                                                                           4.0*fgkmm;
 339 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2]   =
 340                                                           {  1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
 341 /////////////////////////////////////////////////////////////////////////////////
 342 // SSD Mounting Block Clip Parameters (lengths are in mm and angles in degrees)
 343 /////////////////////////////////////////////////////////////////////////////////
 344 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipLength        = 15.1*fgkmm;
 345 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipThickness     = 0.3*fgkmm;
 346 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewRadius   = 1.6*fgkmm;
 347 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewPosition = 4.0*fgkmm;
 348 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibWidth         = 9.0*fgkmm;
 349 /////////////////////////////////////////////////////////////////////////////////
 350 // SSD Mounting Block Support Parameters (lengths are in mm and angles in degrees)
 351 /////////////////////////////////////////////////////////////////////////////////
 352 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportWidth[2] = {9.5*fgkmm,10.0*fgkmm};
 353 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportDownHeight   = 4.0*fgkmm;
 354 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDLay5RadiusMin
 355                                                                                                   -  fgkSSDMountingBlockHeight[1]
 356                                                                                                   +  0.5*fgkCoolingTubeSupportHeight
 357                                                                                                   +      fgkSSDModuleCoolingBlockToSensor
 358                                                                                                   +  fgkSSDModuleVerticalDisalignment
 359                                                                                                   -      fgkMountingBlockSupportDownHeight,
 360                                                                                                          fgkSSDLay6RadiusMin
 361                                                                                                   -  fgkSSDMountingBlockHeight[1]
 362                                                                                                   +  0.5*fgkCoolingTubeSupportHeight
 363                                                                                                   +      fgkSSDModuleCoolingBlockToSensor
 364                                                                                                   +  fgkSSDModuleVerticalDisalignment
 365                                                                                                   -      fgkMountingBlockSupportDownHeight};
 366 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax
 367                                                                                                     -  fgkSSDMountingBlockHeight[1]
 368                                                                                                     +  0.5*fgkCoolingTubeSupportHeight
 369                                                                                                     +  fgkSSDModuleCoolingBlockToSensor
 370                                                                                                         +  fgkSSDModuleVerticalDisalignment
 371                                                                                                         -  fgkMountingBlockSupportRadius[0],
 372                                                                                                            fgkSSDLay6RadiusMax
 373                                                                                                     -  fgkSSDMountingBlockHeight[1]
 374                                                                                                     +  0.5*fgkCoolingTubeSupportHeight
 375                                                                                                     +  fgkSSDModuleCoolingBlockToSensor
 376                                                                                                         +  fgkSSDModuleVerticalDisalignment
 377                                                                                                         -  fgkMountingBlockSupportRadius[1]};
 378 const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeigth = 10.0*fgkmm; // To be verified
 379 const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
 380 const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
 381 /////////////////////////////////////////////////////////////////////////////////
 382 // SSD End Cap Cover Plate Parameters (lengths are in mm and angles in degrees)
 383 /////////////////////////////////////////////////////////////////////////////////
 384 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleRadius = 1.25*fgkmm;
 385 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateBigHoleRadius = 2.45*fgkmm;
 386 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateThickness = 0.5*fgkmm;
 387 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleSeparation[3] =
 388                                                                                                 {16.5*fgkmm,22.0*fgkmm,7.*fgkmm};
 389 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateLength[6] =
 390                                   {7.*fgkmm,55.*fgkmm,8.0*fgkmm,53.*fgkmm,61.0*fgkmm,25.5*fgkmm};
 391 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateWidth[3] =
 392                                                                                            {68.5*fgkmm,75.5*fgkmm,6.5*fgkmm};
 393 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMin = 0.750*fgkmm;
 394 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMax = 2.*fgkmm;
 395 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipLength = 10.4*fgkmm;
 396 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipWidth = 6.0*fgkmm;
 397 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipLength = 5.7*fgkmm;
 398 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipWidth = 5.0*fgkmm;
 399 /////////////////////////////////////////////////////////////////////////////////
 400 // SSD End Cap Kapton Foil Parameters (lengths are in mm and angles in degrees)
 401 /////////////////////////////////////////////////////////////////////////////////
 402 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilThickness = 0.4*fgkmm;
 403 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilLength = 68.0*fgkmm;
 404 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilWidth = 75.0*fgkmm;
 405 /////////////////////////////////////////////////////////////////////////////////
 406 // SSD End Cap Cooling Tube Parameters (lengths are in mm and angles in degrees)
 407 /////////////////////////////////////////////////////////////////////////////////
 408 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAxialRadius[2] =
 409                                                                                                                 {10.5*fgkmm,9.25*fgkmm};
 410 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMin = 1.3*fgkmm;
 411 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMax = 1.5*fgkmm;
 412 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAngle[5] =
 413                                                                                                         {182.3,177.9,84.4,70.0,35.0};
 414 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeLength[5] =
 415                                                                         {49.5*fgkmm,41.7*fgkmm,47.6*fgkmm,5.0*fgkmm};
 416 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeToCoverSide = 13.0*fgkmm;
 417 /////////////////////////////////////////////////////////////////////////////////
 418 // SSD End Cap Cover Side Parameters (lengths are in mm and angles in degrees)
 419 /////////////////////////////////////////////////////////////////////////////////
 420 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverLength[5] = {3.5*fgkmm,
 421                                                                           6.5*fgkmm,75.0*fgkmm,8.0*fgkmm,2.0*fgkmm};
 422 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverWidth[7] = {30.9*fgkmm,
 423                                                                           47.5*fgkmm,12.6*fgkmm,5.6*fgkmm,
 424                                                                           20.0*fgkmm,7.0*fgkmm,5.9*fgkmm};
 425 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm;
 426 /////////////////////////////////////////////////////////////////////////////////
 427 // SSD End Cap Cards Parameters (lengths are in mm and angles in degrees)
 428 /////////////////////////////////////////////////////////////////////////////////
 429 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] =
 430                                                                                                            {62.0*fgkmm,21.87*fgkmm};
 431 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] =
 432                                                                                                             {47.1*fgkmm,0.35*fgkmm};
 433 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness =
 434                                                                                                                                           1.0*fgkmm;
 435 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm;
 436 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerWidth[2] =
 437                                                                                                            {43.5*fgkmm, 0.70*fgkmm};
 438 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerThickness =
 439                                                                                                                                          0.15*fgkmm;
 440 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorThickness =
 441                                                                                                                                          19.0*fgkmm;
 442 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorLength[2] =
 443                                                                                                                  {4.80*fgkmm,1.1*fgkmm};
 444 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorWidth[2] =
 445                                                                                                                  {3.3*fgkmm,1.10*fgkmm};
 446 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorToLayer =
 447                                                                                                                                           2.1*fgkmm;
 448 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorLength[3] =
 449                                                                                                 {5.2*fgkmm,3.5*fgkmm,1.2*fgkmm};
 450 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorWidth[2] =
 451                                                                                                                  {1.9*fgkmm,0.15*fgkmm};
 452 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorThickness =
 453                                                                                                                                            19*fgkmm;
 454 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorDistance =
 455                                                                                                                                           1.0*fgkmm;
 456 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorToLayer =
 457                                                                                                                                           3.6*fgkmm;
 458 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionLength =
 459                                                                                                                                          61.0*fgkmm;
 460 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionThickness =
 461                                                                                                                                          5.97*fgkmm;
 462 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionWidth = 3.0*fgkmm;
 463 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBLength[7] =
 464                                                                                                 {3.1*fgkmm,68.0*fgkmm,3.6*fgkmm,
 465                                                                           1.9*fgkmm,2.5*fgkmm,14.2*fgkmm,1.5*fgkmm};
 466 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBWidth[5] =
 467                                                   {17.0*fgkmm,10.0*fgkmm,5.9*fgkmm,6.4*fgkmm,3.9*fgkmm};
 468 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBThickness =
 469                                                                                                                                           1.0*fgkmm;
 470 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceElectBoardCardBThickness
 471                                                                                                                                    = 0.15*fgkmm;
 472 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBJMDConnectorSeparation =
 473                                                                                                                                          20.0*fgkmm;
 474 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerLength = 68.0*fgkmm;
 475 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerWidth = 5.0*fgkmm;
 476 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerThickness = 5.0*fgkmm;
 477 const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMin = 1.25*fgkmm; // To Be Checked
 478 const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMax = 1.575*fgkmm; // To Be Checked
 479 /////////////////////////////////////////////////////////////////////////////////
 480 // SSD End Cap SupportLayer5/6 Side Parameters (lengths are in mm and angles in degrees)
 481 /////////////////////////////////////////////////////////////////////////////////
 482 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLength[2] = {70.424*fgkmm,72.919*fgkmm};
 483 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fgkmm,437.0*fgkmm};
 484 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {365.0*fgkmm,430.0*fgkmm};
 485 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm;
 486 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm};
 487 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 625.0*fgkmm;
 488 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
 489 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
 490 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
 491 /////////////////////////////////////////////////////////////////////////////////
 492 ClassImp(AliITSv11GeometrySSD)
 493 /////////////////////////////////////////////////////////////////////////////////
 494 AliITSv11GeometrySSD::AliITSv11GeometrySSD():
 495   AliITSv11Geometry(),
 496   fSSDChipMedium(),
 497   fSSDChipGlueMedium(),
 498   fSSDStiffenerMedium(),
 499   fSSDStiffenerConnectorMedium(),
 500   fSSDStiffener0603CapacitorMedium(),
 501   fSSDStiffener1812CapacitorMedium(),
 502   fSSDStiffenerHybridWireMedium(),
 503   fSSDKaptonFlexMedium(),
 504   fSSDAlTraceFlexMedium(),
 505   fSSDAlTraceLadderCableMedium(),
 506   fSSDKaptonLadderCableMedium(),
 507   fSSDKaptonChipCableMedium(),
 508   fSSDAlTraceChipCableMedium(),
 509   fSSDAlCoolBlockMedium(),
 510   fSSDSensorMedium(),
 511   fSSDSensorSupportMedium(),
 512   fSSDCarbonFiberMedium(),
 513   fSSDTubeHolderMedium(),
 514   fSSDCoolingTubeWater(),
 515   fSSDCoolingTubePhynox(),
 516   fSSDSupportRingAl(),
 517   fSSDMountingBlockMedium(),
 518   fSSDAir(),
 519   fCreateMaterials(kFALSE),
 520   fTransformationMatrices(kFALSE),
 521   fBasicObjects(kFALSE),
 522   fcarbonfiberjunction(),
 523   fcoolingtubesupport(),
 524   fhybridmatrix(),
 525   fssdcoolingblocksystem(),
 526   fcoolingblocksystematrix(),
 527   fssdstiffenerflex(),
 528   fssdendflex(),
 529   fendladdercoolingtubesupportmatrix(),
 530   fendladdermountingblock(),
 531   fendladdermountingblockclip(),
 532   fSSDSensor5(),
 533   fSSDSensor6(),
 534   fSSDLayer5(),
 535   fSSDLayer6(),
 536   fMotherVol(),
 537   fLay5LadderSupportRing(),
 538   fLay6LadderSupportRing(),
 539   fgkEndCapSupportSystem(),
 540   fColorCarbonFiber(4),
 541   fColorRyton(5),
 542   fColorPhynox(14),
 543   fColorSilicon(3),
 544   fColorAl(38),
 545   fColorKapton(6),
 546   fColorPolyhamide(5),
 547   fColorStiffener(9),
 548   fColorEpoxy(30),
 549   fColorWater(7),
 550   fColorG10(41)
 551 {
 552   ////////////////////////
 553   // Standard constructor
 554   ////////////////////////
 555 }
 556 /////////////////////////////////////////////////////////////////////////////////
 557 AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
 558   AliITSv11Geometry(s.GetDebug()),
 559   fSSDChipMedium(s.fSSDChipMedium),
 560   fSSDChipGlueMedium(s.fSSDChipGlueMedium),
 561   fSSDStiffenerMedium(s.fSSDStiffenerMedium),
 562   fSSDStiffenerConnectorMedium(s.fSSDStiffenerConnectorMedium),
 563   fSSDStiffener0603CapacitorMedium(s.fSSDStiffener0603CapacitorMedium),
 564   fSSDStiffener1812CapacitorMedium(s.fSSDStiffener1812CapacitorMedium),
 565   fSSDStiffenerHybridWireMedium(s.fSSDStiffenerHybridWireMedium),
 566   fSSDKaptonFlexMedium(s.fSSDKaptonFlexMedium),
 567   fSSDAlTraceFlexMedium(s.fSSDAlTraceFlexMedium),
 568   fSSDAlTraceLadderCableMedium(s.fSSDAlTraceLadderCableMedium),
 569   fSSDKaptonLadderCableMedium(s.fSSDKaptonLadderCableMedium),
 570   fSSDKaptonChipCableMedium(s.fSSDKaptonChipCableMedium),
 571   fSSDAlTraceChipCableMedium(s.fSSDAlTraceChipCableMedium),
 572   fSSDAlCoolBlockMedium(s.fSSDAlCoolBlockMedium),
 573   fSSDSensorMedium(s.fSSDSensorMedium),
 574   fSSDSensorSupportMedium(s.fSSDSensorSupportMedium),
 575   fSSDCarbonFiberMedium(s.fSSDCarbonFiberMedium),
 576   fSSDTubeHolderMedium(s.fSSDTubeHolderMedium),
 577   fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
 578   fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
 579   fSSDSupportRingAl(s.fSSDSupportRingAl),
 580   fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
 581   fSSDAir(s.fSSDAir),
 582   fCreateMaterials(s.fCreateMaterials),
 583   fTransformationMatrices(s.fTransformationMatrices),
 584   fBasicObjects(s.fBasicObjects),
 585   fcarbonfiberjunction(s.fcarbonfiberjunction),
 586   fcoolingtubesupport(s.fcoolingtubesupport),
 587   fhybridmatrix(s.fhybridmatrix),
 588   fssdcoolingblocksystem(s.fssdcoolingblocksystem),
 589   fcoolingblocksystematrix(s.fcoolingblocksystematrix),
 590   fssdstiffenerflex(s.fssdstiffenerflex),
 591   fssdendflex(s.fssdendflex),
 592   fendladdercoolingtubesupportmatrix(s.fendladdercoolingtubesupportmatrix),
 593   fendladdermountingblock(s.fendladdermountingblock),
 594   fendladdermountingblockclip(s.fendladdermountingblockclip),
 595   fSSDSensor5(s.fSSDSensor5),
 596   fSSDSensor6(s.fSSDSensor6),
 597   fSSDLayer5(s.fSSDLayer5),
 598   fSSDLayer6(s.fSSDLayer6),
 599   fMotherVol(s.fMotherVol),
 600   fLay5LadderSupportRing(s.fLay5LadderSupportRing),
 601   fLay6LadderSupportRing(s.fLay6LadderSupportRing),
 602   fgkEndCapSupportSystem(s.fgkEndCapSupportSystem),
 603   fColorCarbonFiber(s.fColorCarbonFiber),
 604   fColorRyton(s.fColorRyton),
 605   fColorPhynox(s.fColorPhynox),
 606   fColorSilicon(s.fColorSilicon),
 607   fColorAl(s.fColorAl),
 608   fColorKapton(s.fColorKapton),
 609   fColorPolyhamide(s.fColorPolyhamide),
 610   fColorStiffener(s.fColorStiffener),
 611   fColorEpoxy(s.fColorEpoxy),
 612   fColorWater(s.fColorWater),
 613   fColorG10(s.fColorG10)
 614 {
 615   ////////////////////////
 616   // Copy Constructor
 617   ////////////////////////
 618 }
 619 /////////////////////////////////////////////////////////////////////////////////
 620 AliITSv11GeometrySSD& AliITSv11GeometrySSD::
 621 operator=(const AliITSv11GeometrySSD &s){
 622   ////////////////////////
 623   // Assignment operator
 624   ////////////////////////
 625   this->~AliITSv11GeometrySSD();
 626   new(this) AliITSv11GeometrySSD(s);
 627   return *this;
 628 /*
 629   if(&s == this) return *this;
 630   fMotherVol = s.fMotherVol;
 631   return *this;
 632  */
 633 }
 634 ///////////////////////////////////////////////////////////////////////////////
 635 void AliITSv11GeometrySSD::CreateTransformationMatrices(){
 636   ///////////////////////////////////////////////////////////////////////
 637   // Method generating the trasformation matrix for the whole SSD Geometry
 638   ///////////////////////////////////////////////////////////////////////
 639   // Setting some variables for Carbon Fiber Supportmatrix creation
 640   //////////////////////////////////////////////////////////////////////
 641   Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
 642                                                                                    * CosD(fgkCarbonFiberJunctionAngle[0]);
 643   Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
 644                                                                  +      fgkCarbonFiberSupportTopEdgeDist[0]
 645                                                                  +      fgkCarbonFiberSupportWidth);
 646   Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
 647                                                                         * TanD(fgkCarbonFiberJunctionAngle[0]);
 648   TGeoRotation* carbonfiberot[3];
 649   for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
 650   carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
 651   carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
 652   carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
 653   Double_t transvector[3] = {fgkCarbonFiberTriangleLength
 654                                                   *  CosD(fgkCarbonFiberTriangleAngle),0.,
 655                                                   -  fgkCarbonFiberTriangleLength
 656                                                   *      SinD(fgkCarbonFiberTriangleAngle)};
 657   ///////////////////////////////////////////
 658   //Setting Local Translations and Rotations:
 659   ///////////////////////////////////////////
 660   TGeoCombiTrans* localcarbonfibersupportmatrix[3];
 661   localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
 662                                                                          0.5*carbonfibersupportheight,NULL);
 663   localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
 664                                                                          2.*symmetryplaneposition+transvector[1],
 665                                                                          transvector[2], carbonfiberot[2]);
 666   localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
 667   /////////////////////////////////////////////////////////////
 668   // Carbon Fiber Support Transformations
 669   /////////////////////////////////////////////////////////////
 670   const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
 671   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
 672                 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
 673                 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
 674                         fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
 675   }
 676   /////////////////////////////////////////////////////////////
 677   // Carbon Fiber Junction Transformation
 678   /////////////////////////////////////////////////////////////
 679   const Int_t kcarbonfiberjunctionmatrixnumber = 2;
 680   TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
 681   TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
 682   TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
 683   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
 684         localcarbonfiberjunctionmatrix[i] =
 685                                                 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
 686         localcarbonfiberjunctionrot[i] =
 687                                                 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
 688         localcarbonfiberjunctiontrans[i] =
 689                                                 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
 690   }
 691   ///////////////////////
 692   // Setting Translations
 693   ///////////////////////
 694   localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
 695   localcarbonfiberjunctiontrans[1][0] =
 696                                  new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
 697   localcarbonfiberjunctiontrans[2][0] =
 698                                  new TGeoTranslation(fgkCarbonFiberTriangleLength
 699                                  * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
 700                                  fgkCarbonFiberTriangleLength
 701                                  * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
 702   localcarbonfiberjunctiontrans[0][1] =
 703                                  new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
 704   localcarbonfiberjunctiontrans[1][1] =
 705                                  new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
 706   localcarbonfiberjunctiontrans[2][1] =
 707                                  new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
 708   ////////////////////
 709   // Setting Rotations
 710   ////////////////////
 711   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
 712                 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
 713                         localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
 714   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
 715         localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
 716   localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
 717   localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
 718   localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
 719   ////////////////////////////////////////
 720   // Setting Carbon Fiber Junction matrix
 721   ////////////////////////////////////////
 722   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
 723                 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
 724                 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
 725                         localcarbonfiberjunctionmatrix[i][j] =
 726                         new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
 727                                                            *localcarbonfiberjunctionrot[i][j]);
 728                     fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
 729          }
 730   }
 731   /////////////////////////////////////////////////////////////
 732   // Carbon Fiber Lower Support Transformations
 733   /////////////////////////////////////////////////////////////
 734   TGeoTranslation* localcarbonfiberlowersupportrans[2];
 735   localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
 736                                                                          fgkCarbonFiberLowerSupportVolumePosition[1]
 737                                                                 +    fgkCarbonFiberLowerSupportVolumePosition[0],
 738                                                                          0.0);
 739   localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
 740                                                                          fgkCarbonFiberJunctionWidth
 741                                                                 -    fgkCarbonFiberLowerSupportWidth
 742                                                                 -    fgkCarbonFiberLowerSupportVolumePosition[0]
 743                                                                 -    fgkCarbonFiberLowerSupportVolumePosition[1],
 744                                                                 -    0.5*fgkCarbonFiberLowerSupportHeight);
 745    localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
 746    fcarbonfiberlowersupportrans[0] =
 747                                                 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
 748    fcarbonfiberlowersupportrans[1] =
 749                                                 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
 750   /////////////////////////////////////////////////////////////
 751   // SSD Sensor Support Transformations
 752   /////////////////////////////////////////////////////////////
 753   const Int_t kssdsensorsupportmatrixnumber = 3;
 754   TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
 755   TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
 756   TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
 757   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 758         localssdsensorsupportmatrix[i] =
 759                                                 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
 760         localssdsensorsupportrot[i] =
 761                                                 new TGeoRotation*[kssdsensorsupportmatrixnumber];
 762         localssdsensorsupportrans[i] =
 763                                                 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
 764   }
 765   ///////////////////////
 766   // Setting Translations
 767   ///////////////////////
 768   localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
 769                                                                           0.5*fgkSSDSensorSideSupportWidth,
 770                                                                           0.0);
 771   localssdsensorsupportrans[1][0] =
 772                                                  new TGeoTranslation(*localssdsensorsupportrans[0][0]);
 773   localssdsensorsupportrans[2][0] =
 774                                                  new TGeoTranslation(*localssdsensorsupportrans[0][0]);
 775   localssdsensorsupportrans[0][1] =
 776                                                  new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
 777                                                                                 0.5*fgkSSDSensorSideSupportThickness[0],
 778                                                                                 0.0);
 779   localssdsensorsupportrans[1][1] =
 780                                                  new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
 781                                                                         -   0.5*fgkSSDSensorSideSupportThickness[0]
 782                                                                     -   fgkSSDModuleSensorSupportDistance,
 783                                                                                 0.0);
 784   localssdsensorsupportrans[2][1] =
 785                                                  new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
 786                                                                         -    fgkSSDSensorCenterSupportPosition,
 787                                                                                  0.5*fgkSSDSensorCenterSupportWidth
 788                                                                         -    0.5*fgkSSDModuleSensorSupportDistance,
 789                                                                                  fgkSSDSensorCenterSupportThickness[0]);
 790   localssdsensorsupportrans[0][2] =
 791                                                  new TGeoTranslation(fgkCarbonFiberTriangleLength
 792                                                                         +    fgkCarbonFiberJunctionToSensorSupport,
 793                                                                                  fgkCarbonFiberJunctionWidth
 794                                                                     -    0.5*(fgkCarbonFiberLowerSupportWidth
 795                                                                         +    fgkSSDSensorCenterSupportLength
 796                                                                         -    fgkSSDSensorCenterSupportThickness[0])
 797                                                                         -    fgkSSDSensorCenterSupportPosition,
 798                                                                              0.0);
 799   localssdsensorsupportrans[1][2] =
 800                                                 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
 801   localssdsensorsupportrans[2][2] =
 802                                                 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
 803   ////////////////////
 804   // Setting Rotations
 805   ////////////////////
 806   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
 807                 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
 808                         localssdsensorsupportrot[i][j] = new TGeoRotation();
 809   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 810         localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
 811         localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
 812   }
 813   localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
 814   localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
 815   localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
 816   ////////////////////////////////////////
 817   // SSD Sensor Support matrix
 818   ////////////////////////////////////////
 819   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 820                 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
 821                 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
 822                         localssdsensorsupportmatrix[i][j] =
 823                         new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
 824                                                            *localssdsensorsupportrot[i][j]);
 825                     fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
 826          }
 827   }
 828   /////////////////////////////////////////////////////////////
 829   // SSD Cooling Tube Support Transformations
 830   /////////////////////////////////////////////////////////////
 831   const Int_t kcoolingtubesupportmatrixnumber = 2;
 832   TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
 833   TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
 834   TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
 835   Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
 836                                                                                                         /fgkCoolingTubeSupportRmax);
 837   localcoolingtubesupportrans[0] =
 838                         new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
 839                                                 +  2.*(fgkCoolingTubeSupportLength
 840                                                 -  fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
 841                                                 +  fgkCarbonFiberTriangleLength
 842                                                 -  2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
 843   localcoolingtubesupportrans[1] =
 844                         new TGeoTranslation(fgkCarbonFiberJunctionLength
 845                                         - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
 846                                         - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 847                                                    fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 848                     +  0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 849                     -  0.5*(fgkCarbonFiberLowerSupportWidth
 850                                         +          fgkSSDSensorCenterSupportLength
 851                     -      fgkSSDSensorCenterSupportThickness[0])
 852                                         +  0.5*fgkSSDSensorLength,
 853                                         -  0.5*fgkCoolingTubeSupportHeight);
 854   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
 855   localcoolingtubesupportrot[i] = new TGeoRotation();
 856   localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
 857   localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
 858   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
 859         localcoolingtubesupportmatrix[i] =
 860                 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
 861                                                    *localcoolingtubesupportrot[i]);
 862   fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
 863   fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
 864                                                                 (*localcoolingtubesupportmatrix[0]));
 865   /////////////////////////////////////////////////////////////
 866   // End Ladder SSD Cooling Tube Support Transformations
 867   /////////////////////////////////////////////////////////////
 868   TGeoTranslation** localendladdercooltubetrans[2];
 869   localendladdercooltubetrans[0] = new TGeoTranslation*[4];
 870   localendladdercooltubetrans[1] = new TGeoTranslation*[2];
 871   for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
 872   localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
 873                                                                                         -          (fgkCoolingTubeSupportLength
 874                                                                                         -               fgkCoolingTubeSupportRmax),
 875                                                                                                         fgkEndLadderMountingBlockPosition[0]
 876                                                                                         -               fgkendladdercoolingsupportdistance[0]
 877                                                                                         +   0.5*fgkCoolingTubeSupportWidth,
 878                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 879   localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
 880                                                                                         -          (fgkCoolingTubeSupportLength
 881                                                                                         -               fgkCoolingTubeSupportRmax),
 882                                                                                                         fgkEndLadderMountingBlockPosition[0]
 883                                                                                         +               fgkendladdercoolingsupportdistance[1]
 884                                                                                         +   0.5*fgkCoolingTubeSupportWidth,
 885                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 886   localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
 887                                                                                         -       fgkCoolingTubeSupportRmax)
 888                                                                                         +               fgkCarbonFiberTriangleLength
 889                                                                                         -   2.0*fgkCarbonFiberJunctionLength,
 890                                                                                                 0.0,
 891                                                                                                 0.0);
 892   localendladdercooltubetrans[0][3]->SetTranslation(0.0,
 893                                                                                                         fgkendladdercoolingsupportdistance[0]
 894                                                                                         +               fgkendladdercoolingsupportdistance[1],
 895                                                                                                         0.0);
 896   for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
 897   localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
 898                                                                                         +               fgkCarbonFiberJunctionLength
 899                                                                                         -               fgkCoolingTubeSupportLength,
 900                                                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[1]
 901                                                                                         -       0.5*fgkCoolingTubeSupportWidth
 902                                                                                                    -fgkendladdercoolingsupportdistance[2],
 903                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 904   localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
 905                                                                                         +               fgkCoolingTubeSupportLength
 906                                                                                         -               fgkCoolingTubeSupportRmax
 907                                                                                         -               fgkCarbonFiberJunctionLength,
 908                                                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[1]
 909                                                                                         -       0.5*fgkCoolingTubeSupportWidth
 910                                                                                         -               fgkendladdercoolingsupportdistance[2],
 911                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 912   fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
 913   fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
 914   fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
 915   fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
 916   (*localcoolingtubesupportrot[1]));
 917   fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
 918   (*localcoolingtubesupportrot[1]));
 919   fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
 920   fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
 921   fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
 922   fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
 923   fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
 924
 925   fendladdercoolingtubesupportmatrix[1][0] =
 926                                                         new TGeoHMatrix((*localendladdercooltubetrans[1][0])
 927                                                                                    *(*localcoolingtubesupportrot[1]));
 928   fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
 929   fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
 930   fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
 931   /////////////////////////////////////////////////////////////
 932   // SSD Cooling Tube Transformations
 933   /////////////////////////////////////////////////////////////
 934   TGeoRotation* localcoolingtuberot = new TGeoRotation();
 935   localcoolingtuberot->SetAngles(0.,90.,0.);
 936   TGeoTranslation** localcoolingtubetrans[4];
 937   TVector3** localcoolingtubevect[4];
 938   for(Int_t i=0; i<4; i++){
 939         localcoolingtubevect[i] = new TVector3*[2];
 940         localcoolingtubetrans[i] = new TGeoTranslation*[2];
 941         fcoolingtubematrix[i] = new TGeoHMatrix*[2];
 942   }
 943   localcoolingtubevect[0][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
 944                                                   -fgkCarbonFiberTriangleLength),
 945                                                   - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 946                                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 947                                                   +      0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 948                                                   -      0.5*(fgkCarbonFiberLowerSupportWidth
 949                                                   +      fgkSSDSensorCenterSupportLength
 950                                                   -      fgkSSDSensorCenterSupportThickness[0])+
 951                                                          0.5*fgkSSDSensorLength-0.25*(fgkSSDSensorLength
 952                                                   -  2.0*fgkSSDModuleStiffenerPosition[1]
 953                                                   -      2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
 954                                                   -  0.5*fgkCoolingTubeSupportWidth,
 955                                                   -  0.5*fgkCoolingTubeSupportHeight);
 956   localcoolingtubevect[0][1] = new TVector3(localcoolingtubevect[0][0]->X(),
 957                                                         localcoolingtubevect[0][0]->Y()+0.5*(fgkSSDSensorLength
 958                                                   -  2.0*fgkSSDModuleStiffenerPosition[1]
 959                                                   -      2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
 960                                                   +  fgkCoolingTubeSupportWidth,
 961                                                   localcoolingtubevect[0][0]->Z());
 962   localcoolingtubevect[1][0] = new TVector3(-localcoolingtubevect[0][0]->X()
 963                                                          +                               fgkCarbonFiberTriangleLength,
 964                                                                                          localcoolingtubevect[0][0]->Y(),
 965                                                                                          localcoolingtubevect[0][0]->Z());
 966   localcoolingtubevect[1][1] = new TVector3(-localcoolingtubevect[0][1]->X()
 967                                                          +                               fgkCarbonFiberTriangleLength,
 968                                                                                          localcoolingtubevect[0][1]->Y(),
 969                                                                                          localcoolingtubevect[0][1]->Z());
 970   localcoolingtubevect[2][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
 971                                                   -     fgkCarbonFiberTriangleLength),
 972                                                   - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 973                                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 974                                                   +      0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 975                                                   -      0.5*(fgkCarbonFiberLowerSupportWidth
 976                                                   +      fgkSSDSensorCenterSupportLength
 977                                                   -      fgkSSDSensorCenterSupportThickness[0])
 978                                                   +  fgkSSDModuleStiffenerPosition[1]
 979                                                   -  0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDSensorOverlap),
 980                                                   -  0.5*fgkCoolingTubeSupportHeight);
 981   localcoolingtubevect[2][1] = new TVector3(-localcoolingtubevect[2][0]->X()
 982                                                          +                               fgkCarbonFiberTriangleLength,
 983                                                                                          localcoolingtubevect[2][0]->Y(),
 984                                                                                          localcoolingtubevect[2][0]->Z());
 985   localcoolingtubevect[3][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
 986                                                   -     fgkCarbonFiberTriangleLength),
 987                                                   - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 988                                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 989                                                   +      0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 990                                                   -      0.5*(fgkCarbonFiberLowerSupportWidth
 991                                                   +      fgkSSDSensorCenterSupportLength
 992                                                   -      fgkSSDSensorCenterSupportThickness[0])
 993                                                   +      fgkSSDSensorLength
 994                                                   -      0.5*fgkSSDModuleStiffenerPosition[1],
 995                                                   -  0.5*fgkCoolingTubeSupportHeight);
 996   localcoolingtubevect[3][1] = new TVector3(-localcoolingtubevect[3][0]->X()
 997                                                   + fgkCarbonFiberTriangleLength,
 998                                                         localcoolingtubevect[3][0]->Y(),
 999                                                   - 0.5*fgkCoolingTubeSupportHeight);
1000   for(Int_t i=0; i<4; i++)
1001         for(Int_t j=0; j<2; j++){
1002                 localcoolingtubetrans[i][j] =
1003                         new TGeoTranslation(localcoolingtubevect[i][j]->X(),
1004                                                                 localcoolingtubevect[i][j]->Y(),
1005                                                                 localcoolingtubevect[i][j]->Z());
1006                 fcoolingtubematrix[i][j] = new TGeoHMatrix((*localcoolingtubetrans[i][j])
1007                                                           *                                     (*localcoolingtuberot));
1008         }
1009   /////////////////////////////////////////////////////////////
1010   // SSD End Ladder Cooling Tube Transformations
1011   /////////////////////////////////////////////////////////////
1012   TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
1013   localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
1014   TGeoTranslation** localendlladdercoolingtubetrans[2];
1015   localendlladdercoolingtubetrans[0] = new TGeoTranslation*[6];
1016   localendlladdercoolingtubetrans[1] = new TGeoTranslation*[4];
1017   for(Int_t i=0; i<2; i++)
1018         for(Int_t j=0; j<(i==0?6:4); j++)
1019                 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
1020   localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1021                                                                         -        fgkCoolingTubeSupportRmax)
1022                                                                         +        fgkCarbonFiberJunctionLength,
1023                                                                           0.5*(fgkEndLadderMountingBlockPosition[0]
1024                                                                         -    fgkendladdercoolingsupportdistance[0]),
1025                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1026   localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1027                                                                         -        fgkCoolingTubeSupportRmax)
1028                                                                         -        fgkCarbonFiberJunctionLength
1029                                                                         +    fgkCarbonFiberTriangleLength,
1030                                                                           0.5*(fgkEndLadderMountingBlockPosition[0]
1031                                                                         -    fgkendladdercoolingsupportdistance[0]),
1032                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1033   localendlladdercoolingtubetrans[0][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1034                                                                         -   fgkCoolingTubeSupportRmax)
1035                                                                         +       fgkCarbonFiberJunctionLength,
1036                                                                            fgkEndLadderMountingBlockPosition[0]
1037                                                                         -   fgkendladdercoolingsupportdistance[0]
1038                                                   +                0.5*(fgkendladdercoolingsupportdistance[0]
1039                                                   +                             fgkendladdercoolingsupportdistance[1]
1040                                                   +                             fgkCoolingTubeSupportWidth),
1041                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1042   localendlladdercoolingtubetrans[0][3]->SetTranslation((fgkCoolingTubeSupportLength
1043                                                                         -        fgkCoolingTubeSupportRmax)
1044                                                                         -        fgkCarbonFiberJunctionLength
1045                                                                         +    fgkCarbonFiberTriangleLength,
1046                                                                            fgkEndLadderMountingBlockPosition[0]
1047                                                                         -   fgkendladdercoolingsupportdistance[0]
1048                                                   +                0.5*(fgkendladdercoolingsupportdistance[0]
1049                                                   +                             fgkendladdercoolingsupportdistance[1]
1050                                                   +                             fgkCoolingTubeSupportWidth),
1051                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1052   localendlladdercoolingtubetrans[0][4]->SetTranslation(-(fgkCoolingTubeSupportLength
1053                                                                         -   fgkCoolingTubeSupportRmax)
1054                                                                         +       fgkCarbonFiberJunctionLength,
1055                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[0]
1056                                                   - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1057                                                   -                     fgkEndLadderMountingBlockPosition[0]
1058                                                   -                     fgkendladdercoolingsupportdistance[1]
1059                                                   -                     fgkCoolingTubeSupportWidth),
1060                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1061   localendlladdercoolingtubetrans[0][5]->SetTranslation((fgkCoolingTubeSupportLength
1062                                                                         -        fgkCoolingTubeSupportRmax)
1063                                                                         -        fgkCarbonFiberJunctionLength
1064                                                                         +    fgkCarbonFiberTriangleLength,
1065                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[0]
1066                                                   - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1067                                                   -                     fgkEndLadderMountingBlockPosition[0]
1068                                                   -                     fgkendladdercoolingsupportdistance[1]
1069                                                   -                     fgkCoolingTubeSupportWidth),
1070                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1071   localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1072                                                                         -   fgkCoolingTubeSupportRmax)
1073                                                                         +       fgkCarbonFiberJunctionLength,
1074                                                         - 0.50 * (fgkMountingBlockToSensorSupport
1075                                                         - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1076                                                         -                 fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1077                                                         +                 fgkSSDSensorOverlap
1078                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1079                                                         -                 fgkendladdercoolingsupportdistance[2]
1080                                                         -                 fgkEndLadderMountingBlockPosition[1]
1081                                                         -                 fgkCoolingTubeSupportWidth)
1082                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1083                                                         -                 fgkendladdercoolingsupportdistance[2]
1084                                                         -                 fgkCoolingTubeSupportWidth,
1085                                                   -             0.5*fgkCoolingTubeSupportHeight);
1086   localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1087                                                   -      fgkCoolingTubeSupportRmax)
1088                                                   -      fgkCarbonFiberJunctionLength
1089                                                   +    fgkCarbonFiberTriangleLength,
1090                                                   - 0.50 * (fgkMountingBlockToSensorSupport
1091                                                         - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1092                                                         -                 fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1093                                                         +                 fgkSSDSensorOverlap
1094                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1095                                                         -                 fgkendladdercoolingsupportdistance[2]
1096                                                         -                 fgkEndLadderMountingBlockPosition[1]
1097                                                         -                 fgkCoolingTubeSupportWidth)
1098                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1099                                                         -                 fgkendladdercoolingsupportdistance[2]
1100                                                         -                 fgkCoolingTubeSupportWidth,
1101                                                   -             0.5*fgkCoolingTubeSupportHeight);
1102   localendlladdercoolingtubetrans[1][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1103                                                                         -   fgkCoolingTubeSupportRmax)
1104                                                                         +       fgkCarbonFiberJunctionLength,
1105                                                                                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1106                                                                         - 0.5*fgkendladdercoolingsupportdistance[2],
1107                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1108   localendlladdercoolingtubetrans[1][3]->SetTranslation((fgkCoolingTubeSupportLength
1109                                                                         -        fgkCoolingTubeSupportRmax)
1110                                                                         -        fgkCarbonFiberJunctionLength
1111                                                                         +    fgkCarbonFiberTriangleLength,
1112                                                                                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1113                                                                         - 0.5*fgkendladdercoolingsupportdistance[2],
1114                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1115   fendladdercoolingtubematrix[0] = new TGeoHMatrix*[6];
1116   fendladdercoolingtubematrix[1] = new TGeoHMatrix*[4];
1117   for(Int_t i=0; i<2; i++)
1118         for(Int_t j=0; j<(i==0?6:4); j++){
1119                 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1120                 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1121         }
1122   /////////////////////////////////////////////////////////////
1123   // SSD Hybrid Components Transformations
1124   /////////////////////////////////////////////////////////////
1125   const Int_t khybridmatrixnumber = 3;
1126   TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1127   localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1128                                             0.5*fgkSSDStiffenerWidth,
1129                                             0.5*fgkSSDStiffenerHeight);
1130   localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1131                                             fgkSSDModuleStiffenerPosition[1],0.0);
1132
1133   localhybridtrans[2] = new TGeoTranslation(
1134                       -  0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1135                       -      (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1136                               fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1137                       +         0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1138                       -         0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1139                       -       fgkSSDSensorCenterSupportThickness[0]),
1140                       -      (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
1141                       -       fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight));
1142   fhybridmatrix = new TGeoHMatrix();
1143   for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1144   /////////////////////////////////////////////////////////////
1145   // SSD Cooling Block Transformations
1146   /////////////////////////////////////////////////////////////
1147   const Int_t kcoolingblockmatrixnumber = 4;
1148   TGeoTranslation* localcoolingblocktrans[kcoolingblockmatrixnumber];
1149   localcoolingblocktrans[0] = new TGeoTranslation(-2.*(fgkCoolingTubeSupportRmax
1150                             -  fgkCoolingTubeSupportRmin),0.0,
1151                                0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1152   localcoolingblocktrans[1] = new TGeoTranslation(0.5*fgkSSDStiffenerLength
1153                             -  0.5*fgkSSDModuleSensorSupportDistance-fgkSSDCoolingBlockLength,
1154                                0.0,fgkSSDStiffenerHeight);
1155   localcoolingblocktrans[2] = new TGeoTranslation(*localhybridtrans[1]);
1156   localcoolingblocktrans[3] = new TGeoTranslation(*localhybridtrans[2]);
1157   fcoolingblocksystematrix = new TGeoHMatrix();
1158   for(Int_t i=0; i<kcoolingblockmatrixnumber; i++)
1159       fcoolingblocksystematrix->MultiplyLeft(localcoolingblocktrans[i]);
1160   /////////////////////////////////////////////////////////////
1161   // SSD Stiffener Flex Transformations
1162   /////////////////////////////////////////////////////////////
1163   const Int_t klocalflexmatrixnumber = 4;
1164   TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1165   for(Int_t i=0; i<fgkflexnumber; i++)
1166       localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1167   for(Int_t i=0; i<fgkflexnumber; i++)
1168       for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1169             localflexmatrix[i][j] = new TGeoCombiTrans();
1170   Double_t ssdstiffenerseparation = fgkSSDSensorLength
1171                                                                   - 2.*fgkSSDModuleStiffenerPosition[1]
1172                                                                   -    fgkSSDStiffenerWidth;
1173   localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1174                                         +0.5*fgkSSDStiffenerLength,
1175                                          0.5*fgkSSDStiffenerWidth,
1176                                         -0.5*fgkSSDStiffenerHeight
1177                                         -0.5*fgkSSDFlexHeight[0]);
1178   localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1179                                         +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1180                                         -0.5*fgkSSDStiffenerWidth,
1181                                         -0.5*fgkSSDStiffenerHeight
1182                                         -0.5*fgkSSDFlexHeight[0]);
1183   TGeoRotation* localflexrot = new TGeoRotation();
1184   localflexrot->SetAngles(180.,0.,0.);
1185   localflexmatrix[1][0]->SetRotation(localflexrot);
1186   for(Int_t i=0; i<fgkflexnumber; i++)
1187       for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1188             localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1189   for(Int_t i=0; i<fgkflexnumber; i++){
1190       fstiffenerflexmatrix[i] = new TGeoHMatrix();
1191       for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1192             fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
1193   }
1194   /////////////////////////////////////////////////////////////
1195   // SSD End Flex Transformations
1196   /////////////////////////////////////////////////////////////
1197   TGeoRotation* localendflexrot = new TGeoRotation();
1198   localendflexrot->SetAngles(0.0,90.0,0.0);
1199   TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1200   Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1201                             /  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1202   Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1203                             * TMath::DegToRad()*ssdflexradiusmax
1204                                                                - fgkSSDFlexLength[2]-TMath::Pi()
1205                                                                * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
1206   Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1207                             + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1208                             +      fgkSSDFlexLength[2];
1209   localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1210                               0.5*fgkSSDFlexWidth[0],
1211                               2.*fgkSSDStiffenerHeight
1212                             + 0.5*fgkSSDFlexHeight[0]);
1213   localendflexmatrix->SetRotation(localendflexrot);
1214   for(Int_t i=0; i<fgkflexnumber; i++)
1215       fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1216   /////////////////////////////////////////////////////////////
1217   // End Ladder Carbon Fiber Junction
1218   /////////////////////////////////////////////////////////////
1219   TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1220   TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1221   TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1222   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1223       localendladdercarbonfiberjunctionmatrix[i]
1224             = new TGeoCombiTrans*[fgkendladdercabonfiberjunctionmatrixnumber];
1225       localendladdercarbonfiberjunctionrot[i]
1226             = new TGeoRotation*[fgkendladdercabonfiberjunctionmatrixnumber];
1227       localendladdercarbonfiberjunctiontrans[i]
1228             = new TGeoTranslation*[fgkendladdercabonfiberjunctionmatrixnumber];
1229       fendladdercarbonfiberjunctionmatrix[i]
1230             = new TGeoHMatrix*[fgkendladdercabonfiberjunctionmatrixnumber];
1231   }
1232   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1233       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1234             localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1235             localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1236       }
1237   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1238       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
1239           localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1240   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1241       localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1242                               0.0,0.0);
1243       localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1244                 *                     CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1245                 *                     SinD(fgkCarbonFiberTriangleAngle),
1246                         0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1247   -                          fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1248   }
1249   TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1250   TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1251   TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1252   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1253       localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1254       localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1255       localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1256       localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1257             0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1258       localendladdercarbonfiberjunctionglobalmatrix[i] =
1259             new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1260                                *localendladdercarbonfiberjunctionglobalrot[i]);
1261   }
1262   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1263       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1264             localendladdercarbonfiberjunctionmatrix[i][j] =
1265                   new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1266                                      *localendladdercarbonfiberjunctionrot[i][j]);
1267            fendladdercarbonfiberjunctionmatrix[i][j] =
1268             new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1269             *               (*localendladdercarbonfiberjunctionmatrix[i][j]));
1270       }
1271   /////////////////////////////////////////////////////////////
1272   // End Ladder Carbon Fiber Support
1273   /////////////////////////////////////////////////////////////
1274   TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1275   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1276       localendladdercarbonfibertrans[i] = new TGeoTranslation();
1277       localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1278             i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1279       fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1280   }
1281   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1282       for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1283             fendladdercarbonfibermatrix[i][j] =
1284             new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1285             *(*fcarbonfibersupportmatrix[j]));
1286   /////////////////////////////////////////////////////////////
1287   // End Ladder SSD Mounting Block
1288   /////////////////////////////////////////////////////////////
1289   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1290       fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1291   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1292       fendladdermountingblockcombitrans[i]->SetTranslation(-  0.25*(fgkSSDMountingBlockLength[0]
1293                                 +        fgkSSDMountingBlockLength[1])
1294                                 +  0.5*fgkCarbonFiberTriangleLength,
1295                                 fgkEndLadderMountingBlockPosition[i],
1296                                 -  fgkSSDMountingBlockHeight[1]
1297                                 +  0.5*fgkSSDMountingBlockHeight[0]);
1298   TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1299   endladdermountingblockrot->SetAngles(0.,90.,0.);
1300   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1301         fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1302   /////////////////////////////////////////////////////////////
1303   // End Ladder SSD Mounting Block Clip Matrix
1304   /////////////////////////////////////////////////////////////
1305   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1306         fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1307
1308   TGeoRotation* localendladdercliprot = new TGeoRotation();
1309   TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1310   localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1311                                                                                   -     fgkSSDMountingBlockLength[1])
1312                                                                                   + fgkSSDMountingBlockLength[0],0.,0.);
1313   localendladdercliprot->SetAngles(90.,180.,-90.);
1314   TGeoCombiTrans* localendladderclipcombitrans =
1315                         new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1316   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1317         for(Int_t j=0; j<2; j++){
1318                 fendladdermountingblockclipmatrix[i][j] =
1319                                                 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1320                 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1321         }
1322   /////////////////////////////////////////////////////////////
1323   // End Ladder Carbon Fiber Lower Support
1324   /////////////////////////////////////////////////////////////
1325   for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1326       fendladderlowersupptrans[i] =
1327             new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1328                         +  0.5*fgkSSDMountingBlockWidth),
1329                         -  0.5*fgkCarbonFiberLowerSupportHeight);
1330   fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1331                                                                          fgkCarbonFiberLowerSupportVolumePosition[1]
1332                                                                 +    fgkCarbonFiberLowerSupportVolumePosition[0],
1333                                                                          0.0);
1334   fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1335  /////////////////////////////////////////////////////////////
1336   // Matrix for positioning Ladder into mother volume
1337   /////////////////////////////////////////////////////////////
1338   TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1339   for(Int_t i=0; i<fgkladdernumber; i++)
1340         ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1341   TGeoRotation* localladdermotherrot = new TGeoRotation();
1342   localladdermotherrot->SetAngles(0.,90.,0.);
1343   TGeoTranslation* localladdermothertrans[fgkladdernumber];
1344   TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1345   for(Int_t i=0; i<fgkladdernumber; i++){
1346         localladdermothertrans[i] = new TGeoTranslation(0.,
1347                                                           - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1348                                                           + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1349                                                           + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1350                                                           * fgkCarbonFiberJunctionWidth,0.);
1351         localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1352                                                                                                                 *localladdermotherrot);
1353         ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1354         ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
1355   }
1356   /////////////////////////////////////////////////////////////
1357   // Ladder Cables Matrices
1358   /////////////////////////////////////////////////////////////
1359   Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
1360                                              + fgkSSDFlexHeight[1];
1361   Double_t ssdladdercabletransx[3];
1362   ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1363                                                   *   SinD(2.*fgkSSDFlexAngle)
1364                                                   *       CosD(2.*fgkSSDFlexAngle);
1365   ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1366                                                   -     ssdladdercabletransx[0]
1367                                                   /     SinD(2.*fgkSSDFlexAngle))
1368                                                   *     CosD(fgkSSDFlexAngle);
1369   ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1370                                                   *       TMath::DegToRad()*ssdflexradiusmax
1371                                                   -     fgkSSDFlexLength[2]-TMath::Pi()
1372                                                   *       fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1373                                                   -       fgkSSDLadderCableWidth)
1374                                                   *       CosD(2.*fgkSSDFlexAngle);
1375   Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
1376                                                   *     TanD(2.*fgkSSDFlexAngle),
1377                                                         ssdladdercabletransx[1]
1378                                                   *     TanD(fgkSSDFlexAngle),
1379                                                         ssdladdercabletransx[2]
1380                                                   *     TanD(2.*fgkSSDFlexAngle)};
1381   TGeoRotation* localladdercablerot[3];
1382   for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1383   localladdercablerot[0]->SetAngles(90.,0.,0.);
1384   localladdercablerot[1]->SetAngles(90.,60.,-90.);
1385   localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1386                                                  *                        (*localladdercablerot[0]));
1387   ////////////////////////////////////////////
1388   // LocalLadderCableCombiTransMatrix
1389   ////////////////////////////////////////////
1390   const Int_t klocalladdersidecablesnumber = 2;
1391   const Int_t klocalladdercombitransnumber = 5;
1392   TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1393   for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1394          localladdercablecombitransmatrix[i] =
1395                                                            new TGeoCombiTrans*[klocalladdercombitransnumber];
1396   ///////////////////////////////////////////
1397   // Left Side Ladder Cables Transformations
1398   ///////////////////////////////////////////
1399   localladdercablecombitransmatrix[0][0]  =
1400                                                 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1401                                                 0.,0.,NULL);
1402   localladdercablecombitransmatrix[0][1] =
1403         new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1404                                            - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1405                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1406                                            + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1407                                            - 0.5*(fgkCarbonFiberLowerSupportWidth
1408                                            + fgkSSDSensorCenterSupportLength
1409                                            - fgkSSDSensorCenterSupportThickness[0]),
1410                                            - (fgkSSDModuleCoolingBlockToSensor
1411                                            + 0.5*fgkCoolingTubeSupportHeight
1412                                            - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1413                                            - fgkSSDChipHeight),NULL);
1414   localladdercablecombitransmatrix[0][2] =
1415                                                 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1416                                                                                    fgkSSDModuleStiffenerPosition[1],0.,0);
1417   localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1418                                         0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1419                                    +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1420                                    fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1421                                          - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1422                                                                                                 new TGeoRotation("",180.,0.,0.));
1423   localladdercablecombitransmatrix[0][4] =
1424                                                 new TGeoCombiTrans(-ssdladdercabletransx[0]
1425                                                 -     ssdladdercabletransx[1]-ssdladdercabletransx[2]
1426                                                 +     fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1427                                                           0.,
1428                                                           0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1429                                                 +         fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
1430                                                 +     ssdladdercabletransz[0]-ssdladdercabletransz[1]
1431                                                 +         ssdladdercabletransz[2],localladdercablerot[2]);
1432   ///////////////////////////////////////////
1433   // Rigth Side Ladder Cables Transformations
1434   ///////////////////////////////////////////
1435   TGeoCombiTrans* localladdercablessdmodulematrix =
1436         new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1437                                                                   - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1438                                                                          fgkSSDStiffenerWidth,
1439                                                                   - 0.5*fgkSSDFlexHeight[0],NULL);
1440   for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1441    localladdercablecombitransmatrix[1][i] =
1442                         (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1443                                         new TGeoCombiTrans(*localladdercablessdmodulematrix));
1444   ///////////////////////////////////////////
1445   // Setting LadderCableHMatrix
1446   ///////////////////////////////////////////
1447   Int_t beamaxistrans[2][3];
1448   beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1449   beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1450   beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1451   beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1452   beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1453   beamaxistrans[1][2] = beamaxistrans[1][0];
1454   TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1455   TGeoRotation* laddercablerot = new TGeoRotation();
1456   TGeoTranslation* laddercabletrans = new TGeoTranslation();
1457   TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1458   Double_t* laddercabletransvector;
1459   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1460         localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1461         fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1462   }
1463   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1464         for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1465                 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1466                 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1467                         localladdercablehmatrix[i][j]->MultiplyLeft(
1468                         localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1469         }
1470                 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1471                 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1472                 laddercabletrans->SetTranslation(laddercabletransvector[0],
1473                                                                          laddercabletransvector[1]
1474                                         +                (j==0 ? beamaxistrans[i][0] : 0.)
1475                                         *                                fgkCarbonFiberJunctionWidth,
1476                                                                          laddercabletransvector[2]);
1477                 laddercablecombitrans->SetRotation(*laddercablerot);
1478                 laddercablecombitrans->SetTranslation(*laddercabletrans);
1479                 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1480         }
1481     fladdercablematrix[i][2] =
1482                                         AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1483                                         beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1484         fladdercablematrix[i][3] =
1485                                         AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1486                                         beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1487   }
1488   for(Int_t i=0; i<fgkladdercablesnumber; i++)
1489         for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1490                 fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1491   ///////////////////////////////////////////
1492   // Setting Ladder HMatrix
1493   ///////////////////////////////////////////
1494   Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1495                                                                                                 fgkSSDLay6SensorsNumber};
1496   for(Int_t i=0; i<fgkladdernumber; i++){
1497         fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1498         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1499                 fladdermatrix[i][j] = new TGeoHMatrix();
1500                 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1501                 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1502                 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1503         }
1504   }
1505   ///////////////////////////////////////////
1506   // Setting SSD Sensor Matrix
1507   ///////////////////////////////////////////
1508   TGeoCombiTrans* localssdsensorcombitrans[2];
1509   TGeoRotation* localssdsensorrot = new TGeoRotation();
1510   localssdsensorrot->SetAngles(0.,90.,0.);
1511   TGeoTranslation* localssdsensortrans[2];
1512   for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1513   localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1514                                           -             (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1515                               fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1516                       +         0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1517                       -         0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1518                       -       fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
1519                                                         0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1520                                           -             fgkSSDModuleCoolingBlockToSensor-0.5*fgkSSDModuleVerticalDisalignment
1521                                           +    (fgkSSDSensorSideSupportHeight[1]
1522                                           -             fgkSSDSensorSideSupportHeight[0]));
1523   localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1524                                           -        (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1525                               fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1526                       +         0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1527                       -         0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1528                       -       fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
1529                                                     0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1530                                                         -fgkSSDModuleCoolingBlockToSensor-0.5*fgkSSDModuleVerticalDisalignment);
1531   for(Int_t i=0; i<2; i++)
1532         localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1533                                                                                                          *localssdsensorrot);
1534     for(Int_t i=0; i<fgkladdernumber; i++){
1535         fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1536         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1537                 switch(i){
1538                         case 0: //Ladder of Layer5
1539                         fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1540                                                                    * ((j%2==0 ? *localssdsensorcombitrans[0] :
1541                                                                                                 *localssdsensorcombitrans[1])));
1542                         break;
1543                         case 1: //Ladder of Layer6
1544                         fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1545                                                                    * ((j%2==0 ? *localssdsensorcombitrans[1] :
1546                                                                                                 *localssdsensorcombitrans[0])));
1547                 break;
1548                 }
1549           }
1550   }
1551   //////////////////////////
1552   // Setting SSD End Ladder
1553   //////////////////////////
1554   for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1555   for(Int_t i=0; i<2; i++){
1556         fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1557         fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1558         fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1559         fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1560         fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1561         fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1562         fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1563         fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1564    }
1565   /////////////////////////////////////////////////////
1566   // Setting the CombiTransformation to pass ITS center
1567   /////////////////////////////////////////////////////
1568   Double_t itscentertransz[fgklayernumber];
1569   itscentertransz[0] = fgkSSDLay5LadderLength
1570                                          - fgkLay5CenterITSPosition;
1571   itscentertransz[1] = fgkSSDLay6LadderLength
1572                                          - fgkLay6CenterITSPosition;
1573   Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1574                                                    + 0.5*fgkCoolingTubeSupportHeight;
1575   TGeoRotation* itscenterrot[3];
1576   for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1577   itscenterrot[0]->SetAngles(90.,180.,-90.);
1578   itscenterrot[1]->SetAngles(0.,90.,0.);
1579   itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1580   TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1581   for(Int_t i=0; i<fgklayernumber; i++)
1582         itscentercombitrans[i] = new TGeoCombiTrans(0.,
1583                                                          itssensortransy,
1584                                                          fgkEndLadderCarbonFiberLowerJunctionLength[1]
1585                                                    - itscentertransz[i],itscenterrot[2]);
1586   TGeoRotation** locallayerrot[fgklayernumber];
1587   TGeoTranslation** locallayertrans[fgklayernumber];
1588   TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1589   TGeoTranslation* localbeamaxistrans[fgklayernumber];
1590   localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1591                                          - fgkLay5CenterITSPosition);
1592   localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1593                                          - fgkLay6CenterITSPosition);
1594   const Int_t kssdlayladdernumber[fgklayernumber] =
1595                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1596   for(Int_t i=0; i<fgklayernumber; i++){
1597     locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1598     locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1599         locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1600         flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1601   }
1602   Double_t layerladderangleposition[fgklayernumber] =
1603                 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1604   Double_t layerradius = 0.;
1605   for(Int_t i=0; i<fgklayernumber; i++){
1606         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1607                 switch(i){
1608                         case 0: //Ladder of Layer5
1609                         layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1610                         break;
1611                         case 1: //Ladder of Layer6
1612                         layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1613                 break;
1614                 }
1615                 locallayerrot[i][j] = new TGeoRotation();
1616                 locallayertrans[i][j] = new TGeoTranslation();
1617                 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1618                 locallayertrans[i][j]->SetTranslation(layerradius
1619                                                           *     CosD(90.0+j*layerladderangleposition[i]),
1620                                                             layerradius
1621                                                           * SinD(90.0+j*layerladderangleposition[i]),0.);
1622                 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1623                                                                          *locallayerrot[i][j]);
1624                 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1625                 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1626                 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1627         }
1628   }
1629   /////////////////////////////////////////////////////////////
1630   // Deallocating memory
1631   /////////////////////////////////////////////////////////////
1632   for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1633         delete carbonfiberot[i];
1634         delete localcarbonfibersupportmatrix[i];
1635   }
1636   for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1637      for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1638        delete localcarbonfiberjunctionmatrix[i][j];
1639            delete localcarbonfiberjunctionrot[i][j];
1640            delete localcarbonfiberjunctiontrans[i][j];
1641            }
1642        delete [] localcarbonfiberjunctionmatrix[i];
1643        delete [] localcarbonfiberjunctionrot[i];
1644        delete [] localcarbonfiberjunctiontrans[i];
1645   }
1646   for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1647            delete localcarbonfiberlowersupportrans[i];
1648   for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1649      for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1650        delete localssdsensorsupportmatrix[i][j];
1651            delete localssdsensorsupportrot[i][j];
1652            delete localssdsensorsupportrans[i][j];
1653            }
1654        delete [] localssdsensorsupportmatrix[i];
1655        delete [] localssdsensorsupportrot[i];
1656        delete [] localssdsensorsupportrans[i];
1657   }
1658   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1659         delete localcoolingtubesupportmatrix[i];
1660         delete localcoolingtubesupportrot[i];
1661         delete localcoolingtubesupportrans[i];
1662   }
1663   for(Int_t i=0; i<4; i++){
1664         for(Int_t j=0; j<2; j++){
1665                 delete localcoolingtubevect[i][j];
1666                 delete localcoolingtubetrans[i][j];
1667         }
1668         delete [] localcoolingtubevect[i];
1669         delete [] localcoolingtubetrans[i];
1670   }
1671  delete endladdermountingblockrot;
1672  for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
1673  for(Int_t i=0; i<kcoolingblockmatrixnumber; i++) delete localcoolingblocktrans[i];
1674  for(Int_t i=0; i<fgkflexnumber; i++){
1675       for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1676             delete localflexmatrix[i][j];
1677       delete [] localflexmatrix[i];
1678  }
1679  delete localendlladdercoolingtuberot;
1680  for(Int_t i=0; i<2; i++){
1681         for(Int_t j=0; j<(i==0?6:4); j++)
1682                 delete localendlladdercoolingtubetrans[i][j];
1683         delete [] localendlladdercoolingtubetrans[i];
1684   }
1685
1686  delete localflexrot;
1687  delete localendflexrot;
1688  delete localendflexmatrix;
1689  for(Int_t i=0; i<fgkladdernumber; i++){
1690         delete localladdermothertrans[i];
1691         delete localladdermothercombitrans[i];
1692   }
1693  delete localladdermotherrot;
1694  for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1695       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1696             delete localendladdercarbonfiberjunctionmatrix[i][j];
1697             delete localendladdercarbonfiberjunctionrot[i][j];
1698             delete localendladdercarbonfiberjunctiontrans[i][j];
1699       }
1700       delete [] localendladdercarbonfiberjunctionmatrix[i];
1701       delete [] localendladdercarbonfiberjunctionrot[i];
1702       delete [] localendladdercarbonfiberjunctiontrans[i];
1703       delete localendladdercarbonfiberjunctionglobalrot[i];
1704       delete localendladdercarbonfiberjunctionglobaltrans[i];
1705       delete localendladdercarbonfiberjunctionglobalmatrix[i];
1706  }
1707   for(Int_t i=0; i<2; i++){
1708         for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1709         delete [] localendladdercooltubetrans[i];
1710   }
1711   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1712       delete localendladdercarbonfibertrans[i];
1713   for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1714   for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1715         for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1716                 delete localladdercablecombitransmatrix[i][j];
1717                 delete []localladdercablecombitransmatrix[i];
1718   }
1719   delete localendladdercliprot;
1720   delete localendladdercliptrans;
1721   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1722         for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1723                 delete localladdercablehmatrix[i][j];
1724         delete []localladdercablehmatrix[i];
1725   }
1726   delete laddercablerot;
1727   delete laddercabletrans;
1728   delete laddercablecombitrans;
1729   delete localladdercablessdmodulematrix;
1730   delete localssdsensorrot;
1731   for(Int_t i=0; i<2; i++){
1732         delete localssdsensortrans[i];
1733         delete localssdsensorcombitrans[i];
1734   }
1735   for(Int_t i=0; i<fgklayernumber; i++){
1736         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1737                 delete locallayerrot[i][j];
1738                 delete locallayertrans[i][j];
1739                 delete locallayercombitrans[i][j];
1740     }
1741         delete [] locallayerrot[i];
1742         delete [] locallayertrans[i];
1743         delete [] locallayercombitrans[i];
1744         delete localbeamaxistrans[i];
1745   }
1746   for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1747   for(Int_t i=0; i<fgkladdernumber; i++){
1748         for(Int_t j=0; j<fgkladdernumber; j++)
1749                 delete ladderglobalmatrix[i][j];
1750         delete [] ladderglobalmatrix[i];
1751   }
1752   /////////////////////////////////////////////////////////////
1753   fTransformationMatrices = kTRUE;
1754 }
1755 ///////////////////////////////////////////////////////////////////////////////
1756 void AliITSv11GeometrySSD::CreateBasicObjects(){
1757   /////////////////////////////////////////////////////////////
1758   // Method generating the Objects of SSD Geometry
1759   /////////////////////////////////////////////////////////////
1760   // SSD Sensor
1761   ///////////////////////////////////
1762   SetSSDSensor();
1763   /////////////////////////////////////////////////////////////
1764   // Carbon Fiber Support
1765   /////////////////////////////////////////////////////////////
1766   TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1767   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1768       fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
1769   /////////////////////////////////////////////////////////////
1770   // Carbon Fiber Junction
1771   /////////////////////////////////////////////////////////////
1772   fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth);
1773   /////////////////////////////////////////////////////////////
1774   // Carbon Fiber Lower Support
1775   /////////////////////////////////////////////////////////////
1776   TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1777   for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1778         fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1779   /////////////////////////////
1780   // SSD Sensor Support
1781   /////////////////////////////
1782   for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1783                                                                                 new TGeoVolume*[fgkssdsensorsupportnumber];
1784   Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
1785                                                                          fgkSSDSensorSideSupportThickness[1]};
1786   for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1787         fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1788                                                                                            fgkSSDSensorSideSupportHeight[i],
1789                                                                                            fgkSSDSensorSideSupportWidth,
1790                                                                                            sidesupporthickness);
1791         fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1792                                                                                            fgkSSDSensorCenterSupportHeight[i],
1793                                                                                            fgkSSDSensorCenterSupportWidth,
1794                                                                                            sidesupporthickness);
1795   }
1796   /////////////////////////////////////////////////////////////
1797   // SSD Cooling Tube Support
1798   /////////////////////////////////////////////////////////////
1799   Int_t edgesnumber = 16;
1800   fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1801   /////////////////////////////////////////////////////////////
1802   // SSD Hybrid
1803   /////////////////////////////////////////////////////////////
1804   TList* ssdhybridcomponentslist = GetSSDHybridParts();
1805   for(Int_t i=0; i<fgkhybridcompnumber; i++)
1806         fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1807   /////////////////////////////////////////////////////////////
1808   // SSD Cooling Block System
1809   /////////////////////////////////////////////////////////////
1810   fssdcoolingblocksystem = GetCoolingBlockSystem();
1811    /////////////////////////////////////////////////////////////
1812   // SSD Cooling Tube
1813   /////////////////////////////////////////////////////////////
1814   TList* coolingtubelist = GetCoolingTubeList();
1815   for(Int_t i=0; i<fgkcoolingtubenumber; i++)
1816         fcoolingtube[i] = (TGeoVolume*)coolingtubelist->At(i);
1817   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
1818         fendladdercoolingtube[i] =
1819                         (TGeoVolume*)coolingtubelist->At(fgkcoolingtubenumber+i);
1820   /////////////////////////////////////////////////////////////
1821   // SSD Flex
1822   /////////////////////////////////////////////////////////////
1823   fssdstiffenerflex = GetSSDStiffenerFlex();
1824   fssdendflex = GetSSDEndFlex();
1825   ///////////////////////////////////
1826   // End Ladder Carbon Fiber Junction
1827   ///////////////////////////////////
1828   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1829                                                    fendladdercarbonfiberjunction[i] =
1830                                                    new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1831   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1832     fendladdercarbonfiberjunction[i][0] =
1833                   GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]);
1834     fendladdercarbonfiberjunction[i][1] =
1835                   GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]);
1836   }
1837   ///////////////////////////////////
1838   // End Ladder Mounting Block
1839   ///////////////////////////////////
1840   fendladdermountingblock = GetSSDMountingBlock();
1841   ///////////////////////////////////
1842   // End Ladder Mounting Block
1843   ///////////////////////////////////
1844   fendladdermountingblockclip = GetMountingBlockClip();
1845   ///////////////////////////////////
1846   // Ladder Support
1847   ///////////////////////////////////
1848   TList* laddersupportlist = GetMountingBlockSupport(20);
1849   fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1850   fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1851   fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1852   fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
1853   /////////////////////////////////////////////////////////////
1854   // Deallocating memory
1855   /////////////////////////////////////////////////////////////
1856   delete carbonfibersupportlist;
1857   delete carbonfiberlowersupportlist;
1858   delete ssdhybridcomponentslist;
1859   delete laddersupportlist;
1860   /////////////////////////////////////////////////////////////
1861   fBasicObjects = kTRUE;
1862 }
1863 /////////////////////////////////////////////////////////////////////////////////
1864 void AliITSv11GeometrySSD::SetSSDSensor(){
1865   ////////////////////////////////////////////////////////////////
1866   // Method generating SSD Sensors: it sets the private variables
1867   // fSSDSensor5, fSSDSensor6
1868   ////////////////////////////////////////////////////////////////
1869   Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1870   Double_t ssdsensitivewidth  = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1871   TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
1872                                                 0.5*ssdsensitivewidth,
1873                                                 0.5*fgkSSDSensorHeight,
1874                                                 0.5*ssdsensitivelength);
1875   TGeoVolume* ssdsensorsensitiveLay5 =
1876         new TGeoVolume(fgSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
1877   TGeoVolume* ssdsensorsensitiveLay6 =
1878         new TGeoVolume(fgSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
1879   ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1880   ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
1881   TGeoBBox* ssdsensorinsensitiveshape[2];
1882   ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
1883                                                 0.5*fgkSSDSensorInsensitiveWidth,
1884                                                 0.5*fgkSSDSensorHeight,
1885                                                 0.5*fgkSSDSensorLength);
1886   ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
1887                                                 0.5*ssdsensitivewidth,
1888                                                 0.5*fgkSSDSensorHeight,
1889                                                 0.5*fgkSSDSensorInsensitiveWidth);
1890   const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
1891                                              "SSDSensorInsensitive2"};
1892   TGeoVolume* ssdsensorinsensitive[2];
1893   for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1894       new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1895                      fSSDSensorMedium);
1896       ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
1897   }
1898   /////////////////////////////////////////////////////////////
1899   // Virtual Volume containing SSD Sensor
1900   /////////////////////////////////////////////////////////////
1901   TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1902                                                                                              0.5*fgkSSDSensorWidth,
1903                                                                                              0.5*fgkSSDSensorHeight,
1904                                                                                              0.5*fgkSSDSensorLength);
1905   fSSDSensor5 = new TGeoVolume("ITSssdSensor5",virtualSSDSensorShape,
1906                                                                                  fSSDAir);
1907   fSSDSensor6 = new TGeoVolume("ITSssdSensor6",virtualSSDSensorShape,
1908                                                                                  fSSDAir);
1909   /////////////////////////////////////////////////////////////
1910   for(Int_t i=0; i<4; i++){
1911             fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1912             ssdsensorinsensitive[1],i<2?1:2,
1913                         new TGeoTranslation(
1914                          0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1915       *   (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1916                         0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1917       *   (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1918             fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1919             ssdsensorinsensitive[1],i<2?1:2,
1920                         new TGeoTranslation(
1921                          0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1922       *   (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1923                         0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1924       *   (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1925   }
1926     fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1927     fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
1928 }
1929 ///////////////////////////////////////////////////////////////////////////////
1930 TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1931   /////////////////////////////////////////////////////////////
1932   // Method generating the Carbon Fiber Support
1933   /////////////////////////////////////////////////////////////
1934   const Int_t kvertexnumber = 4;
1935   const Int_t kshapesnumber = 2;
1936   TVector3** vertexposition[kshapesnumber];
1937   for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1938   Double_t carbonfibersupportxaxisEdgeproj =
1939                 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1940         *       TMath::DegToRad());
1941   Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1942                                  /                         fgkCarbonFiberSupportXAxisLength);
1943   /////////////////////
1944   //Vertex Positioning
1945   ////////////////////
1946   vertexposition[0][0] = new TVector3();
1947   vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
1948                                                                           fgkCarbonFiberSupportYAxisLength);
1949   vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
1950                                                                           carbonfibersupportxaxisEdgeproj
1951                                            *                      TMath::Tan(theta));
1952   vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
1953                                            -                      carbonfibersupportxaxisEdgeproj,
1954                                                                           fgkCarbonFiberSupportYAxisLength
1955                                            -                      vertexposition[0][2]->Y());
1956   ////////////////////////////////////////////////////
1957   //Setting the parameters for Isometry Transformation
1958   ////////////////////////////////////////////////////
1959   Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
1960                                                                  +      fgkCarbonFiberSupportTopEdgeDist[0]
1961                                                                  +      fgkCarbonFiberSupportWidth);
1962   Double_t* param = new Double_t[4];
1963   param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
1964   for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
1965                                   new TVector3((GetReflection(vertexposition[0][j],param))->X(),
1966                                                           (GetReflection(vertexposition[0][j],param))->Y());
1967   char* carbonfibersupportshapename[kshapesnumber] =
1968                                                 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
1969   char* carbonfibersupportname[kshapesnumber] =
1970                                                 {"CarbonFiberSupport1","CarbonFiberSupport2"};
1971   TGeoArb8* carbonfibersupportshape[kshapesnumber];
1972   TGeoVolume* carbonfibersupport[kshapesnumber];
1973   TList* carbonfibersupportlist = new TList();
1974   Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
1975   Double_t carbonfibersupportheight =
1976           carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1977           *TMath::DegToRad());
1978   for(Int_t i = 0; i< kshapesnumber; i++){
1979    carbonfibersupportshape[i] =
1980                                         GetArbShape(vertexposition[i],width,carbonfibersupportheight,
1981                                                                 carbonfibersupportshapename[i],i==0 ? 1: -1);
1982    carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
1983                                                    carbonfibersupportshape[i],fSSDCarbonFiberMedium);
1984    carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
1985    carbonfibersupportlist->Add(carbonfibersupport[i]);
1986    }
1987   /////////////////////////////////////////////////////////////
1988   // Deallocating memory
1989   /////////////////////////////////////////////////////////////
1990   for(Int_t i=0; i< kshapesnumber; i++){
1991      for(Int_t j=0; j< kvertexnumber; j++)
1992            delete vertexposition[i][j];
1993        delete [] vertexposition[i];
1994   }
1995   delete [] param;
1996   /////////////////////////////////////////////////////////////
1997    return carbonfibersupportlist;
1998 }
1999 /////////////////////////////////////////////////////////////////////////////////
2000 TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
2001   /////////////////////////////////////////////////////////////
2002   // Method generating SSD Carbon Fiber Junction
2003   /////////////////////////////////////////////////////////////
2004   const Int_t kvertexnumber = 6;
2005   TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
2006   Double_t reflectionparam[3] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
2007                                                           *  TMath::DegToRad()),-1.,0.};
2008   TVector3* vertex[kvertexnumber];
2009   vertex[0] = new TVector3();
2010   vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
2011                         *                         TMath::Cos(fgkCarbonFiberJunctionAngle[0]
2012                         *                         TMath::DegToRad()),
2013                                                   fgkCarbonFiberJunctionEdge[0]
2014                         *                         TMath::Sin(fgkCarbonFiberJunctionAngle[0]
2015                         *                         TMath::DegToRad()));
2016   vertex[4] = new TVector3(fgkCarbonFiberJunctionLength,
2017                                                    fgkCarbonFiberJunctionEdge[1]);
2018   vertex[5] = new TVector3(fgkCarbonFiberJunctionLength);
2019   vertex[1] = GetReflection(vertex[5],reflectionparam);
2020   vertex[2] = GetReflection(vertex[4],reflectionparam);
2021   Double_t xvertexpoints[6], yvertexpoints[6];
2022   for(Int_t i=0; i<kvertexnumber; i++)
2023           xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
2024   carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2025   carbonfiberjunctionshape->DefineSection(0,-0.5*width);
2026   carbonfiberjunctionshape->DefineSection(1,0.5*width);
2027   TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
2028                                                                 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
2029   carbonfiberjunction->SetLineColor(fColorCarbonFiber);
2030   /////////////////////////////////////////////////////////////
2031   // Deallocating memory
2032   /////////////////////////////////////////////////////////////
2033   for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
2034   /////////////////////////////////////////////////////////////
2035   return carbonfiberjunction;
2036 }
2037 ////////////////////////////////////////////////////////////////////////////////
2038 TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
2039   /////////////////////////////////////////////////////////////
2040   // Method generating the Carbon Fiber Lower Support
2041   /////////////////////////////////////////////////////////////
2042   const Int_t kvertexnumber = 4;
2043   const Int_t kshapesnumber = 2;
2044   Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
2045                                                                 fgkCarbonFiberLowerSupportWidth};
2046   TVector3** vertexposition[kshapesnumber];
2047   for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
2048                                                  new TVector3*[kvertexnumber];
2049   //First Shape Vertex Positioning
2050   vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
2051   vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
2052                                            -            fgkCarbonFiberLowerSupportLowerLenght);
2053   vertexposition[0][2] = new TVector3();
2054   vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
2055   //Second Shape Vertex Positioning
2056   Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
2057                                  -                              fgkCarbonFiberLowerSupportVolumePosition[0])
2058                                  /                              fgkCarbonFiberTriangleLength);
2059   vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
2060                                                                 vertexposition[0][0]->X()*TMath::Tan(theta)
2061                                  +                              fgkCarbonFiberLowerSupportVolumePosition[0]);
2062   vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
2063                                                                 vertexposition[0][1]->X()*TMath::Tan(theta)
2064                                  +                              fgkCarbonFiberLowerSupportVolumePosition[0]);
2065   vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
2066   vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
2067                                                                 fgkCarbonFiberLowerSupportVolumePosition[1]);
2068   char* carbonfiberlowersupportshapename[kshapesnumber] =
2069                           {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
2070   char* carbonfiberlowersupportname[kshapesnumber] =
2071                           {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
2072   TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
2073   TGeoVolume* carbonfiberlowersupport[kshapesnumber];
2074   TList* carbonfiberlowersupportlist = new TList();
2075   for(Int_t i = 0; i< kshapesnumber; i++){
2076         carbonfiberlowersupportshape[i] =
2077                                                                 GetArbShape(vertexposition[i],width,
2078                                                                                         fgkCarbonFiberLowerSupportHeight,
2079                                                                                         carbonfiberlowersupportshapename[i]);
2080     carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
2081                                                 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
2082         carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
2083     carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
2084   }
2085   /////////////////////////////////////////////////////////////
2086   // Deallocating memory
2087   /////////////////////////////////////////////////////////////
2088   for(Int_t i=0; i< kshapesnumber; i++){
2089      for(Int_t j=0; j< kvertexnumber; j++)
2090            delete vertexposition[i][j];
2091        delete [] vertexposition[i];
2092   }
2093   /////////////////////////////////////////////////////////////
2094   return carbonfiberlowersupportlist;
2095 }
2096 ///////////////////////////////////////////////////////////////////////////////
2097 TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
2098                                                                  Double_t width, Double_t* thickness)const{
2099   /////////////////////////////////////////////////////////////
2100   // Method generating the Sensor Support
2101   /////////////////////////////////////////////////////////////
2102         const Int_t kvertexnumber = 6;
2103         TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2104     TVector3* vertexposition[kvertexnumber];
2105         vertexposition[0] = new TVector3();
2106         vertexposition[1] = new TVector3(0.0,length);
2107         vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());
2108         vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);
2109         vertexposition[4] = new TVector3(height,vertexposition[3]->Y());
2110         vertexposition[5] = new TVector3(vertexposition[4]->X());
2111         Double_t xvertexpoints[6], yvertexpoints[6];
2112         for(Int_t i=0; i<kvertexnumber; i++)
2113                 xvertexpoints[i] = vertexposition[i]->X(),
2114                 yvertexpoints[i] = vertexposition[i]->Y();
2115     ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2116     ssdsensorsupportshape->DefineSection(0,-0.5*width);
2117     ssdsensorsupportshape->DefineSection(1,0.5*width);
2118     TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2119                                                                  ssdsensorsupportshape,fSSDSensorSupportMedium);
2120   /////////////////////////////////////////////////////////////
2121   // Deallocating memory
2122   /////////////////////////////////////////////////////////////
2123         for (Int_t i=0; i<kvertexnumber; i++)
2124                 delete vertexposition[i];
2125   /////////////////////////////////////////////////////////////
2126     return ssdsensorsupport;
2127 }
2128 ////////////////////////////////////////////////////////////////////////////////
2129 TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2130   /////////////////////////////////////////////////////////////
2131   // Method generating the Cooling Tube Support
2132   /////////////////////////////////////////////////////////////
2133   if(nedges%2!=0) nedges--;
2134   const Int_t kvertexnumber = nedges+5;
2135   Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2136                            /                     fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2137   Double_t angle = 90.+phi;
2138   Double_t psi = 90.-phi;
2139   ///////////////////////////////////////
2140   // Vertex Positioning for TGeoXTru
2141   ///////////////////////////////////////
2142   TVector3** vertexposition = new TVector3*[kvertexnumber];
2143   vertexposition[0] = new TVector3(fgkCoolingTubeSupportRmin*CosD(angle),
2144                                                                    fgkCoolingTubeSupportRmin*SinD(angle));
2145   vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2146                                                                    fgkCoolingTubeSupportRmax*SinD(angle));
2147   vertexposition[2] = new TVector3(vertexposition[1]->X(),
2148                                                                    fgkCoolingTubeSupportRmax);
2149   vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2150                                                                    fgkCoolingTubeSupportRmax);
2151   vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2152                                                                     vertexposition[1]->Y());
2153   for(Int_t i=0; i<nedges; i++)
2154         vertexposition[i+5] =
2155                 new TVector3(fgkCoolingTubeSupportRmin*CosD(psi+i*(2.*phi/nedges)),
2156                                          fgkCoolingTubeSupportRmin*SinD(psi+i*(2.*phi/nedges)));
2157   ///////////////////////////////////////////////////////////////////////
2158   // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2159   ///////////////////////////////////////////////////////////////////////
2160   TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2161   Double_t* xvertexpoints = new Double_t[kvertexnumber];
2162   Double_t* yvertexpoints = new Double_t[kvertexnumber];
2163   for(Int_t i=0; i<kvertexnumber; i++){
2164         xvertexpoints[i] = vertexposition[i]->X();
2165         yvertexpoints[i] = vertexposition[i]->Y();
2166   }
2167   coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2168                                                                                         yvertexpoints);
2169   coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2170   coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2171   TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2172                                                                           coolingtubesupportarcshape,
2173                                                                                   fSSDTubeHolderMedium);
2174   coolingtubesupportarc->SetLineColor(fColorG10);
2175   //////////////////////////////////////////////////////////////////////////
2176   // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2177   //////////////////////////////////////////////////////////////////////////
2178   TGeoTubeSeg* coolingtubesupportsegshape =
2179                                                         new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2180                                                                                         fgkCoolingTubeSupportRmax,
2181                                                                                         0.5*fgkCoolingTubeSupportWidth,
2182                                                                                         phi,360-phi);
2183   TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2184                                                                                         coolingtubesupportsegshape,
2185                                                                                         fSSDTubeHolderMedium);
2186   coolingtubesupportseg->SetLineColor(fColorG10);
2187   //////////////////////////////////////////////////////////////////////////
2188   // TGeoBBox Volume definition for Cooling Tube Support Box Part
2189   //////////////////////////////////////////////////////////////////////////
2190   Double_t* boxorigin = new Double_t[3];
2191   Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2192   boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2193   TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2194                                                                                  0.5*fgkCoolingTubeSupportHeight,
2195                                                                                  0.5*fgkCoolingTubeSupportWidth,boxorigin);
2196   TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2197                                coolingtubesupportboxshape,fSSDTubeHolderMedium);
2198   coolingtubesupportbox->SetLineColor(fColorG10);
2199   //////////////////////////////////////////////////////////////////////////
2200   // Cooling Tube for Cooling Tube Support
2201   //////////////////////////////////////////////////////////////////////////
2202   TGeoXtru* coolingtubearcshape[2];
2203   coolingtubearcshape[0] = new TGeoXtru(2);
2204   Double_t* xvert = new Double_t[nedges+2];
2205   Double_t* yvert = new Double_t[nedges+2];
2206   Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2207   ////////////////////////////////////////
2208   // Positioning the vertices for TGeoXTru
2209   ////////////////////////////////////////
2210   xvert[0] = 0., yvert[0] = 0.;
2211   xvert[1] = vertexposition[0]->X()*ratio,  yvert[1] = vertexposition[0]->Y()*ratio;
2212   for(Int_t i=0; i< nedges; i++)
2213                 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2214                 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2215   ////////////////////////////////////////
2216   // Defining TGeoXTru PolyGone
2217   ////////////////////////////////////////
2218   coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2219   coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2220   coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2221   coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2222                 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2223   TGeoVolume* coolingtubearc[2];
2224   coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2225                                                                   coolingtubearcshape[0],fSSDCoolingTubeWater);
2226   coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2227                                                                   coolingtubearcshape[1],fSSDCoolingTubePhynox);
2228   coolingtubearc[0]->SetLineColor(fColorWater);
2229   coolingtubearc[1]->SetLineColor(fColorPhynox);
2230   ////////////////////////////////////////////
2231   // Defining TGeoTubeSeg Part of Cooling Tube
2232   ////////////////////////////////////////////
2233   TGeoTubeSeg* coolingtubesegshape[2];
2234   coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2235                                                         0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2236   coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2237                                                         0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2238   TGeoVolume* coolingtubeseg[2];
2239   coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2240                                                                  coolingtubesegshape[0],fSSDCoolingTubePhynox);
2241   coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2242                                                                  coolingtubesegshape[1],fSSDCoolingTubeWater);
2243   coolingtubeseg[0]->SetLineColor(fColorPhynox);
2244   coolingtubeseg[1]->SetLineColor(fColorWater);
2245   /////////////////////////////////////////////////////////////
2246   // Virtual Volume containing Cooling Tube Support
2247   /////////////////////////////////////////////////////////////
2248   TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2249   const Int_t kvirtualvertexnumber = 8;
2250   TVector3* virtualvertex[kvirtualvertexnumber];
2251    ////////////////////////////////////////
2252   // Positioning the vertices for TGeoXTru
2253   ////////////////////////////////////////
2254   virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax);
2255   virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
2256   virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
2257   virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
2258   virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
2259   virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
2260   virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
2261   virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
2262   Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2263   for(Int_t i=0; i< kvirtualvertexnumber; i++)
2264         xmothervertex[i] = virtualvertex[i]->X(),
2265         ymothervertex[i] = virtualvertex[i]->Y();
2266   ////////////////////////////////////////
2267   // Defining TGeoXTru PolyGone
2268   ////////////////////////////////////////
2269   virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2270                                                                                                                                          ymothervertex);
2271   virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2272   virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2273   TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2274                                                                  virtualCoolingTubeSupportShape,fSSDAir);
2275   ////////////////////////////////////////
2276   // Positioning Volumes in Virtual Volume
2277   ////////////////////////////////////////
2278   TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2279   coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2280   virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2281   virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2282   virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
2283   virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2284   virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2285   virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2286   virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
2287   /////////////////////////////////////////////////////////////
2288   // Deallocating memory
2289   /////////////////////////////////////////////////////////////
2290   delete [] vertexposition;
2291   delete xvertexpoints;
2292   delete yvertexpoints;
2293   delete xvert;
2294   delete yvert;
2295   for(Int_t i=0; i< kvirtualvertexnumber; i++)
2296         delete virtualvertex[i];
2297   /////////////////////////////////////////////////////////////
2298         return virtualcoolingtubesupport;
2299 }
2300 /////////////////////////////////////////////////////////////////////////////////
2301 TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2302   /////////////////////////////////////////////////////////////
2303   // Method generating List containing SSD Hybrid Components
2304   /////////////////////////////////////////////////////////////
2305   TList* ssdhybridlist = new TList();
2306   const Int_t kssdstiffenernumber = 2;
2307   Double_t ssdstiffenerseparation = fgkSSDSensorLength
2308                                                                   - 2.*fgkSSDModuleStiffenerPosition[1]
2309                                                                   -    fgkSSDStiffenerWidth;
2310   Double_t ssdchipcablesradius[kssdstiffenernumber];
2311   for(Int_t i=0; i<kssdstiffenernumber; i++)
2312           ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2313                                -  fgkSSDChipCablesHeight[0]
2314                                -  fgkSSDChipCablesHeight[1]);
2315   /////////////////////////////////////////////////////////////
2316   // Mother Volumes Containers
2317   /////////////////////////////////////////////////////////////
2318   const Int_t kmothernumber = 2;
2319   const Int_t kmothervertexnumber = 12;
2320   Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2321   Double_t ymothervertex[kmothernumber][kmothervertexnumber];
2322   ///////////////////////
2323   // Setting the vertices
2324   ///////////////////////
2325   xmothervertex[0][0]  = -0.5*fgkSSDStiffenerLength;
2326   xmothervertex[0][1]  = xmothervertex[0][0];
2327   xmothervertex[0][2]  = fgkSSDFlexLength[0]-0.5*fgkSSDStiffenerLength;
2328   xmothervertex[0][3]  = xmothervertex[0][2];
2329   xmothervertex[0][4]  = xmothervertex[0][0];
2330   xmothervertex[0][5]  = xmothervertex[0][4];
2331   xmothervertex[0][6]  = -xmothervertex[0][0];
2332   xmothervertex[0][7]  = xmothervertex[0][6];
2333   xmothervertex[0][8]  = -xmothervertex[0][2];
2334   xmothervertex[0][9]  = xmothervertex[0][8];
2335   xmothervertex[0][10] = xmothervertex[0][7];
2336   xmothervertex[0][11] = xmothervertex[0][10];
2337   for(Int_t i=0; i<kmothervertexnumber; i++) xmothervertex[1][i] = xmothervertex[0][i];
2338   for(Int_t i = 0; i<kmothernumber; i++){
2339       ymothervertex[i][0]  = -(fgkSSDChipWidth-(0.5*fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist)
2340                            + ssdchipcablesradius[i]+fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]);
2341       ymothervertex[i][1]  = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexWidth[0];
2342       ymothervertex[i][2]  = ymothervertex[i][1];
2343       ymothervertex[i][3]  = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth;
2344       ymothervertex[i][4]  = ymothervertex[i][3];
2345       ymothervertex[i][5]  = ymothervertex[i][4]+0.5*fgkSSDStiffenerWidth-ymothervertex[i][0];
2346       ymothervertex[i][6]  = ymothervertex[i][5];
2347       ymothervertex[i][7]  = 0.5*fgkSSDStiffenerWidth+fgkSSDFlexWidth[0];
2348       ymothervertex[i][8]  = ymothervertex[i][7];
2349       ymothervertex[i][9]  = 0.5*fgkSSDStiffenerWidth;
2350       ymothervertex[i][10] = ymothervertex[i][9];
2351       ymothervertex[i][11] = ymothervertex[i][0];
2352   }
2353   TGeoXtru* ssdhybridmothershape[kmothernumber];
2354   TGeoVolume* ssdhybridmother[kmothernumber];
2355   const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2356   for(Int_t i=0; i<kmothernumber; i++){
2357       ssdhybridmothershape[i] = new TGeoXtru(2);
2358       ssdhybridmothershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
2359                                           ymothervertex[i]);
2360       ssdhybridmothershape[i]->DefineSection(0,-0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2361                                                -fgkSSDChipCablesHeight[i+2]);
2362       ssdhybridmothershape[i]->DefineSection(1, 0.5*fgkSSDStiffenerHeight);
2363       ssdhybridmother[i] = new TGeoVolume(ssdhybridmothername[i],ssdhybridmothershape[i],
2364                                           fSSDAir);
2365    }
2366   /////////////////////////////////////////////////////////////
2367   // SSD Stiffener
2368   /////////////////////////////////////////////////////////////
2369   TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2370                                              0.5*fgkSSDStiffenerLength,
2371                                              0.5*fgkSSDStiffenerWidth,
2372                                              0.5*fgkSSDStiffenerHeight);
2373   TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2374                                             fSSDStiffenerMedium);
2375   ssdstiffener->SetLineColor(fColorStiffener);
2376   TGeoTranslation* ssdstiffenertrans[kssdstiffenernumber];
2377   for(Int_t i=0; i<kssdstiffenernumber; i++)
2378       ssdstiffenertrans[i] = new TGeoTranslation(0.,i*ssdstiffenerseparation,0.);
2379   /////////////////////////////////////////////////////////////
2380   // SSD Chip System
2381   /////////////////////////////////////////////////////////////
2382   TList* ssdchipsystemlist = GetSSDChipSystem();
2383   Double_t ssdchipseparation = fgkSSDSensorLength
2384                              - 2.*fgkSSDModuleStiffenerPosition[1]
2385                              - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
2386                              - 0.5*fgkSSDChipWidth);
2387   Double_t ssdchipsystemlength = (fgkSSDChipNumber-1)*(fgkSSDChipLength
2388                                +  fgkSSDChipSeparationLength)+fgkSSDChipCablesLength[1];
2389   TGeoTranslation* ssdchipsystemtrans = new TGeoTranslation(0.5*fgkSSDChipCablesLength[1]
2390                                       - 0.5*ssdchipsystemlength,
2391                                         0.5*(ssdstiffenerseparation-ssdchipseparation),
2392                                       - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight));
2393 ////////////////////////////
2394 // Capacitor 0603-2200 nF
2395 ///////////////////////////
2396   const Int_t knapacitor0603number = 5;
2397   TGeoBBox* capacitor0603shape =  new TGeoBBox("Capacitor0603Shape",
2398                                                                                          0.5*fgkSSDCapacitor0603Length,
2399                                                                                          0.5*fgkSSDCapacitor0603Width,
2400                                                                                          0.5*fgkSSDCapacitor0603Height);
2401   TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
2402                                              fSSDStiffener0603CapacitorMedium);
2403   capacitor0603->SetLineColor(fColorAl);
2404   for(Int_t i=0; i<kmothernumber; i++){
2405       for(Int_t j=0; j<kssdstiffenernumber; j++){
2406             ssdhybridmother[i]->AddNode(ssdstiffener,j+1,ssdstiffenertrans[j]);
2407             for(Int_t k=1; k<knapacitor0603number+1; k++){
2408                   ssdhybridmother[i]->AddNode(capacitor0603,knapacitor0603number*j+k,
2409                         new TGeoTranslation((k-3.)/6*fgkSSDStiffenerLength,
2410                                              j*ssdstiffenerseparation
2411                         +                    0.5*((j==0? 1:-1)*fgkSSDStiffenerWidth
2412                         +                    (j==0? -1:+1)*fgkSSDCapacitor0603Width),
2413                         -                    0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
2414             }
2415       }
2416       ssdhybridmother[i]->AddNode((TGeoVolume*)ssdchipsystemlist->At(i),i+1,ssdchipsystemtrans);
2417       ssdhybridlist->Add(ssdhybridmother[i]);
2418   }
2419 /////////////////////////////////////////////////////////////
2420 // Mother Volume Containing Capacitor Part
2421 /////////////////////////////////////////////////////////////
2422   const Int_t kcapacitormothernumber = 8;
2423   Double_t xcapacitorvertex[kcapacitormothernumber];
2424   Double_t ycapacitorvertex[kcapacitormothernumber];
2425   ///////////////////////
2426   // Setting the vertices
2427   ///////////////////////
2428   xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2429   xcapacitorvertex[1] = xcapacitorvertex[0];
2430   xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2431   xcapacitorvertex[3] = xcapacitorvertex[2];
2432   xcapacitorvertex[4] = xcapacitorvertex[0];
2433   xcapacitorvertex[5] = xcapacitorvertex[0];
2434   xcapacitorvertex[6] = -xcapacitorvertex[0];
2435   xcapacitorvertex[7] = xcapacitorvertex[6];
2436   ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2437   ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2438   ycapacitorvertex[2] = ycapacitorvertex[1];
2439   ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2440   ycapacitorvertex[4] = ycapacitorvertex[3];
2441   ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2442   ycapacitorvertex[6] = ycapacitorvertex[5];
2443   ycapacitorvertex[7] = ycapacitorvertex[0];
2444   TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2445   ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2446                                               ycapacitorvertex);
2447   ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2448   ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
2449   TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2450                                           fSSDAir);
2451 ////////////////////////////
2452 // Connector
2453 ///////////////////////////
2454   const Int_t kssdconnectornumber = 2;
2455   TGeoBBox* ssdconnectorshape[kssdconnectornumber];
2456   Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2457   Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2458                                    +  fgkSSDConnectorAlHeight};
2459   const char* ssdconnectorname[kssdconnectornumber] = {"SSDConnectorAl","SSDConnectorNi"};
2460   TGeoVolume* ssdconnector[kssdconnectornumber];
2461   for(Int_t i=0; i<kssdconnectornumber; i++){
2462       ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2463                                           0.5*fgkSSDConnectorWidth,
2464                                           0.5*((1-i)*fgkSSDConnectorAlHeight
2465                            +              i*fgkSSDConnectorNiHeight),
2466                              i==0? ssdAlconnectororigin : ssdNiconnectororigin);
2467       ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
2468                                        i==0 ? fSSDAlTraceFlexMedium
2469                                             : fSSDStiffenerConnectorMedium);
2470       ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorPhynox);
2471   }
2472   TGeoTranslation* ssdconnectortrans[2*kssdconnectornumber];
2473   ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2474                        +  fgkSSDConnectorPosition[0]
2475                        -  fgkSSDConnectorSeparation
2476                        -  1.5*fgkSSDConnectorLength,
2477                           ssdstiffenerseparation+ssdstiffenershape->GetDY()
2478                        -  fgkSSDConnectorPosition[1]
2479                        -  ssdconnectorshape[0]->GetDY(),0.0);
2480   ssdconnectortrans[1] = new TGeoTranslation(
2481                        -  ssdstiffenershape->GetDX()
2482                        +  fgkSSDConnectorPosition[0]
2483                        -  0.5*fgkSSDConnectorLength,
2484                           ssdstiffenerseparation+ssdstiffenershape->GetDY()
2485                        -  fgkSSDConnectorPosition[1]
2486                        -  ssdconnectorshape[0]->GetDY(),0.0);
2487   ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2488                        -  fgkSSDConnectorPosition[0]
2489                        +  fgkSSDConnectorSeparation
2490                        +  1.5*fgkSSDConnectorLength,
2491                           -(ssdstiffenershape->GetDY()
2492                        -  fgkSSDConnectorPosition[1]
2493                        -  ssdconnectorshape[0]->GetDY()),0.0);
2494   ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2495                        -  fgkSSDConnectorPosition[0]
2496                        +  0.5*fgkSSDConnectorLength,
2497                           -(ssdstiffenershape->GetDY()
2498                        -  fgkSSDConnectorPosition[1]
2499                        -  ssdconnectorshape[0]->GetDY()),0.0);
2500   for(Int_t i=0; i<2*kssdconnectornumber; i++)
2501       for(Int_t j=0; j<kssdconnectornumber; j++)
2502             ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2503 ////////////////////////////
2504 // Capacitor 1812-330 nF
2505 ///////////////////////////
2506   Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
2507   TGeoBBox* capacitor1812shape =  new TGeoBBox("Capacitor1812Shape",
2508                                                                                          0.5*fgkSSDCapacitor1812Length,
2509                                                                                          0.5*fgkSSDCapacitor1812Width,
2510                                                                                          0.5*fgkSSDCapacitor1812Height,
2511             ssdcapacitor1812origin);
2512   TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2513                                              fSSDStiffener1812CapacitorMedium);
2514   capacitor1812->SetLineColor(fColorAl);
2515   TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2516                                         0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2517                                       - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.0);
2518   ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
2519 ////////////////////////////
2520 //Hybrid Wire
2521 ////////////////////////////
2522   Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
2523                                  - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2524                                  - fgkSSDConnectorSeparation;
2525   Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
2526                                  - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
2527   Double_t ssdwireradius = TMath::Sqrt(TMath::Power(wirex,2.)
2528                                          + TMath::Power(wirey,2));
2529   Double_t wireangle = TMath::ATan(wirex/wirey);
2530   TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2531                                                 fgkSSDWireRadius, 0.5*ssdwireradius);
2532   TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2533                                              fSSDStiffenerHybridWireMedium);
2534   hybridwire->SetLineColor(fColorPhynox);
2535   TGeoCombiTrans* hybridwirecombitrans[2];
2536   hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
2537                    0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2538                                  + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
2539                    0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
2540                                  + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
2541                                    ssdstiffenershape->GetDZ()
2542                                  + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight,
2543                    new TGeoRotation("HybridWireRot1",0.,90.,0.));
2544   hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
2545                             0.0,
2546                           - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2547                             0.0,
2548                             new TGeoRotation("HybridWireRot2",
2549                           - wireangle*TMath::RadToDeg(),0.,0.));
2550   TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2551   hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2552   hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
2553   ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2554   ssdhybridlist->Add(ssdhybridcapacitormother);
2555   /////////////////////////////////////////////////////////////
2556   // Deallocating memory
2557   /////////////////////////////////////////////////////////////
2558   delete hybridwirecombitrans[0];
2559   delete hybridwirecombitrans[1];
2560   delete ssdchipsystemlist;
2561   return ssdhybridlist;
2562   /////////////////////////////////////////////////////////////
2563 }
2564 ///////////////////////////////////////////////////////////////////////////////
2565 TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2566   /////////////////////////////////////////////////////////////
2567   // SSD Cooling Block System
2568   /////////////////////////////////////////////////////////////
2569   // SSD Cooling Block and Cooling Tube Transformations
2570   /////////////////////////////////////////////////////////////
2571   TGeoRotation* localcoolingblockrot = new TGeoRotation();
2572   localcoolingblockrot->SetAngles(0.,90.,0.);
2573   TGeoCombiTrans localcoolingblockmatrix(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
2574   TVector3* coolingblocktransvector;
2575   coolingblocktransvector = new TVector3(fgkSSDModuleSensorSupportDistance
2576                                                                 + fgkSSDCoolingBlockLength,
2577                                                                   fgkSSDSensorLength
2578                                                                 - 2.*fgkSSDModuleStiffenerPosition[1]
2579                                                                 - fgkSSDCoolingBlockWidth);
2580   const Int_t kcoolingblocktransnumber = 2;
2581   const Int_t kcoolingblocknumber = 4;
2582   TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
2583   TGeoHMatrix* coolingtubematrix[kcoolingblocknumber];
2584   TGeoRotation* localcoolingtuberot = new TGeoRotation();
2585   localcoolingtuberot->SetAngles(0.0,90.0,0.0);
2586   TGeoTranslation* localcoolingtubetrans = new TGeoTranslation();
2587   localcoolingtubetrans->SetTranslation(0.5*fgkSSDCoolingBlockLength,
2588                                         0.5*fgkSSDCoolingBlockWidth,
2589                                         fgkSSDCoolingBlockHoleCenter);
2590   TGeoCombiTrans localcoolingtubematrix (*localcoolingtubetrans,*localcoolingtuberot);
2591   Double_t coolingtubedistance = fgkCoolingTubeSupportRmax-fgkCoolingTubeSupportRmin;
2592   for(Int_t i=0; i<kcoolingblocktransnumber; i++){
2593     for(Int_t j=0; j<kcoolingblocktransnumber; j++){
2594       TGeoTranslation localcoolingblocktrans(i*coolingblocktransvector->X()+2*coolingtubedistance,
2595                                              j*coolingblocktransvector->Y(),
2596                                              - 0.5*(fgkSSDCoolingBlockHoleCenter
2597                                                     + fgkCoolingTubeRmax));
2598       coolingblockmatrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingblockmatrix);
2599       coolingtubematrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingtubematrix);
2600     }
2601   }
2602   /////////////////////////////////////////////////////////////
2603   // Virtual Volume containing CoolingBlock System
2604   /////////////////////////////////////////////////////////////
2605   TGeoXtru* coolingsystemothershape = new TGeoXtru(2);
2606   const Int_t kmothervertexnumber = 16;
2607   Double_t xmothervertex[kmothervertexnumber];
2608   Double_t ymothervertex[kmothervertexnumber];
2609   ///////////////////////
2610   // Setting the vertices
2611   ///////////////////////fgkCoolingTubeSupportRmax
2612   xmothervertex[0] = 0.0,ymothervertex[0] = 0.0;
2613   xmothervertex[1] = xmothervertex[0], ymothervertex[1] = coolingblocktransvector->Y()
2614                                    + fgkSSDCoolingBlockWidth;
2615   xmothervertex[2] = coolingblocktransvector->X()
2616                                    + fgkSSDCoolingBlockLength
2617                                    + 4*coolingtubedistance;
2618   ymothervertex[2] = ymothervertex[1];
2619   xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
2620   xmothervertex[4] = xmothervertex[3]-2.*coolingtubedistance-fgkSSDCoolingBlockLength;
2621   ymothervertex[4] = ymothervertex[0];
2622   xmothervertex[5] = xmothervertex[4], ymothervertex[5] = fgkSSDCoolingBlockWidth;
2623   xmothervertex[6] = xmothervertex[3]-coolingtubedistance;
2624   ymothervertex[6] = ymothervertex[5];
2625   xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
2626                                    - fgkSSDCoolingBlockWidth;
2627   xmothervertex[8] = xmothervertex[5], ymothervertex[8] = ymothervertex[7];
2628   xmothervertex[9] = xmothervertex[8], ymothervertex[9] = ymothervertex[2]
2629                                    - coolingtubedistance;
2630   xmothervertex[10] = fgkSSDCoolingBlockLength+2.*coolingtubedistance;
2631   ymothervertex[10] = ymothervertex[9];
2632   xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[8];
2633   xmothervertex[12] = coolingtubedistance, ymothervertex[12] = ymothervertex[11];
2634   xmothervertex[13] = xmothervertex[12], ymothervertex[13] = fgkSSDCoolingBlockWidth;
2635   xmothervertex[14] = 2.*coolingtubedistance+fgkSSDCoolingBlockLength;
2636   ymothervertex[14] = ymothervertex[13];
2637   xmothervertex[15] = xmothervertex[14], ymothervertex[15] = ymothervertex[0];
2638   //////////////////////////////////////////////////////////
2639   coolingsystemothershape->DefinePolygon(kmothervertexnumber,
2640                                                                         xmothervertex,ymothervertex);
2641   coolingsystemothershape->DefineSection(0,-0.5*(fgkSSDCoolingBlockHoleCenter
2642                                                                                            + fgkCoolingTubeRmax));
2643   coolingsystemothershape->DefineSection(1, 0.5*(fgkSSDCoolingBlockHoleCenter
2644                                                                                            + fgkCoolingTubeRmax));
2645   TGeoVolume* coolingsystemother = new TGeoVolume("CoolingBlockSystem",
2646                                                           coolingsystemothershape,fSSDAir);
2647   /////////////////////////////////////////////////////////////
2648   // SSD Cooling Tube Part
2649   /////////////////////////////////////////////////////////////
2650   TGeoTube* coolingtubeshape[fgkcoolingtubenumber];
2651   coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2652                                                                                  0.5*fgkSSDCoolingBlockWidth);
2653   coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
2654                                                                          0.5*fgkSSDCoolingBlockWidth);
2655   TGeoVolume* coolingtube[fgkcoolingtubenumber];
2656   coolingtube[0] = new TGeoVolume("OuterCoolingTube",coolingtubeshape[0],
2657                                                                         fSSDCoolingTubePhynox);
2658   coolingtube[1] = new TGeoVolume("InnerCoolingTube",coolingtubeshape[1],
2659                                                                         fSSDCoolingTubeWater);
2660   coolingtube[0]->SetLineColor(fColorPhynox);
2661   coolingtube[1]->SetLineColor(fColorWater);
2662   TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2663   /////////////////////////////////////////////////////////////
2664   // Adding Cooling block to mother volume
2665   /////////////////////////////////////////////////////////////
2666    for(Int_t i=0; i<kcoolingblocknumber; i++){
2667         coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
2668         coolingsystemother->AddNode(coolingtube[0],i+1,coolingtubematrix[i]);
2669         coolingsystemother->AddNode(coolingtube[1],i+1,coolingtubematrix[i]);
2670   }
2671   /////////////////////////////////////////////////////////////
2672   // Deallocating memory
2673   /////////////////////////////////////////////////////////////
2674         delete coolingblocktransvector;
2675         delete localcoolingblockrot;
2676         delete localcoolingtubetrans;
2677         delete localcoolingtuberot;
2678   /////////////////////////////////////////////////////////////
2679   // Checking overlaps
2680   /////////////////////////////////////////////////////////////
2681         //coolingsystemother->CheckOverlaps(0.01);
2682   /////////////////////////////////////////////////////////////
2683         return coolingsystemother;
2684 }
2685 /////////////////////////////////////////////////////////////////////////////////
2686 TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
2687   /////////////////////////////////////////////////////////////
2688   // SSD Flex
2689   /////////////////////////////////////////////////////////////
2690   const Int_t kssdflexlayernumber = 2;
2691   TGeoXtru* ssdflexshape[kssdflexlayernumber];
2692   for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2693   const Int_t kmothervertexnumber = 17;
2694   Double_t xmothervertex[kmothervertexnumber];
2695   Double_t ymothervertex[kmothervertexnumber];
2696   /////////////////////////////////////////////
2697   // Auxiliary variables for vertex positioning
2698   /////////////////////////////////////////////
2699   const Int_t kssdflexboxnumber = 5;
2700   Double_t ssdflexboxlength[kssdflexboxnumber];
2701   ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
2702                                           *     fgkSSDChipLength+(fgkSSDChipNumber-1)
2703                                           *     fgkSSDChipSeparationLength
2704                                           - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2705                                           - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
2706   ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2707   ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
2708                                           -     fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
2709   ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2710   ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2711                                           -     ssdflexboxlength[1];
2712   Double_t ssdflexboxwidth[kssdflexboxnumber];
2713   ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2714   ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2715   ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2716   ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2717   ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
2718   ///////////////////////
2719   // Setting the vertices
2720   ///////////////////////
2721   xmothervertex[0]  = 0.0;
2722   xmothervertex[1]  = xmothervertex[0];
2723   xmothervertex[2]  = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2724   xmothervertex[3]  = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2725                                         + ssdflexboxlength[4];
2726   xmothervertex[4]  = xmothervertex[3];
2727   xmothervertex[5]  = xmothervertex[4]-ssdflexboxlength[4];
2728   xmothervertex[6]  = xmothervertex[5];
2729   xmothervertex[7]  = xmothervertex[6]-fgkSSDFlexHoleLength;
2730   xmothervertex[8]  = xmothervertex[7];
2731   xmothervertex[9]  = xmothervertex[8]-ssdflexboxlength[2];
2732   xmothervertex[10] = xmothervertex[9];
2733   xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2734   xmothervertex[12] = xmothervertex[11];
2735   xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2736   xmothervertex[14] = xmothervertex[13];
2737   xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2738   xmothervertex[16] = xmothervertex[15];
2739   ymothervertex[0]  = 0.0;
2740   ymothervertex[1]  = fgkSSDFlexWidth[1];
2741   ymothervertex[2]  = fgkSSDFlexWidth[0];
2742   ymothervertex[3]  = ymothervertex[2];
2743   ymothervertex[4]  = ymothervertex[0];
2744   ymothervertex[5]  = ymothervertex[4];
2745   ymothervertex[6]  = ssdflexboxwidth[2];
2746   ymothervertex[7]  = ymothervertex[6];
2747   ymothervertex[8]  = ymothervertex[0];
2748   ymothervertex[9]  = ymothervertex[8];
2749   ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2750   ymothervertex[11] = ymothervertex[10];
2751   ymothervertex[12] = ymothervertex[0];
2752   ymothervertex[13] = ymothervertex[12];
2753   ymothervertex[14] = ymothervertex[7];
2754   ymothervertex[15] = ymothervertex[14];
2755   ymothervertex[16] = ymothervertex[0];
2756   /////////////////////////////////////////////////////////////
2757   // First Mother Volume containing SSDFlex
2758   /////////////////////////////////////////////////////////////
2759   TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2760   ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2761                                                                     ymothervertex);
2762   ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2763   ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
2764   TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2765                                                                                          fSSDAir);
2766   /////////////////////////////////////////////////////////////
2767   // SSDFlex Layer Shapes
2768   /////////////////////////////////////////////////////////////
2769   for(Int_t i=0; i<kssdflexlayernumber; i++){
2770         ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2771                                                                    ymothervertex);
2772     ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2773         ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2774   }
2775   /////////////////////////////////////
2776   // Setting Layers into Mother Volume
2777   /////////////////////////////////////
2778   Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2779   TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2780                                                                                                  fSSDKaptonFlexMedium};
2781   const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2782                                                                                                         "AlFlexLay2","KaptonFlexLay2"};
2783   TGeoVolume* ssdflex[2*kssdflexlayernumber];
2784   TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2785   for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2786         ssdflex[i] = new TGeoVolume(ssdflexname[i],
2787                                                                 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2788                                                                 i%2==0 ? ssdflexmed[0]   : ssdflexmed[1]);
2789         ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2790     ssdflextrans[i]  = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2791                                          +                                         fgkSSDFlexHeight[1]));
2792     ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2793   }
2794   //ssdflexmother->CheckOverlaps(0.01);
2795   return ssdflexmother;
2796 }
2797 /////////////////////////////////////////////////////////////////////////////////
2798 TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
2799   /////////////////////////////////////////////////////////////
2800   // Method generating SSD End Flex
2801   /////////////////////////////////////////
2802   Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2803                                                         /  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2804   Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2805                                                 * TMath::DegToRad()*ssdflexradiusmax
2806                                                 - fgkSSDFlexLength[2]-TMath::Pi()
2807                                                 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
2808   const Int_t knedges = 20;
2809   const Int_t karcnumber = 2;
2810   TVector3* vertexposition[karcnumber*(knedges+1)];
2811   Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2812   Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2813   Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2814   Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2815                                                                                  - 90.0*TMath::DegToRad()};
2816   TVector3* referencetrans[karcnumber];
2817   referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2818                                         +                          radius[0]*SinD(2.*fgkSSDFlexAngle),
2819                                                                    radius[0]);
2820   referencetrans[1] = new TVector3(referencetrans[0]->X()
2821                                         +              fgkSSDFlexLength[2],
2822      -              fgkSSDStiffenerHeight);
2823 for(Int_t i=0; i<karcnumber; i++){
2824         for(Int_t j=0; j<knedges+1; j++){
2825                 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2826                                                                                                radius[i]*SinD(angle[i]));
2827                 angle[i] +=  deltangle[i]*(1.0-2.0*i);
2828         }
2829   }
2830   ///////////////////////
2831   // Setting the vertices
2832   ///////////////////////
2833   const Int_t kendflexlayernumber = 4;
2834   const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2835   TVector3** vertex[kendflexlayernumber];
2836   for(Int_t i=0; i<kendflexlayernumber; i++)
2837                                         vertex[i] = new TVector3*[kendflexvertexnumber];
2838   TVector3* transvector[kendflexlayernumber+1];
2839   TVector3* deltatransvector = new TVector3();
2840   for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2841   transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2842                                 +                radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2843   for(Int_t i=1; i<kendflexlayernumber+1; i++){
2844         deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2845                                         *                 CosD(fgkSSDFlexAngle),
2846                                                           (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2847                                         *         SinD(fgkSSDFlexAngle),0.0);
2848         *transvector[i] = *transvector[i-1]+*deltatransvector;
2849   }
2850   Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2851   ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2852   for(Int_t i=0; i<karcnumber; i++){
2853         for(Int_t j=1; j<kendflexlayernumber+1; j++){
2854                 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2855                                                   * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2856                                               /radius[i];
2857         }
2858   }
2859   for(Int_t i=0; i<kendflexlayernumber; i++){
2860         vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
2861         vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
2862         for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2863                 if(j<(knedges+1)){
2864                         vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2865                                                                                   vertexposition[j]->Y()*ratioradius[0][i+1]);
2866                         vertex[i][j+2]->RotateZ(referenceangle[0]);
2867                         *vertex[i][j+2] += *referencetrans[0];
2868                         vertex[i][4*(knedges+1)-j+1] =
2869                                                          new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2870                                                                                   vertexposition[j]->Y()*ratioradius[0][i]);
2871                         vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2872                         *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2873                 }
2874                 else{
2875
2876                         vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2877                                                                                   vertexposition[j]->Y()*ratioradius[1][i+1]);
2878                         vertex[i][j+2]->RotateZ(referenceangle[1]);
2879                         *vertex[i][j+2] += *referencetrans[1];
2880                         vertex[i][4*(knedges+1)-j+1] =
2881                                                          new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2882                                                                                   vertexposition[j]->Y()*ratioradius[1][i]);
2883                         vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2884                         *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2885            }
2886         }
2887   }
2888   /////////////////////////////////////////////////////////////
2889   // First Mother Volume containing SSDEndFlex
2890   /////////////////////////////////////////////////////////////
2891   TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2892   Double_t xmothervertex[kendflexvertexnumber];
2893   Double_t ymothervertex[kendflexvertexnumber];
2894   xmothervertex[0] = vertex[0][0]->X();
2895   ymothervertex[0] = vertex[0][0]->Y();
2896   for(Int_t i=1; i<kendflexvertexnumber; i++){
2897         if(i<2*(knedges+1)+2){
2898                 xmothervertex[i] = vertex[3][i]->X();
2899                 ymothervertex[i] = vertex[3][i]->Y();
2900         }
2901         else{
2902                 xmothervertex[i] = vertex[0][i]->X();
2903                 ymothervertex[i] = vertex[0][i]->Y();
2904         }
2905   }
2906   ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2907                                                                            xmothervertex,ymothervertex);
2908   ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2909   ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2910   TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2911                                                                  ssdendflexmothershape,fSSDAir);
2912   //////////////////////////////////////
2913   // End Flex TGeoXtru Layer Definition
2914   //////////////////////////////////////
2915   TGeoXtru* ssdendflexshape[kendflexlayernumber];
2916   TGeoVolume* ssdendflex[kendflexlayernumber];
2917   for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2918   Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2919   Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2920   Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2921   TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2922                                                                                                         fSSDKaptonFlexMedium};
2923   const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2924                                                                                                          "AlEndFlexLay2","KaptonEndFlexLay2"};
2925   for(Int_t i=0; i<kendflexlayernumber; i++){
2926         for(Int_t j=0; j<4*(knedges+1)+2; j++){
2927                 xvertex[i][j] = vertex[i][j]->X();
2928                 yvertex[i][j] = vertex[i][j]->Y();
2929         }
2930   ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2931   ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2932   ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2933   ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2934                                                                  i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2935   ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2936   ssdendflexmother->AddNode(ssdendflex[i],1);
2937   }
2938   /////////////////////////////////////////////////////////////
2939   // Deallocating memory
2940   /////////////////////////////////////////////////////////////
2941   for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2942   for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2943   for(Int_t i=0; i<kendflexlayernumber; i++){
2944         for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2945         delete [] vertex[i];
2946   }
2947   for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2948   delete deltatransvector;
2949   /////////////////////////////////////////////////////////////
2950   //ssdendflexmother->CheckOverlaps(0.01);
2951   return ssdendflexmother;
2952 }
2953 ///////////////////////////////////////////////////////////////////////////////
2954 TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
2955   /////////////////////////////////////////////////////////////
2956   // Method generating the Mounting Block
2957   /////////////////////////////////////////////////////////////
2958   const Int_t kvertexnumber = 8;
2959   Double_t xvertex[kvertexnumber];
2960   Double_t yvertex[kvertexnumber];
2961   xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2962   xvertex[1] = xvertex[0];
2963   xvertex[2] = -xvertex[0];
2964   xvertex[3] = xvertex[2];
2965   xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2966                          -                                 fgkSSDMountingBlockLength[2]);
2967   xvertex[5] = xvertex[4];
2968   xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2969                          - 0.5*fgkSSDMountingBlockScrewHoleEdge
2970                          -     fgkSSDMountingBlockScrewHoleRadius[0];
2971   xvertex[7] = xvertex[6];
2972   yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
2973                          +      fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0]
2974                          -  fgkSSDModuleVerticalDisalignment;
2975   yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2976   yvertex[2] = yvertex[1];
2977   yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2978   yvertex[4] = yvertex[3];
2979   yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2980                          - fgkSSDMountingBlockHeight[0];
2981   yvertex[6] = yvertex[5];
2982   yvertex[7] = yvertex[0];
2983   ///////////////////////////////////////////////////////////////////////
2984   // TGeoXTru Volume definition for Mounting Block Part
2985   ///////////////////////////////////////////////////////////////////////
2986   TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2987   ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2988   ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2989   ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
2990   TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
2991                                                                           ssdmountingblockshape,
2992                                                                                   fSSDMountingBlockMedium);
2993   ssdmountingblock->SetLineColor(fColorG10);
2994   TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
2995   mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
2996   TGeoRotation* mountingblockrot = new TGeoRotation();
2997   mountingblockrot->SetAngles(90.,180.,-90.);
2998   mountingblockcombitrans->SetRotation(*mountingblockrot);
2999   /////////////////////////////////////////////////////////////
3000   // Generating the Mounting Block Screw Vertices
3001   /////////////////////////////////////////////////////////////
3002   const Int_t kscrewvertexnumber = 15;
3003   Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
3004                                  -                                      fgkSSDMountingBlockScrewHoleEdge)
3005                                  /                              fgkSSDMountingBlockScrewHoleRadius[0])
3006                                  * TMath::RadToDeg();
3007   Double_t phi0 = 90.+alpha;
3008   Double_t phi = 270.-2*alpha;
3009   Double_t deltaphi = phi/kscrewvertexnumber;
3010   TVector3* screwvertex[kscrewvertexnumber+1];
3011   for(Int_t i=0; i<kscrewvertexnumber+1; i++)
3012         screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
3013                                    *CosD(phi0+i*deltaphi),
3014                                    fgkSSDMountingBlockScrewHoleRadius[0]
3015                                    *SinD(phi0+i*deltaphi));
3016   Double_t xscrewvertex[kscrewvertexnumber+6];
3017   Double_t yscrewvertex[kscrewvertexnumber+6];
3018   xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
3019   yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
3020                                   -               fgkSSDMountingBlockScrewHoleEdge);
3021   xscrewvertex[1] = xscrewvertex[0];
3022   yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3023   xscrewvertex[2] = screwvertex[0]->X();
3024   yscrewvertex[2] = yscrewvertex[1];
3025   for(Int_t i=0; i<kscrewvertexnumber+1; i++){
3026         xscrewvertex[i+3] = screwvertex[i]->X();
3027         yscrewvertex[i+3] = screwvertex[i]->Y();
3028   }
3029   xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3030   yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
3031   xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
3032   yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
3033   TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
3034   ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
3035   ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
3036   ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
3037                                                         +                                  fgkSSDMountingBlockHeight[2]);
3038   TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
3039                                                                                 ssdmountingblockscrewshape,
3040                                                                                             fSSDMountingBlockMedium);
3041   ssdmountingblockscrew->SetLineColor(fColorG10);
3042   TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
3043   for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
3044   ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3045                                                                         -                                yscrewvertex[1],
3046                                                                                                          0.5*fgkSSDMountingBlockHeight[0]
3047                                                                         -                                fgkSSDMountingBlockHeight[2]
3048                                                                         +                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3049                                                                         +                                fgkSSDMountingBlockHeight[2]
3050                                                                         -                                yvertex[0]));
3051   ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3052                                                                                                         -0.5*fgkSSDMountingBlockScrewHoleEdge,
3053                                                                                                                  yscrewvertex[1]
3054                                                                                                         -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3055                                                                                                          +fgkSSDMountingBlockHeight[2]
3056                                                                                                          -yvertex[0]));
3057   ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3058                                                                                                           yscrewvertex[1],
3059                                                                         -                                 0.5*fgkSSDMountingBlockHeight[0]
3060                                                                         +                                 fgkSSDMountingBlockHeight[2]
3061                                                                         -                                 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3062                                                                         +                                 fgkSSDMountingBlockHeight[2]
3063                                                                         -                                 yvertex[0]));
3064   ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3065                                                                                                          yscrewvertex[1],
3066                                                                         -                                yscrewvertex[1]
3067                                                                         +                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3068                                                                         +                                fgkSSDMountingBlockHeight[2]
3069                                                                         -                                yvertex[0]));
3070   TGeoRotation* ssdmountingblockscrewrot[4];
3071   for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
3072         ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
3073     ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
3074     ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
3075   for(Int_t i=1; i<4; i++)
3076         ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
3077   TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
3078   ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
3079   TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
3080   ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
3081                                                          +                                xvertex[0],yscrewvertex[1]
3082                                                          -                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3083                                                          +                                fgkSSDMountingBlockHeight[2]
3084                                                          -                                yvertex[0]),0.);
3085   TGeoHMatrix* ssdmountingblockscrewmatrix[4];
3086   for(Int_t i=0; i<4; i++){
3087         ssdmountingblockscrewmatrix[i] =
3088                 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
3089         ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
3090   }
3091   ///////////////////////////////////////////////////////////////////////
3092   // TGeoXtru for Mother Volume
3093   ///////////////////////////////////////////////////////////////////////
3094   const Int_t kvertexmothernumber = 12;
3095   Double_t xmothervertex[kvertexmothernumber];
3096   Double_t ymothervertex[kvertexmothernumber];
3097   for(Int_t i=0; i<6; i++){
3098         xmothervertex[i] = xvertex[i];
3099         ymothervertex[i] = yvertex[i];
3100   }
3101   xmothervertex[6]  = xvertex[5]+fgkSSDMountingBlockLength[2];
3102   ymothervertex[6]  = ymothervertex[5];
3103   xmothervertex[7]  = xmothervertex[6];
3104   ymothervertex[7]  = ymothervertex[4];
3105   xmothervertex[8]  = xmothervertex[7]
3106                                         + 0.5*(fgkSSDMountingBlockLength[1]
3107                                         -          fgkSSDMountingBlockLength[2]);
3108   ymothervertex[8]  = ymothervertex[4];
3109   xmothervertex[9]  = xmothervertex[8];
3110   ymothervertex[9]  = ymothervertex[2];
3111   xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
3112   ymothervertex[10] = ymothervertex[1];
3113   xmothervertex[11] = xmothervertex[10];
3114   ymothervertex[11] = ymothervertex[0];
3115   TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3116   ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3117   ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3118   ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3119   TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3120                                                                           ssdmountingblockmothershape,
3121                                                                                   fSSDAir);
3122   /////////////////////////////////////////////////////////////
3123   // Placing the Volumes into Mother Volume
3124   /////////////////////////////////////////////////////////////
3125   ssdmountingblockmother->AddNode(ssdmountingblock,1);
3126   ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3127   for(Int_t i=0; i<4; i++)
3128         ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3129                                                                         ssdmountingblockscrewmatrix[i]);
3130   /////////////////////////////////////////////////////////////
3131   // Deallocating memory
3132   /////////////////////////////////////////////////////////////
3133   delete mountingblockrot;
3134   for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3135   delete ssdmountingblockglobalrot;
3136   delete ssdmountingblockglobaltrans;
3137   /////////////////////////////////////////////////////////////
3138   return ssdmountingblockmother;
3139 }
3140 ///////////////////////////////////////////////////////////////////////////////
3141  TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3142   /////////////////////////////////////////////////////////////
3143   // Method generating the Mounting Block Clip
3144   /////////////////////////////////////////////////////////////
3145   const Int_t kmothervertexnumber = 10;
3146   Double_t xmothervertex[kmothervertexnumber];
3147   Double_t ymothervertex[kmothervertexnumber];
3148   xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3149                                    - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3150   xmothervertex[1] = xmothervertex[0];
3151   xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3152                                    - fgkMountingBlockClibScrewRadius);
3153   xmothervertex[3] = xmothervertex[2];
3154   xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3155   xmothervertex[5] = xmothervertex[4];
3156   xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3157   xmothervertex[7] = xmothervertex[6];
3158   xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3159   xmothervertex[9] = xmothervertex[8];
3160   ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
3161                                + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0]
3162                                    - fgkSSDModuleVerticalDisalignment;
3163   ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3164   ymothervertex[2] = ymothervertex[1];
3165   ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3166                                    - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3167                                    - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3168   ymothervertex[4] = ymothervertex[3];
3169   ymothervertex[5] = ymothervertex[2];
3170   ymothervertex[6] = ymothervertex[5];
3171   ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3172   ymothervertex[8] = ymothervertex[7];
3173   ymothervertex[9] = ymothervertex[0];
3174   ///////////////////////////////////////////////////////////////////////
3175   // TGeoXTru Volume definition for Mounting Block Clip Part
3176   ///////////////////////////////////////////////////////////////////////
3177   TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3178   ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3179   ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3180   ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3181   TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3182                                                                           ssdmountingblockclipshape,fSSDAir);
3183   ssdmountingblockclip->SetLineColor(4);
3184   ///////////////////////////////////////////////////////////////////////
3185   // TGeoXTru Volume definition for Clip
3186   ///////////////////////////////////////////////////////////////////////
3187   const Int_t kclipvertexnumber = 6;
3188   Double_t xclipvertex[kclipvertexnumber];
3189   Double_t yclipvertex[kclipvertexnumber];
3190   xclipvertex[0] = xmothervertex[0];
3191   xclipvertex[1] = xclipvertex[0];
3192   xclipvertex[2] = xmothervertex[6];
3193   xclipvertex[3] = xclipvertex[2];
3194   xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3195   xclipvertex[5] = xclipvertex[4];
3196   yclipvertex[0] = ymothervertex[0];
3197   yclipvertex[1] = ymothervertex[1];
3198   yclipvertex[2] = yclipvertex[1];
3199   yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3200   yclipvertex[4] = yclipvertex[3];
3201   yclipvertex[5] = yclipvertex[0];
3202   TGeoXtru* clipshape = new TGeoXtru(2);
3203   clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3204   clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3205   clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3206                                                          +   fgkMountingBlockClibWidth);
3207   TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3208   clip->SetLineColor(18);
3209   ///////////////////////////////////////////////////////////////////////
3210   // Ladder Support Piece
3211   ///////////////////////////////////////////////////////////////////////
3212   const Int_t ksupportvertexnumber = 4;
3213   Double_t xsupportvertex[ksupportvertexnumber];
3214   Double_t ysupportvertex[ksupportvertexnumber];
3215   xsupportvertex[0] = xclipvertex[5];
3216   xsupportvertex[1] = xsupportvertex[0];
3217   xsupportvertex[2] = xmothervertex[9];
3218   xsupportvertex[3] = xsupportvertex[2];
3219   ysupportvertex[0] = yclipvertex[0];
3220   ysupportvertex[1] = yclipvertex[3];
3221   ysupportvertex[2] = ysupportvertex[1];
3222   ysupportvertex[3] = ysupportvertex[0];
3223   TGeoXtru* supportshape = new TGeoXtru(2);
3224   supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3225   supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3226   supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3227   TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3228   support->SetLineColor(9);
3229   ///////////////////////////////////////////////////////////////////////
3230   // TGeoXTru Volume definition for Screw
3231   ///////////////////////////////////////////////////////////////////////
3232   Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3233                                                 0.5*fgkMountingBlockClibScrewRadius};
3234   Int_t edgesnumber[2] = {50,6};
3235   Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3236                                                  +0.5*(ymothervertex[3]-ymothervertex[2])};
3237   TGeoXtru* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
3238   TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3239   clipscrew->SetLineColor(12);
3240   TGeoRotation* screwrot = new TGeoRotation();
3241   screwrot->SetAngles(0.,90.,0.);
3242   TGeoTranslation* screwtrans = new TGeoTranslation();
3243   screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3244                                                          0.5*(ymothervertex[3]+ymothervertex[2]),
3245                                                          0.5*fgkSSDMountingBlockWidth+
3246                                                         -0.5*fgkMountingBlockSupportWidth[0]);
3247   TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3248   ///////////////////////////////////////////////////////////////////////
3249   // Placing the Volumes
3250   ///////////////////////////////////////////////////////////////////////
3251   ssdmountingblockclip->AddNode(clip,1);
3252   ssdmountingblockclip->AddNode(support,1);
3253   ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3254   /////////////////////////////////////////////////////////////
3255   // Deallocating memory
3256   /////////////////////////////////////////////////////////////
3257   delete screwtrans;
3258   delete screwrot;
3259   /////////////////////////////////////////////////////////////
3260   return ssdmountingblockclip;
3261 }
3262 ///////////////////////////////////////////////////////////////////////////////
3263 TList* AliITSv11GeometrySSD::GetCoolingTubeList()const{
3264   /////////////////////////////////////////////////////////////
3265   // Method generating the Cooling Tube
3266   /////////////////////////////////////////////////////////////
3267    TGeoTube** coolingtubeshape[fgkcoolingtubenumber];
3268    for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtubeshape[i] =
3269                                                                                                 new     TGeoTube*[2];
3270    // Ladder Cooling Tubes
3271    coolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3272                                           0.25 * (fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3273                                                   -     2.*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth));
3274    coolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3275                                                                                  coolingtubeshape[0][0]->GetDz());
3276    coolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3277                                                                                  0.5*(fgkSSDModuleStiffenerPosition[1]
3278                                                   -                                       fgkSSDSensorOverlap));
3279    coolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3280                                                                                  coolingtubeshape[1][0]->GetDz());
3281    coolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3282                                                                                  0.5*fgkSSDModuleStiffenerPosition[1]);
3283    coolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3284                                                                                  coolingtubeshape[2][0]->GetDz());
3285    // End Ladder Cooling Tubes
3286    TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3287    for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3288         endladdercoolingtubeshape[i] = new      TGeoTube*[2];
3289    endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3290                                                         0.50 * (fgkEndLadderMountingBlockPosition[0]
3291                                                   -                     fgkendladdercoolingsupportdistance[0]));
3292    endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3293                                                                         endladdercoolingtubeshape[0][0]->GetDz());
3294    endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3295                                                         0.50 * (fgkendladdercoolingsupportdistance[0]
3296                                                   +                     fgkendladdercoolingsupportdistance[1]
3297                                                   -                     fgkCoolingTubeSupportWidth));
3298    endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3299                                                                         endladdercoolingtubeshape[1][0]->GetDz());
3300    endladdercoolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3301                                                         0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
3302                                                   -                     fgkEndLadderMountingBlockPosition[0]
3303                                                   -                     fgkendladdercoolingsupportdistance[1]
3304                                                   -                     fgkCoolingTubeSupportWidth));
3305    endladdercoolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3306                                                                         endladdercoolingtubeshape[2][0]->GetDz());
3307    endladdercoolingtubeshape[3][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3308                                                           0.50 * (fgkMountingBlockToSensorSupport
3309                                                         - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
3310                                                         -                 fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
3311                                                         +                 fgkSSDSensorOverlap
3312                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
3313                                                         -                 fgkendladdercoolingsupportdistance[2]
3314                                                         -                 fgkEndLadderMountingBlockPosition[1]
3315                                                         -                 fgkCoolingTubeSupportWidth));
3316    endladdercoolingtubeshape[3][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3317                                                                         endladdercoolingtubeshape[3][0]->GetDz());
3318    endladdercoolingtubeshape[4][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3319                                                           0.50 * fgkendladdercoolingsupportdistance[2]);
3320    endladdercoolingtubeshape[4][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3321                                                                         endladdercoolingtubeshape[4][0]->GetDz());
3322    // Ladder Cooling Tubes
3323    TGeoVolume** coolingtube[fgkcoolingtubenumber];
3324    for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtube[i] =
3325                                                                                          new TGeoVolume*[2];
3326    coolingtube[0][0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0][0],
3327                                                                           fSSDCoolingTubePhynox);
3328    coolingtube[0][1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[0][1],
3329                                                                           fSSDCoolingTubeWater);
3330    coolingtube[1][0] = new TGeoVolume("OuterCoolingTube2",coolingtubeshape[1][0],
3331                                                                           fSSDCoolingTubePhynox);
3332    coolingtube[1][1] = new TGeoVolume("InnerCoolingTube2",coolingtubeshape[1][1],
3333                                                                           fSSDCoolingTubeWater);
3334    coolingtube[2][0] = new TGeoVolume("OuterCoolingTube3",coolingtubeshape[2][0],
3335                                                                           fSSDCoolingTubePhynox);
3336    coolingtube[2][1] = new TGeoVolume("InnerCoolingTube3",coolingtubeshape[2][1],
3337                                                                           fSSDCoolingTubeWater);
3338    for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3339         coolingtube[i][0]->SetLineColor(fColorPhynox);
3340         coolingtube[i][1]->SetLineColor(fColorWater);
3341    }
3342    // End Ladder Cooling Tubes
3343    TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3344    for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3345    endladdercoolingtube[i] = new TGeoVolume*[2];
3346    endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3347                                                                 endladdercoolingtubeshape[0][0],
3348                                                                 fSSDCoolingTubePhynox);
3349    endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3350                                                                 endladdercoolingtubeshape[0][1],
3351                                                                 fSSDCoolingTubeWater);
3352    endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3353                                                                 endladdercoolingtubeshape[1][0],
3354                                                                 fSSDCoolingTubePhynox);
3355    endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3356                                                                 endladdercoolingtubeshape[1][1],
3357                                                                 fSSDCoolingTubeWater);
3358    endladdercoolingtube[2][0] = new TGeoVolume("OuterEndLadderCoolingTube3",
3359                                                                 endladdercoolingtubeshape[2][0],
3360                                                                 fSSDCoolingTubePhynox);
3361    endladdercoolingtube[2][1] = new TGeoVolume("InnerEndlLadderCoolingTube3",
3362                                                                 endladdercoolingtubeshape[2][1],
3363                                                                 fSSDCoolingTubeWater);
3364    endladdercoolingtube[3][0] = new TGeoVolume("OuterEndLadderCoolingTube4",
3365                                                                 endladdercoolingtubeshape[3][0],
3366                                                                 fSSDCoolingTubePhynox);
3367    endladdercoolingtube[3][1] = new TGeoVolume("InnerEndlLadderCoolingTube4",
3368                                                                 endladdercoolingtubeshape[3][1],
3369                                                                 fSSDCoolingTubeWater);
3370    endladdercoolingtube[4][0] = new TGeoVolume("OuterEndLadderCoolingTube5",
3371                                                                 endladdercoolingtubeshape[4][0],
3372                                                                 fSSDCoolingTubePhynox);
3373    endladdercoolingtube[4][1] = new TGeoVolume("InnerEndlLadderCoolingTube5",
3374                                                                 endladdercoolingtubeshape[4][1],
3375                                                                 fSSDCoolingTubeWater);
3376    for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3377         endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3378         endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3379    }
3380   /////////////////////////////////////////////////////////////
3381   // Virtual Volume containing Cooling Tubes
3382   /////////////////////////////////////////////////////////////
3383   // Ladder Cooling Tubes
3384   TGeoTube* virtualcoolingtubeshape[fgkcoolingtubenumber];
3385   for(Int_t i=0; i<fgkcoolingtubenumber; i++)
3386   virtualcoolingtubeshape[i] = new TGeoTube(coolingtubeshape[i][1]->GetRmin(),
3387                                                                                         coolingtubeshape[i][0]->GetRmax(),
3388                                                                                         coolingtubeshape[i][0]->GetDz());
3389   TGeoVolume* virtualcoolingtube[fgkcoolingtubenumber];
3390   virtualcoolingtube[0] = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape[0],
3391                                                                           fSSDAir);
3392   virtualcoolingtube[1] = new TGeoVolume("CoolingTube2",virtualcoolingtubeshape[1],
3393                                                                           fSSDAir);
3394   virtualcoolingtube[2] = new TGeoVolume("CoolingTube3",virtualcoolingtubeshape[2],
3395                                                                           fSSDAir);
3396   // End Ladder Cooling Tubes
3397   TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3398   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3399   endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3400                                                                                         endladdercoolingtubeshape[i][0]->GetRmax(),
3401                                                                                         endladdercoolingtubeshape[i][0]->GetDz());
3402   TGeoVolume* endladdervirtualcoolingtube[fgkendladdercoolingtubenumber];
3403   endladdervirtualcoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3404                                                                           endladdervirtualcoolingtubeshape[0],
3405                                                                           fSSDAir);
3406   endladdervirtualcoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3407                                                                           endladdervirtualcoolingtubeshape[1],
3408                                                                           fSSDAir);
3409   endladdervirtualcoolingtube[2] = new TGeoVolume("EndLadderCoolingTube3",
3410                                                                           endladdervirtualcoolingtubeshape[2],
3411                                                                           fSSDAir);
3412   endladdervirtualcoolingtube[3] = new TGeoVolume("EndLadderCoolingTube4",
3413                                                                           endladdervirtualcoolingtubeshape[3],
3414                                                                           fSSDAir);
3415   endladdervirtualcoolingtube[4] = new TGeoVolume("EndLadderCoolingTube5",
3416                                                                           endladdervirtualcoolingtubeshape[4],
3417                                                                           fSSDAir);
3418   TList* coolingtubelist = new TList();
3419   for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3420         virtualcoolingtube[i]->AddNode(coolingtube[i][0],1);
3421         virtualcoolingtube[i]->AddNode(coolingtube[i][1],1);
3422     coolingtubelist->Add(virtualcoolingtube[i]);
3423   }
3424         endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3425         endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3426     coolingtubelist->Add(endladdervirtualcoolingtube[0]);
3427         endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3428         endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
3429     coolingtubelist->Add(endladdervirtualcoolingtube[1]);
3430         endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][0],1);
3431         endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][1],1);
3432     coolingtubelist->Add(endladdervirtualcoolingtube[2]);
3433         endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][0],1);
3434         endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][1],1);
3435     coolingtubelist->Add(endladdervirtualcoolingtube[3]);
3436         endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][0],1);
3437         endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][1],1);
3438     coolingtubelist->Add(endladdervirtualcoolingtube[4]);
3439   return coolingtubelist;
3440 }
3441 ///////////////////////////////////////////////////////////////////////////////
3442 TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
3443   /////////////////////////////////////////////////////////////
3444   // Method generating SSD Cooling Block
3445   /////////////////////////////////////////////////////////////
3446   const Int_t kvertexnumber = 8;
3447   ///////////////////////////////////////
3448   // Vertex Positioning for TGeoXTru
3449   ///////////////////////////////////////
3450   TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3451   vertexposition[0] = new TVector3(0.0,0.0);
3452   vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]);
3453   vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3454                                           vertexposition[1]->Y());
3455   vertexposition[3] = new TVector3(vertexposition[2]->X(),
3456                                           vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]);
3457   vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y());
3458   vertexposition[5] = new TVector3(vertexposition[4]->X(),
3459                                         + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]);
3460   vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3461                                           vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3462                                         - fgkSSDCoolingBlockHoleLength[0]
3463                                         - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3464                                           fgkSSDCoolingBlockHeight[0]
3465                                         - fgkSSDCoolingBlockHoleRadius[1],
3466                                           fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]);
3467   vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3468                                         - fgkSSDCoolingBlockHoleLength[0]),
3469                                           vertexposition[6]->Y());
3470   Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3471                            / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3472   Double_t phi = 180.-alpha;
3473   Double_t psi = 180.+2.*alpha;
3474   Double_t deltapsi = psi/nedges;
3475   Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3476   TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3477                                                   fgkSSDCoolingBlockHoleCenter);
3478   for(Int_t i=0; i<nedges+1; i++){
3479         vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3480                                                                                                radius*SinD(phi+i*deltapsi));
3481    *vertexposition[kvertexnumber+i] += (*transvector);
3482   }
3483   Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3484   for(Int_t i=0; i<kvertexnumber; i++)
3485     vertexposition[kvertexnumber+nedges+1+i] =
3486                                                 GetReflection(vertexposition[kvertexnumber-1-i],param);
3487   ///////////////////////////////////////////////////////////////////////
3488   // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3489   ///////////////////////////////////////////////////////////////////////
3490   TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3491   Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3492   Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3493   for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3494         xvertexpoints[i] = vertexposition[i]->X();
3495         yvertexpoints[i] = vertexposition[i]->Y();
3496   }
3497   ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3498                                                                                         yvertexpoints);
3499   ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3500   ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3501   TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3502                                                                           ssdcoolingblockshape,
3503                                                                                   fSSDAlCoolBlockMedium);
3504   ssdcoolingblock->SetLineColor(fColorAl);
3505   /////////////////////////////////////////////////////////////
3506   // Deallocating memory
3507   /////////////////////////////////////////////////////////////
3508   delete [] vertexposition;
3509   delete xvertexpoints;
3510   delete yvertexpoints;
3511   /////////////////////////////////////////////////////////////
3512   return ssdcoolingblock;
3513 }
3514 /////////////////////////////////////////////////////////////////////////////////
3515 TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, Int_t nedges){
3516   ///////////////////////////////////////////////////////
3517   const Int_t kssdchipcablesnumber    = 2;
3518   const Int_t kssdchipcableslaynumber = 2;
3519   const Int_t kvertexnumber                       = 4*(nedges+1)+4;
3520   Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3521   Double_t ssdchipcablesradius[kssdchipcableslaynumber];
3522   ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeigth
3523                                                  -  fgkSSDChipCablesHeight[0]
3524                                                  -  fgkSSDChipCablesHeight[1]);
3525   ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3526   Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3527   ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3528                                                           - 2.*TMath::Pi()*ssdchipcablesradius[0]
3529                                                           - ssdchipcablesradius[0]
3530                                                           - fgkSSDChipCablesWidth[1]
3531                                                           - fgkSSDChipCablesWidth[2]);
3532   ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3533                                                           - 0.5*(fgkSSDModuleStiffenerPosition[1]
3534                                                           +      fgkSSDChipCablesHeight[1]
3535                                                           +      fgkSSDSensorHeight);
3536   ///////////////////////////////////////////////////////
3537   // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3538   ///////////////////////////////////////////////////////
3539   TVector3** vertexposition[kssdchipcableslaynumber];
3540   for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3541                                                                                                   new TVector3*[4*(nedges+1)+4];
3542   Double_t ratio[4];
3543   ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3544   ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3545                    /  ssdchipcablesradius[0];
3546   ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3547                    /  ssdchipcablesradius[0];
3548   ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3549                    +  fgkSSDChipCablesHeight[1])
3550                    /  ssdchipcablesradius[0];
3551   Double_t phi = 180.;
3552   Double_t deltaphi = 180./nedges;
3553   Double_t angle = 0.0;
3554   Double_t **xvertexpoints = new Double_t*[kssdchipcableslaynumber];
3555   Double_t **yvertexpoints = new Double_t*[kssdchipcableslaynumber];
3556   for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3557         xvertexpoints[i] = new Double_t[kvertexnumber];
3558         yvertexpoints[i] = new Double_t[kvertexnumber];
3559   }
3560   TVector3* vertex = new TVector3();
3561   TVector3* transvector[kssdchipcableslaynumber];
3562   transvector[0] = new TVector3(fgkSSDChipWidth,
3563                                                                 SSDChipCablesHeigth-ssdchipcablesradius[0]);
3564   transvector[1] = new TVector3();
3565   TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcableslaynumber];
3566   TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcableslaynumber];
3567   const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcableslaynumber] =
3568                 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3569                  "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3570   for(Int_t k=0; k<kssdchipcablesnumber; k++){
3571         transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3572         transvector[1]->SetY(ssdchipcablesradius[0]
3573                                  +               fgkSSDChipCablesHeight[0]
3574                                  +               fgkSSDChipCablesHeight[1]);
3575         for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3576                 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeigth
3577                                                          - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
3578                 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeigth
3579                                                          - i*fgkSSDChipCablesHeight[0]);
3580                 vertexposition[i][2*(nedges+1)+2] =
3581                                         new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3582                                 +                                fgkSSDChipCablesWidth[1]
3583                                 +                                fgkSSDChipCablesWidth[2],
3584                                                                 ((1.-i)*fgkSSDChipCablesHeight[i]
3585                                 +                                fgkSSDChipCablesHeight[1]));
3586         vertexposition[i][2*(nedges+1)+3] =
3587                                         new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3588                                                                  vertexposition[i][2*(nedges+1)+2]->Y()
3589                                 -                                fgkSSDChipCablesHeight[i]);
3590             for(Int_t j=0; j<nedges+1; j++){
3591                     angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3592                         vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3593                         vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3594                         vertexposition[0][(nedges+1)*i+j+2] =
3595                                                 new TVector3(*vertex+*transvector[i]);
3596                         vertexposition[1][(nedges+1)*i+j+2] =
3597                                                 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3598                                                                          vertex->Y()*ratio[2*i]+transvector[i]->Y());
3599                         vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3600                                                 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3601                         vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3602                                                 new TVector3(vertex->X()*ratio[2*i+1]
3603                                                         +                        transvector[i]->X(),
3604                                                                                  vertex->Y()*ratio[2*i+1]
3605                                                         +                transvector[i]->Y());
3606                 }
3607         }
3608         for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3609                 for(Int_t j=0; j<kvertexnumber; j++){
3610                         xvertexpoints[i][j] = vertexposition[i][j]->X();
3611                         yvertexpoints[i][j] = vertexposition[i][j]->Y();
3612                 }
3613                 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3614                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3615                                                                                 xvertexpoints[i],yvertexpoints[i]);
3616                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3617                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3618                 ssdchipcable[kssdchipcablesnumber*k+i] =
3619                                 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3620                                                            ssdchipcableshape[kssdchipcablesnumber*k+i],
3621                                                           (kssdchipcablesnumber*k+i)%2==0?
3622                                                            fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3623                 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3624         }
3625         for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3626                 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3627   }
3628   /////////////////////////////////////////////////////////////
3629   // Mother Volume definition
3630   /////////////////////////////////////////////////////////////
3631   Double_t ssdchipseparation = fgkSSDSensorLength
3632                                                          - 2.*fgkSSDModuleStiffenerPosition[1]
3633                                                          - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3634                                                          - 0.5*fgkSSDChipWidth)-fgkSSDChipWidth;
3635   Double_t boxorigin[3] = {-0.5*ssdchipseparation,0.,0.5*SSDChipCablesHeigth};
3636   Double_t dx = ssdchipseparation+2.*(fgkSSDChipWidth+ssdchipcablesradius[0]
3637                                                           +fgkSSDChipCablesWidth[1]
3638                                                           +fgkSSDChipCablesWidth[2]);
3639   Double_t dy = fgkSSDChipCablesLength[1];
3640   Double_t dz = SSDChipCablesHeigth;
3641   TGeoBBox* ssdchipcablesmotherbox = new TGeoBBox(0.5*dx,0.5*dy,0.5*dz,boxorigin);
3642   TGeoVolume* ssdchipcablesmother = new TGeoVolume("SSDChipCablesMother",
3643                           ssdchipcablesmotherbox,fSSDAir);
3644   /////////////////////////////////////////////////////////////
3645   // Rotation and Translation Definition for positioning
3646   /////////////////////////////////////////////////////////////
3647   TGeoRotation* ssdchipcablesrot[5];
3648   ssdchipcablesrot[0] = new TGeoRotation("",90.,180.,-90);
3649   ssdchipcablesrot[1] = new TGeoRotation("",0.0,90.0,0.0);
3650   ssdchipcablesrot[2] = new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0]));
3651   ssdchipcablesrot[3] = new TGeoRotation("",180.,0.0,0.0);
3652   ssdchipcablesrot[4] = new TGeoRotation((*ssdchipcablesrot[3])*(*ssdchipcablesrot[2]));
3653   TGeoCombiTrans* ssdchipcablescombitrans = new TGeoCombiTrans(-ssdchipseparation,
3654                                                                                                                 0.,0.,ssdchipcablesrot[2]);
3655   ssdchipcablesmother->AddNode(ssdchipcable[0],1,ssdchipcablesrot[4]);
3656   ssdchipcablesmother->AddNode(ssdchipcable[1],1,ssdchipcablesrot[4]);
3657   ssdchipcablesmother->AddNode(ssdchipcable[2],1,ssdchipcablescombitrans);
3658   ssdchipcablesmother->AddNode(ssdchipcable[3],1,ssdchipcablescombitrans);
3659   /////////////////////////////////////////////////////////////
3660   // Deallocating memory
3661   /////////////////////////////////////////////////////////////
3662   for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3663         delete [] xvertexpoints[i];
3664         delete [] yvertexpoints[i];
3665   }
3666   for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3667   for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3668   delete vertex;
3669   delete ssdchipcablesrot[0];
3670   delete ssdchipcablesrot[1];
3671   delete ssdchipcablesrot[3];
3672   /////////////////////////////////////////////////////////////
3673   return ssdchipcablesmother;
3674 }
3675 ///////////////////////////////////////////////////////////////////////////////
3676 TList* AliITSv11GeometrySSD::GetSSDChipSystem(){
3677   /////////////////////////////////////////////////////////////
3678   // SSD Chip Assembly
3679   /////////////////////////////////////////////////////////////
3680   TGeoVolume* ssdchipassembly = GetSSDChips();
3681   TList* ssdchipsystemlist = new TList();
3682 //  const Int_t knedges = 20;
3683   const Int_t knedges = 5;
3684   const Int_t kchipsystemnumber = 2;
3685   /////////////////////////////////////////////////////////////
3686   // Mother Volume containing SSDChipSystem
3687   /////////////////////////////////////////////////////////////
3688   TGeoXtru* chipsystemothershape[kchipsystemnumber];
3689   for(Int_t i=0; i<kchipsystemnumber; i++) chipsystemothershape[i] = new TGeoXtru(2);
3690   const Int_t kmothervertexnumber = 12;
3691   Double_t xmothervertex[kchipsystemnumber][kmothervertexnumber];
3692   Double_t ymothervertex[kchipsystemnumber][kmothervertexnumber];
3693   Double_t ssdchipcablesradius[kchipsystemnumber];
3694   Double_t ssdchipseparation = fgkSSDSensorLength
3695                              - 2.*fgkSSDModuleStiffenerPosition[1]
3696                              - 2.*(fgkSSDStiffenerWidth
3697                              - fgkSSDStiffenerToChipDist-0.5*fgkSSDChipWidth);
3698   for(Int_t i=0; i<kchipsystemnumber; i++)
3699         ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
3700                                                    -  fgkSSDChipCablesHeight[0]
3701                                                    -  fgkSSDChipCablesHeight[1]);
3702   ///////////////////////
3703   // Setting the vertices
3704   ///////////////////////
3705   xmothervertex[0][0]  = -0.5*fgkSSDChipCablesLength[1];
3706   xmothervertex[0][1]  = xmothervertex[0][0];
3707   xmothervertex[0][2]  = (fgkSSDChipNumber-1)*(fgkSSDChipLength
3708                                            + fgkSSDChipSeparationLength)+0.5*fgkSSDChipCablesLength[1];
3709   xmothervertex[0][3]  = xmothervertex[0][2];
3710   xmothervertex[0][4]  = 0.5*fgkSSDChipCablesLength[1];
3711   xmothervertex[0][5]  = xmothervertex[0][4];
3712   xmothervertex[0][6]  = xmothervertex[0][2]-0.5*fgkSSDChipCablesLength[1];
3713   xmothervertex[0][7]  = xmothervertex[0][6];
3714   xmothervertex[0][8]  = 0.0;
3715   xmothervertex[0][9]  = xmothervertex[0][8];
3716   xmothervertex[0][10] = xmothervertex[0][4];
3717   xmothervertex[0][11] = xmothervertex[0][10];
3718   for(Int_t i=0; i<kmothervertexnumber; i++)
3719         xmothervertex[1][i] = xmothervertex[0][i];
3720   for(Int_t i=0; i<kchipsystemnumber; i++){
3721         ymothervertex[i][0]  = -0.5*fgkSSDChipWidth-ssdchipcablesradius[i]
3722                                                  - fgkSSDChipCablesWidth[1]-fgkSSDChipCablesWidth[2];
3723         ymothervertex[i][1]  = ssdchipseparation-ymothervertex[i][0];
3724         ymothervertex[i][2]  = ymothervertex[i][1];
3725         ymothervertex[i][3]  = ymothervertex[i][0];
3726         ymothervertex[i][4]  = ymothervertex[i][0];
3727         ymothervertex[i][5]  = 0.5*fgkSSDChipWidth;
3728         ymothervertex[i][6]  = ymothervertex[i][5];
3729         ymothervertex[i][7]  = ssdchipseparation-0.5*fgkSSDChipWidth;
3730         ymothervertex[i][8]  = ymothervertex[i][7];
3731         ymothervertex[i][9]  = ymothervertex[i][5];
3732         ymothervertex[i][10] = ymothervertex[i][5];
3733         ymothervertex[i][11] = ymothervertex[i][4];
3734   }
3735   //////////////////////////////////////////////////////////
3736   TGeoVolume* chipsystemother[kchipsystemnumber];
3737   const char* chipsytemothername[kchipsystemnumber] =
3738                                         {"SSDChipSytemother1","SSDChipSytemother2"};
3739   for(Int_t i=0; i<kchipsystemnumber; i++){
3740     chipsystemothershape[i]->DefinePolygon(kmothervertexnumber,
3741                                                                         xmothervertex[i],ymothervertex[i]);
3742     chipsystemothershape[i]->DefineSection(0,-fgkSSDChipCablesHeight[i+2]
3743                                                                                   -0.5*fgkSSDChipHeight);
3744     chipsystemothershape[i]->DefineSection(1,0.5*fgkSSDChipHeight);
3745     chipsystemother[i] = new TGeoVolume(chipsytemothername[i],
3746                                                           chipsystemothershape[i],fSSDAir);
3747   }
3748   /////////////////////////////////////////////////////////////
3749   // SSD Chip Cables
3750   /////////////////////////////////////////////////////////////
3751   TGeoVolume* ssdchipcables[kchipsystemnumber];
3752   TGeoRotation** ssdchipcablesrot[kchipsystemnumber];
3753   TGeoTranslation** ssdchipcablestrans[kchipsystemnumber];
3754   TGeoCombiTrans** ssdchipcablescombitrans[kchipsystemnumber];
3755   //////////////////
3756   for(Int_t i=0; i<kchipsystemnumber; i++){
3757                 ssdchipcables[i] =
3758                 GetSSDChipCables(fgkSSDChipCablesHeight[i+2],knedges);
3759                 ssdchipcablestrans[i] = new TGeoTranslation*[fgkSSDChipNumber];
3760                 ssdchipcablesrot[i] = new TGeoRotation*[fgkSSDChipNumber];
3761                 ssdchipcablescombitrans[i] = new TGeoCombiTrans*[fgkSSDChipNumber];
3762   }
3763   for(Int_t i=0; i<kchipsystemnumber; i++){
3764         for(Int_t j=0; j<fgkSSDChipNumber; j++){
3765                 ssdchipcablestrans[i][j] = new TGeoTranslation();
3766                 ssdchipcablesrot[i][j] = new TGeoRotation();
3767                 ssdchipcablescombitrans[i][j] = new TGeoCombiTrans();
3768                 ssdchipcablesrot[i][j]->SetAngles(-90.0,0.0,0.0);
3769                 ssdchipcablestrans[i][j]->SetTranslation(j*(fgkSSDChipLength
3770                                                   +                fgkSSDChipSeparationLength),
3771                                                                                         0.5*fgkSSDChipWidth,
3772                                                   -                                     0.5*fgkSSDChipHeight
3773                                                   -                                     fgkSSDChipCablesHeight[i+2]);
3774                 ssdchipcablescombitrans[i][j]->SetRotation(*ssdchipcablesrot[i][j]);
3775                 ssdchipcablescombitrans[i][j]->SetTranslation(*ssdchipcablestrans[i][j]);
3776                 chipsystemother[i]->AddNode(ssdchipcables[i],j+1,ssdchipcablescombitrans[i][j]);
3777         }
3778         chipsystemother[i]->AddNode(ssdchipassembly,i+1);
3779         ssdchipsystemlist->Add(chipsystemother[i]);
3780   }
3781   /////////////////////////////////////////////////////////////
3782   // Deallocating memory
3783   /////////////////////////////////////////////////////////////
3784   for(Int_t i=0; i<kchipsystemnumber; i++){
3785         for(Int_t j=0; j<fgkSSDChipNumber; j++){
3786                 delete ssdchipcablesrot[i][j];
3787                 delete ssdchipcablestrans[i][j];
3788         }
3789         delete ssdchipcablesrot[i];
3790         delete ssdchipcablestrans[i];
3791   }
3792   /////////////////////////////////////////////////////////////
3793   return ssdchipsystemlist;
3794 }
3795 ///////////////////////////////////////////////////////////////////////////////
3796 TGeoVolume* AliITSv11GeometrySSD::GetSSDChips() const{
3797   /////////////////////////////////////////////////////////////
3798   // SSD Chip Assembly Generation
3799   /////////////////////////////////////////////////////////////
3800   const Int_t kssdchiprownumber = 2;
3801   TGeoBBox* ssdchipcompshape[2];
3802   ssdchipcompshape[0] =  new TGeoBBox("SSDChipCompShape",
3803                                                                                 0.5*fgkSSDChipLength,
3804                                                                                 0.5*fgkSSDChipWidth,
3805                                                                                 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3806   ssdchipcompshape[1] =  new TGeoBBox("SSDChipGlueCompShape",
3807                                                                                 0.5*fgkSSDChipLength,
3808                                                                                 0.5*fgkSSDChipWidth,
3809                                                                                 0.5*fgkSSDChipGlueHeight);
3810   TGeoVolume* ssdchipcomp[2];
3811   ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3812   ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3813                                                                   fSSDChipGlueMedium);
3814   ssdchipcomp[0]->SetLineColor(fColorSilicon);
3815   ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3816   TGeoTranslation* ssdchipcomptrans[2];
3817   ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3818   ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3819   /////////////////////////////////////////////////////////////
3820   // Virtual Volume containing SSDChip
3821   /////////////////////////////////////////////////////////////
3822   TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3823                                                                                                                  0.5*fgkSSDChipWidth,
3824                                                                                                                  0.5*fgkSSDChipHeight);
3825   TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
3826   /////////////////////////////////////////////////////////////
3827   for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3828   Double_t ssdchipseparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength,
3829                                                   fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3830                                    -  2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3831                                    -  0.5*fgkSSDChipWidth)};
3832   /////////////////////////////////////////////////////////////
3833   // Virtual Volume containing SSDChipAssembly
3834   /////////////////////////////////////////////////////////////
3835   TGeoXtru* ssdchipmothershape = new TGeoXtru(2);
3836   const Int_t kssdmothervertexnumber = 2*fgkSSDChipNumber;
3837   Double_t xmothervertex[kssdmothervertexnumber];
3838   Double_t ymothervertex[kssdmothervertexnumber];
3839   ///////////////////////
3840   // Setting the vertices
3841   ///////////////////////
3842   xmothervertex[0] = -0.5*fgkSSDChipLength,ymothervertex[0] = -0.5*fgkSSDChipWidth;
3843   xmothervertex[1] = xmothervertex[0], ymothervertex[1] = ssdchipseparation[1]
3844                                    - ymothervertex[0];
3845   xmothervertex[2] = (fgkSSDChipNumber-1)*ssdchipseparation[0]-xmothervertex[0];
3846   ymothervertex[2] = ymothervertex[1];
3847   xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
3848   xmothervertex[4] = ssdchipseparation[0]+xmothervertex[0];
3849   ymothervertex[4] = ymothervertex[0];
3850   xmothervertex[5] = xmothervertex[4], ymothervertex[5] = -ymothervertex[4];
3851   xmothervertex[6] = (fgkSSDChipNumber-1)*ssdchipseparation[0]
3852                                    + (0.5*fgkSSDChipLength-fgkSSDChipWidth);
3853   ymothervertex[6] = ymothervertex[5];
3854   xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
3855                                    - fgkSSDChipWidth;
3856   xmothervertex[8] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3857   ymothervertex[8] = ymothervertex[7];
3858   xmothervertex[9] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3859   ymothervertex[9] = ymothervertex[6];
3860   xmothervertex[10] = -xmothervertex[0], ymothervertex[10] = ymothervertex[9];
3861   xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[0];
3862   //////////////////////////////////////////////////////////
3863   ssdchipmothershape->DefinePolygon(kssdmothervertexnumber,
3864                                                                         xmothervertex,ymothervertex);
3865   ssdchipmothershape->DefineSection(0,-0.5*fgkSSDChipHeight);
3866   ssdchipmothershape->DefineSection(1, 0.5*fgkSSDChipHeight);
3867   TGeoVolume* ssdchipmother = new TGeoVolume("SSDChipContainer",
3868                                                           ssdchipmothershape,fSSDAir);
3869    /////////////////////////////////////////////////////////////
3870   for(Int_t i=0; i<kssdchiprownumber; i++)
3871     for(Int_t j=0; j<fgkSSDChipNumber; j++)
3872                 ssdchipmother->AddNode(ssdchip,fgkSSDChipNumber*i+j+1,
3873                 new TGeoTranslation(j*ssdchipseparation[0],i*ssdchipseparation[1],0.));
3874   return ssdchipmother;
3875 }
3876 /////////////////////////////////////////////////////////////////////////////////
3877 TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
3878   /////////////////////////////////////////////////////////////
3879   // Method returning a List containing pointers to Ladder Cable Volumes
3880   /////////////////////////////////////////////////////////////
3881   const Int_t kladdercablesegmentnumber = 2;
3882   /////////////////////////////////////////
3883   // LadderSegmentBBox Volume
3884   /////////////////////////////////////////
3885   TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber];
3886   const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3887                                 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
3888   for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3889                                                   new TGeoBBox(laddercablesegmentbboxshapename[i],
3890                                                                            0.5*fgkSSDFlexWidth[0],
3891                                                                            0.5*fgkSSDLadderCableWidth,
3892                                                                            0.5*fgkSSDFlexHeight[i]);
3893   const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3894                                                   {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3895   TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3896   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3897                         laddercablesegmentbbox[i] =
3898                                                   new TGeoVolume(laddercablesegmentbboxname[i],
3899                                                                                  laddercablesegmentbboxshape[i],
3900                                                                                  (i==0?fSSDAlTraceLadderCableMedium:
3901             fSSDKaptonLadderCableMedium));
3902                         laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3903                                                                                                                    fColorPolyhamide);
3904   }
3905   TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber];
3906   laddercablesegmentbboxtrans[0] =
3907                                                    new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3908                                                                                            0.5*fgkSSDFlexWidth[0],
3909                                                                                            0.5*fgkSSDLadderCableWidth,
3910                                                                                            0.5*fgkSSDFlexHeight[0]);
3911   laddercablesegmentbboxtrans[1] =
3912                                                    new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3913                                                                                            0.5*fgkSSDFlexWidth[0],
3914                                                                                            0.5*fgkSSDLadderCableWidth,
3915                                                                                            fgkSSDFlexHeight[0]
3916                                                                                            +0.5*fgkSSDFlexHeight[1]);
3917   TGeoVolume* laddercablesegmentbboxassembly =
3918                                                    new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly");
3919   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3920                 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3921                                                                                             laddercablesegmentbboxtrans[i]);
3922 /////////////////////////////////////////
3923 // LadderSegmentArb8 Volume
3924 /////////////////////////////////////////
3925   const Int_t kvertexnumber = 4;
3926   TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3927   for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3928                                                                                                   new TVector3*[kvertexnumber];
3929 //Shape Vertex Positioning
3930   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3931         laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
3932         laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3933                                                                                                                   i*fgkSSDFlexHeight[0]);
3934         laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3935                                                                                    +                         fgkSSDFlexHeight[1]
3936                                                                                    +                      i*fgkSSDFlexHeight[0]);
3937         laddercablesegmentvertexposition[i][3] =
3938                                                    new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3939                                                                                 laddercablesegmentvertexposition[i][2]->Y());
3940   }
3941   Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3942                                                                             {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
3943   char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
3944                                         {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
3945   TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3946   for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3947                                         GetArbShape(laddercablesegmentvertexposition[i],
3948                                                                 laddercablesegmentwidth[i],
3949                                                                 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3950                                                                 laddercablesegmentarbshapename[i]);
3951   const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3952                                                   {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
3953   TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3954   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3955                          laddercablesegmentarb[i] =
3956                                                    new TGeoVolume(laddercablesegmentarbname[i],
3957                                                                                   laddercablesegmentarbshape[i],
3958                                                                                   (i==0?fSSDAlTraceLadderCableMedium:
3959             fSSDKaptonLadderCableMedium));
3960                          laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3961                                                                                                                    fColorPolyhamide);
3962 }
3963   TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3964   laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3965                                                                                                  90.,90,-90.);
3966   laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3967                                                                                                   0.,90.,0.);
3968   TGeoCombiTrans* laddercablesegmentarbcombitrans =
3969                                                    new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3970                                                            0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3971                                                          + fgkSSDFlexWidth[0],0.,0.,
3972                                                    new TGeoRotation((*laddercablesegmentarbrot[1])
3973                                                      *(*laddercablesegmentarbrot[0])));
3974   TGeoVolume* laddercablesegmentarbassembly =
3975                                                    new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3976   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3977   laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3978                                                                                    laddercablesegmentarbcombitrans);
3979 /////////////////////////////////////////
3980 // End Ladder Cable Volume
3981 /////////////////////////////////////////
3982   TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3983   const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3984                                 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3985   for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3986                                                   new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3987                                                                            0.5*ssdendladdercablelength,
3988                                                                            0.5*fgkSSDLadderCableWidth,
3989                                                                            0.5*fgkSSDFlexHeight[i]);
3990   const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3991                                                   {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
3992   TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
3993   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3994                         ladderendcablesegmentbbox[i] =
3995                                                   new TGeoVolume(ladderendcablesegmentbboxname[i],
3996                                                                                  ladderendcablesegmentbboxshape[i],
3997                                                                                  (i==0?fSSDAlTraceLadderCableMedium:
3998             fSSDKaptonLadderCableMedium));
3999                         ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
4000                                                                                                                    fColorPolyhamide);
4001   }
4002   TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
4003   ladderendcablesegmentbboxtrans[0] =
4004                                                    new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
4005                                                                                            0.5*ssdendladdercablelength,
4006                                                                                            0.5*fgkSSDLadderCableWidth,
4007                                                                                            0.5*fgkSSDFlexHeight[0]);
4008   ladderendcablesegmentbboxtrans[1] =
4009                                                    new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
4010                                                                                            0.5*ssdendladdercablelength,
4011                                                                                            0.5*fgkSSDLadderCableWidth,
4012                                                                                            fgkSSDFlexHeight[0]
4013                                                                                            +0.5*fgkSSDFlexHeight[1]);
4014   TGeoVolume* ladderendcablesegmentbboxassembly =
4015                                                    new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
4016   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
4017                 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
4018                                                                                             ladderendcablesegmentbboxtrans[i]);
4019 /////////////////////////////////////////
4020   TList* laddercablesegmentlist = new TList();
4021   laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
4022   laddercablesegmentlist->Add(laddercablesegmentarbassembly);
4023   laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
4024   return laddercablesegmentlist;
4025   }
4026 /////////////////////////////////////////////////////////////////////////////////
4027 TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
4028   /////////////////////////////////////////////////////////////
4029   // Method generating Ladder Cable Volumes Assemblies
4030   /////////////////////////////////////////////////////////////
4031   TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
4032   TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
4033   for(Int_t i=0; i<n; i++){
4034          TGeoTranslation* laddercabletrans = new TGeoTranslation(
4035                                                         i*(fgkCarbonFiberJunctionWidth),
4036                                                         fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4037                                                         i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4038     laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
4039         if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
4040   }
4041   TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
4042                                           (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4043                                                                  fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4044                                           (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4045   laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
4046   return laddercable;
4047 }
4048 /////////////////////////////////////////////////////////////////////////////////
4049 TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
4050   /////////////////////////////////////////////////////////////
4051   // Method generating Ladder Cable Volumes Assembly
4052   /////////////////////////////////////////////////////////////
4053   TGeoVolume* laddercableassembly = new TGeoVolumeAssembly("LadderCableAssembly");
4054   char laddercabletransname[30];
4055   for(Int_t i=0; i<n; i++){
4056         sprintf(laddercabletransname,"LadderCableTrans%i",i+1);
4057     laddercableassembly->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
4058         new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0.,0.));
4059   }
4060   return laddercableassembly;
4061 }
4062 /////////////////////////////////////////////////////////////////////////////////
4063 TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
4064   /////////////////////////////////////////////////////////////
4065   // Method generating Ladder Cable List Assemblies
4066   /////////////////////////////////////////////////////////////
4067   const Int_t kladdercableassemblynumber = 2;
4068   TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
4069   TGeoVolume* ladderCable[kladdercableassemblynumber];
4070   char laddercableassemblyname[30];
4071   TList* laddercableassemblylist = new TList();
4072   for(Int_t i=0; i<kladdercableassemblynumber; i++){
4073         sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
4074         ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
4075         ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
4076                                          new TGeoCombiTrans((n-1)
4077                                          *       fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4078                                              2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
4079                                                                                         0.,new TGeoRotation("",180,0.,0.)));
4080         laddercableassemblylist->Add(ladderCable[i]);
4081 }
4082   return laddercableassemblylist;
4083 }
4084 ///////////////////////////////////////////////////////////////////////////////
4085 void AliITSv11GeometrySSD::SetLadderSegment(){
4086   /////////////////////////////////////////////////////////////
4087   // Method Generating Ladder Segment Array
4088   /////////////////////////////////////////////////////////////
4089   fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
4090   fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
4091   if(!fCreateMaterials) CreateMaterials();
4092   if(!fTransformationMatrices) CreateTransformationMatrices();
4093   if(!fBasicObjects) CreateBasicObjects();
4094   for(Int_t i=0; i<fgkladdersegmentnumber; i++){
4095   // Placing Carbon Fiber Support
4096         for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
4097                 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4098                                                                                         fcarbonfibersupportmatrix[j]);
4099                 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4100                                                                                         fcarbonfibersupportmatrix[j]);
4101   }
4102   // Placing Carbon Fiber Junction
4103     for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++)
4104         fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
4105                                                                    fcarbonfiberjunctionmatrix[j]);
4106   // Placing Carbon Fiber Lower Support
4107         for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++)
4108                 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
4109                                                            fcarbonfiberlowersupportrans[j]);
4110   // Placing SSD Sensor Support
4111     for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
4112         fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
4113                                                                      fssdsensorsupport[1][i],
4114                                                            j+1,fssdsensorsupportmatrix[j]);
4115   // Placing SSD Cooling Tube Support
4116         for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
4117                 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
4118                                                                    fcoolingtubesupportmatrix[j]);
4119   // Placing SSD Cooling Tube
4120         for(Int_t j=0; j<2; j++)
4121                 for(Int_t k=0; k<2; k++){
4122                 fladdersegment[i]->AddNode(fcoolingtube[0],2*j+k+1,fcoolingtubematrix[j][k]);
4123                 fladdersegment[i]->AddNode(fcoolingtube[j+1],k+1,fcoolingtubematrix[2+j][k]);
4124                 }
4125   // Placing SSD Hybrid
4126     switch(i){
4127         case 0:
4128                 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
4129                 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4130                 break;
4131     case 1:
4132                 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
4133                 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4134                 break;
4135         }
4136         // Placing Cooling Block System
4137     fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
4138         // Placing SSD Flex
4139         for(Int_t j=0; j<fgkflexnumber; j++){
4140       fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
4141       fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
4142         }
4143    }
4144 }
4145 ///////////////////////////////////////////////////////////////////////////////
4146 void AliITSv11GeometrySSD::SetEndLadderSegment(){
4147   /////////////////////////////////////////////////////////////
4148   // Method Generating End Ladder
4149   /////////////////////////////////////////////////////////////
4150   // End Ladder Carbon Fiber Junction
4151   /////////////////////////////////////////////////////////////
4152   fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
4153   fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
4154   if(!fCreateMaterials) CreateMaterials();
4155   if(!fTransformationMatrices) CreateTransformationMatrices();
4156   if(!fBasicObjects) CreateBasicObjects();
4157   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
4158         for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
4159                 fendladdersegment[i]->AddNode(j==2 ?
4160                                                         fendladdercarbonfiberjunction[i][1] :
4161                                                         fendladdercarbonfiberjunction[i][0],
4162                                                         j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
4163   }
4164   /////////////////////////////////////////////////////////////
4165   // End Ladder Carbon Fiber Support
4166   /////////////////////////////////////////////////////////////
4167   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
4168       for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
4169                   fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4170                   fendladdercarbonfibermatrix[i][j]);
4171           fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4172                   fendladdercarbonfibermatrix[i][j]);
4173       }
4174   /////////////////////////////////////////////////////////////
4175   // End Ladder Mounting Block
4176   /////////////////////////////////////////////////////////////
4177   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4178        fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
4179                                      fendladdermountingblockcombitrans[i]);
4180   /////////////////////////////////////////////////////////////
4181   // End Ladder Mounting Block Clip
4182   /////////////////////////////////////////////////////////////
4183   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4184         for(Int_t j=0; j<2; j++)
4185                 fendladdersegment[i]->AddNode(fendladdermountingblockclip,j+1,
4186                                               fendladdermountingblockclipmatrix[i][j]);
4187   /////////////////////////////////////////////////////////////
4188   // End Ladder Lower Supports
4189   /////////////////////////////////////////////////////////////
4190   fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
4191                                 fendladderlowersupptrans[0]);
4192   fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
4193                                 fendladderlowersupptrans[1]);
4194   fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
4195                                 fendladderlowersupptrans[2]);
4196   /////////////////////////////////////////////////////////////
4197   // End Ladder Cooling Tube Support
4198   /////////////////////////////////////////////////////////////
4199   for(Int_t i=0; i<2; i++)
4200         for(Int_t j=0; j<(i==0?4:2); j++)
4201                 fendladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
4202                                               fendladdercoolingtubesupportmatrix[i][j]);
4203   /////////////////////////////////////////////////////////////
4204   // End Ladder Cooling Tube Support
4205   /////////////////////////////////////////////////////////////
4206   fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
4207   fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
4208   fendladdersegment[0]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[0][2]);
4209   fendladdersegment[0]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[0][3]);
4210   fendladdersegment[0]->AddNode(fendladdercoolingtube[2],1,fendladdercoolingtubematrix[0][4]);
4211   fendladdersegment[0]->AddNode(fendladdercoolingtube[2],2,fendladdercoolingtubematrix[0][5]);
4212   fendladdersegment[1]->AddNode(fendladdercoolingtube[3],1,fendladdercoolingtubematrix[1][0]);
4213   fendladdersegment[1]->AddNode(fendladdercoolingtube[3],2,fendladdercoolingtubematrix[1][1]);
4214   fendladdersegment[1]->AddNode(fendladdercoolingtube[4],1,fendladdercoolingtubematrix[1][2]);
4215   fendladdersegment[1]->AddNode(fendladdercoolingtube[4],2,fendladdercoolingtubematrix[1][3]);
4216 }
4217 ///////////////////////////////////////////////////////////////////////////////
4218 void AliITSv11GeometrySSD::SetLadder(){
4219   /////////////////////////////////////////////////////////////
4220   // Method Generating Ladder of Layer 5 and 6
4221   /////////////////////////////////////////////////////////////
4222   Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
4223                                                                                                 fgkSSDLay6SensorsNumber};
4224   /////////////////////////////////////////////////////////////////////////////
4225   /// Generating Ladder Mother Volume Containing Ladder
4226   /////////////////////////////////////////////////////////////////////////////
4227   TGeoXtru* laddershape[fgkladdernumber];
4228   for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
4229   const Int_t kmothervertexnumber = 8;
4230   Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
4231   Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
4232   ///////////////////////
4233   // Setting the vertices
4234   ///////////////////////
4235   Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
4236                                                                 * (fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]);
4237   xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
4238   ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
4239                                           -  fgkSSDModuleVerticalDisalignment;
4240   xmothervertex[0][1] = xmothervertex[0][0];
4241   ymothervertex[0][1] = 0.0;
4242   xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
4243                                                 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
4244   ymothervertex[0][2] = ymothervertex[0][1];
4245   ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
4246   xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
4247   xmothervertex[0][4] = -xmothervertex[0][3];
4248   ymothervertex[0][4] = ymothervertex[0][3];
4249   xmothervertex[0][5] = -xmothervertex[0][2];
4250   ymothervertex[0][5] = ymothervertex[0][2];
4251   xmothervertex[0][6] = -xmothervertex[0][1];
4252   ymothervertex[0][6] = ymothervertex[0][1];
4253   xmothervertex[0][7] = -xmothervertex[0][0];
4254   ymothervertex[0][7] = ymothervertex[0][0];
4255   for(Int_t i=0; i<kmothervertexnumber; i++){
4256         xmothervertex[1][i] = xmothervertex[0][i];
4257         ymothervertex[1][i] = ymothervertex[0][i];
4258   }
4259   const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4260   for(Int_t i=0; i<fgkladdernumber; i++){
4261         laddershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
4262                                                                     ymothervertex[i]);
4263     laddershape[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
4264     laddershape[i]->DefineSection(1,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4265                                                                                         +fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4266     fladder[i] = new TGeoVolume(laddername[i],laddershape[i],fSSDAir);
4267         fladder[i]->SetLineColor(4);
4268  }
4269 ///////////////////////////////////////////////////////////////////////////
4270  if(!fCreateMaterials) CreateMaterials();
4271  if(!fTransformationMatrices) CreateTransformationMatrices();
4272  if(!fBasicObjects) CreateBasicObjects();
4273  SetLadderSegment();
4274  SetEndLadderSegment();
4275   for(Int_t i=0; i<fgkladdernumber; i++){
4276         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4277         //////////////////////////
4278         /// Placing Ladder Segment
4279         //////////////////////////
4280                 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4281                                                                      fladdersegment[i==0 ? 1 : 0],
4282                                                                          ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4283         //////////////////////////
4284         /// Placing SSD Sensor
4285         //////////////////////////
4286                 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4287                                                         fssdsensormatrix[i][j]);
4288         }
4289         ///////////////////////////////
4290         /// Placing End Ladder Segment
4291         ///////////////////////////////
4292     fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
4293         fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4294    }
4295 /////////////////////////////////////////////////////////////////////////////
4296 /// Placing Ladder Cables
4297 /////////////////////////////////////////////////////////////////////////////
4298   Int_t sidecablenumber[2][2];
4299   sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4300   sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4301   sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4302   sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4303   Double_t carbonfibertomoduleposition[3];
4304   carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4305   carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4306                          fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4307          +               0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4308          -               0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4309          -            fgkSSDSensorCenterSupportThickness[0]);
4310   carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4311                                                                  +   0.5*fgkCoolingTubeSupportHeight
4312          -         fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4313   const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
4314   Double_t ssdendladdercablelength[4];
4315   ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
4316                                                          + fgkSSDSensorLength
4317                                                          - fgkSSDModuleStiffenerPosition[1]
4318                                                          - fgkSSDStiffenerWidth
4319                                                          - fgkSSDFlexWidth[0]
4320                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
4321   ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
4322                                                          + fgkSSDModuleStiffenerPosition[1]
4323                                                          + fgkSSDStiffenerWidth
4324                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
4325   ssdendladdercablelength[2] = ssdendladdercablelength[1]
4326                                                          - fgkEndLadderCarbonFiberLowerJunctionLength[1]
4327                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4328                                                          - kendladdercablecorrection;
4329   ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4330                                                          + carbonfibertomoduleposition[1]
4331                                                          - fgkSSDModuleStiffenerPosition[1]
4332                                                          - fgkSSDStiffenerWidth)
4333                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
4334   TList* laddercableassemblylist[4];
4335   const Int_t kendladdercablesnumber = 4;
4336   for(Int_t i=0; i<fgkladdercablesnumber; i++)
4337         for(Int_t j=0; j<kendladdercablesnumber; j++){
4338                 laddercableassemblylist[j] =
4339                 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4340                                                                    ssdendladdercablelength[j]);
4341             fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4342                                                                         j<2?1:2,fladdercablematrix[i][j]);
4343   }
4344 }
4345 ////////////////////////////////////////////////////////////////////////////////
4346 void AliITSv11GeometrySSD::SetLayer(){
4347 ////////////////////////////////////////////////////////////////////////////////
4348   // Creating Ladder of Layer 5 and Layer 6
4349   /////////////////////////////////////////////////////////////
4350   if(!fCreateMaterials) CreateMaterials();
4351   if(!fTransformationMatrices) CreateTransformationMatrices();
4352   if(!fBasicObjects) CreateBasicObjects();
4353   SetLadder(); // Generating the ladder of Layer5 and Layer6
4354   const Int_t kssdlayladdernumber[fgklayernumber] =
4355                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4356   /////////////////////////////////////////////////////////////
4357   // Generating mother volumes for Layer5 and Layer6
4358   /////////////////////////////////////////////////////////////
4359   fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
4360   fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
4361   Int_t *ladderindex[fgklayernumber];
4362   Int_t index[fgklayernumber] = {8,9};
4363   for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4364   for(Int_t i=0; i<fgklayernumber; i++)
4365         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4366                 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4367                                                           j+index[i] : j+index[i]-kssdlayladdernumber[i];
4368                 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4369                         fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4370         }
4371   /////////////////////////////////////////////////////////////
4372   // Deallocating memory
4373   /////////////////////////////////////////////////////////////
4374   for(Int_t i=0; i<fgklayernumber; i++) delete ladderindex[i];
4375 }
4376 ////////////////////////////////////////////////////////////////////////////////
4377 void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
4378   /////////////////////////////////////////////////////////////
4379   // Insert the layer 5 in the mother volume.
4380   /////////////////////////////////////////////////////////////
4381   if (! moth) {
4382     printf("Error::AliITSv11GeometrySSD: Can't insert layer5, mother is null!\n");
4383     return;
4384   };
4385   if(!fSSDLayer5) SetLayer();
4386   fMotherVol = moth;
4387   TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4388                                                                                 + fgkLay5CenterITSPosition);
4389   moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
4390  }
4391 ////////////////////////////////////////////////////////////////////////////////
4392 void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
4393   /////////////////////////////////////////////////////////////
4394   // Insert the layer 6 in the mother volume.
4395   /////////////////////////////////////////////////////////////
4396   if (! moth) {
4397     printf("Error::AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
4398     return;
4399   };
4400   if(!fSSDLayer6) SetLayer();
4401   fMotherVol = moth;
4402   TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4403                                                                                 + fgkLay6CenterITSPosition);
4404   moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
4405  }
4406  ////////////////////////////////////////////////////////////////////////////////
4407  TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4408   /////////////////////////////////////////////////////////////
4409   // Method generating the Arc structure of Ladder Support
4410   /////////////////////////////////////////////////////////////
4411   const Int_t kssdlayladdernumber[fgklayernumber] =
4412                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4413   Double_t mountingsupportedge[fgklayernumber];
4414   Double_t mountingblockratio[fgklayernumber];
4415   Double_t theta[fgklayernumber];
4416   Double_t phi[fgklayernumber];
4417   Double_t psi0[fgklayernumber];
4418   Double_t deltapsi[fgklayernumber];
4419   TVector3* mountingsupportedgevector[fgklayernumber];
4420   for(Int_t i=0; i<fgklayernumber; i++){
4421         mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4422     mountingsupportedge[i]    = 0.5*fgkMountingBlockSupportRadius[i]
4423                                                           *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
4424                                                           * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4425                                                           - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4426                                                           / kssdlayladdernumber[i])));
4427     theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4428     phi[i]   = TMath::ASin(0.5*mountingblockratio[i]);
4429         mountingsupportedgevector[i] = new TVector3();
4430     mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4431         mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(1.
4432                                                                  -TMath::Power(mountingsupportedgevector[i]->X()
4433                                                                  /                         fgkMountingBlockSupportRadius[i],2)));
4434     psi0[i] = 0.5*TMath::Pi()-phi[i];
4435     deltapsi[i] = (theta[i]+phi[i])/nedges;
4436   }
4437   TVector3** vertex[fgklayernumber];
4438   TList* vertexlist[fgklayernumber];
4439   Int_t indexedge[fgklayernumber] = {0,0};
4440   for(Int_t i=0; i<fgklayernumber; i++){
4441         vertex[i] = new TVector3*[nedges+1];
4442         vertexlist[i] = new TList();
4443   }
4444   for(Int_t i=0; i<fgklayernumber; i++){
4445         for(Int_t j=0; j<nedges+1; j++){
4446                 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
4447                                                                     fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]));
4448                 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4449                 vertexlist[i]->Add(vertex[i][j]);
4450         }
4451         vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4452   }
4453   Double_t** xsidevertex = new Double_t*[fgklayernumber];
4454   Double_t** ysidevertex = new Double_t*[fgklayernumber];
4455   Double_t** xcentervertex = new Double_t*[fgklayernumber];
4456   Double_t** ycentervertex = new Double_t*[fgklayernumber];
4457   Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4458   Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4459   Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4460   Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4461   for(Int_t i=0; i<fgklayernumber; i++){
4462     xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4463     ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4464     xcentervertex[i] = new Double_t[indexedge[i]+3];
4465     ycentervertex[i] = new Double_t[indexedge[i]+3];
4466         xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4467         ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4468         xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4469         ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4470         for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4471                 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4472                                                                                 ((TVector3*)vertexlist[i]->At(j))->X();
4473                 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4474                                                                                 ((TVector3*)vertexlist[i]->At(j))->Y();
4475                 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4476                 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4477                 if(j<indexedge[i]+1){
4478                         xcentervertex[i][j!=indexedge[i]?j+3:0] =
4479                                                                                 ((TVector3*)vertexlist[i]->At(j))->X();
4480                         ycentervertex[i][j!=indexedge[i]?j+3:0] =
4481                                                                                 ((TVector3*)vertexlist[i]->At(j))->Y();
4482                         xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4483                         ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4484                 }
4485         }
4486         xsidevertex[i][1] = xsidevertex[i][0];
4487         ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4488         xsidevertex[i][2] = xsidevertex[i][3];
4489         ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4490         xcentervertex[i][1] = xcentervertex[i][0];
4491         ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4492         xcentervertex[i][2] = xcentervertex[i][3];
4493         ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4494         xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4495         ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4496         xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4497         ycenterlowervertex[i][0] = ysidevertex[i][0];
4498         xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4499         ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4500   }
4501   /////////////////////////////////////////////////////////////
4502   // Building the Arc Structure of Ladder Supports
4503   /////////////////////////////////////////////////////////////
4504   TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4505   TGeoXtru* centermountingsupportshape[fgklayernumber];
4506   TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4507   TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4508   TGeoVolume* sidemountingblocksupport[fgklayernumber];
4509   TGeoVolume* centermountingblocksupport[fgklayernumber];
4510   TGeoVolume* sideladdersupportpiece[fgklayernumber];
4511   TGeoVolume* centerladdersupportpiece[fgklayernumber];
4512   char sidemountingblockname[40];
4513   char centermountingblockname[40];
4514   char sideladdersupportpiecename[40];
4515   char centerladdersupportpiecename[40];
4516   for(Int_t i=0; i<fgklayernumber; i++){
4517         sprintf(sidemountingblockname,"MountingBlockSupportSideLay%dArc",i+5);
4518         sprintf(centermountingblockname,"MountingBlockSupportCenterLay%dArc",i+5);
4519         sprintf(sideladdersupportpiecename,"SideLadderSupportPieceLay%d",i+5);
4520         sprintf(centerladdersupportpiecename,"CenterLadderSupportPieceLay%d",i+5);
4521         sidemountingblocksupportshape[i] = new TGeoXtru(2);
4522     sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4523                                                                                                 xsidevertex[i],ysidevertex[i]);
4524     sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4525                                                                                                          -fgkMountingBlockSupportWidth[0]);
4526     sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4527     sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4528                                                                           sidemountingblocksupportshape[i],
4529                                                                                   fSSDAlCoolBlockMedium);
4530         sidemountingblocksupport[i]->SetLineColor(9);
4531         centermountingsupportshape[i] = new TGeoXtru(2);
4532     centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4533                                                                                                 xcentervertex[i],ycentervertex[i]);
4534         centermountingsupportshape[i]->DefineSection(0,0.);
4535     centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4536                                                                                                   -fgkMountingBlockSupportWidth[0]);
4537     centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4538                                                                           centermountingsupportshape[i],
4539                                                                                   fSSDAlCoolBlockMedium);
4540         centermountingblocksupport[i]->SetLineColor(9);
4541         sideladdersupportpieceshape[i] = new TGeoXtru(2);
4542     sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4543                                                                                                 xsidelowervertex[i],ysidelowervertex[i]);
4544         sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4545                                                                                                          -fgkMountingBlockSupportWidth[0]);
4546     sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4547     sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4548                                                                           sideladdersupportpieceshape[i],
4549                                                                                   fSSDCarbonFiberMedium);
4550         sideladdersupportpiece[i]->SetLineColor(fColorAl);
4551         centerladdersupportpieceshape[i] = new TGeoXtru(2);
4552     centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4553                                                                                                 xcenterlowervertex[i],ycenterlowervertex[i]);
4554         centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4555     centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4556                                                                                                   -fgkMountingBlockSupportWidth[0]);
4557     centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4558                                                                           centerladdersupportpieceshape[i],
4559                                                                                   fSSDCarbonFiberMedium);
4560         centerladdersupportpiece[i]->SetLineColor(fColorAl);
4561   }
4562   /////////////////////////////////////////////////////////////
4563   // Building the Up Structure of Ladder Supports
4564   /////////////////////////////////////////////////////////////
4565   TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4566   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4567   TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4568   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4569   TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4570   //////////////////////////////////////////////////////////
4571   // Setting the volume for TGeoXtru Mounting Block Piece
4572   //////////////////////////////////////////////////////////
4573   TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4574   TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4575   TGeoVolume* mountingblockpiecedown[fgklayernumber];
4576   TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4577   TGeoVolume* mountingblockpieceup[fgklayernumber];
4578   Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4579   Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4580   Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4581   Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
4582   char mountingblockpiecedownname[34];
4583   char mountingblockpieceupname[34];
4584   for(Int_t i=0; i<fgklayernumber; i++){
4585     ///////////////////////////
4586     // Mounting Block Down Vertex
4587     ///////////////////////////
4588         mountingblockpiecedownshape[i] = new TGeoXtru(2);
4589     sprintf(mountingblockpiecedownname,"MountingBlockPieceDownLay%d",i+5);
4590         mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4591         mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4592                                                                                 + fgkMountingBlockSupportDownHeight;
4593         mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4594         mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4595                                                                                 + fgkSSDMountingBlockHeight[1]
4596                                                                                 - 0.5*fgkCoolingTubeSupportHeight
4597                                                                                 - fgkSSDModuleCoolingBlockToSensor
4598                                                                                 - fgkSSDModuleVerticalDisalignment;
4599         mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4600         mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4601         mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4602         mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4603         mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4604         mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4605         mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4606         mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4607                                                                                 + fgkSSDMountingBlockHeight[2]
4608                                                                                 - fgkSSDMountingBlockHeight[0];
4609         mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4610         mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4611         mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4612         mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4613         mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4614                                                                                                          mountingblockpiecedownyvertex[i]);
4615         mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4616         mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4617         mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
4618                                                                  mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
4619         mountingblockpiecedown[i]->SetLineColor(fColorG10);
4620     ///////////////////////////
4621     // Mounting Block Up Vertex
4622     ///////////////////////////
4623         mountingblockpieceupshape[i] = new TGeoXtru(2);
4624         sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5);
4625         mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4626         mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4627                                                                                 + fgkMountingBlockSupportUpHeight[i];
4628         mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4629         mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4630                                                                                 + fgkSSDMountingBlockHeight[1]
4631                                                                                 - 0.5*fgkCoolingTubeSupportHeight
4632                                                                                 - fgkSSDModuleCoolingBlockToSensor
4633                                                                                 - fgkSSDModuleVerticalDisalignment;
4634         mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4635         mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4636         mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4637         mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4638         mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4639         mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4640         mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4641         mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4642                                                                                 + fgkSSDMountingBlockHeight[2]
4643                                                                                 - fgkSSDMountingBlockHeight[0];
4644         mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4645         mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4646         mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4647         mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
4648         mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4649                                                                                                          mountingblockpieceupyvertex[i]);
4650         mountingblockpieceupshape[i]->DefineSection(0,0.0);
4651         mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4652         mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
4653                                                                 mountingblockpieceupshape[i],fSSDMountingBlockMedium);
4654         mountingblockpieceup[i]->SetLineColor(fColorG10);
4655  }
4656   ///////////////////////////////////////////////////////////////////
4657   // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4658   ///////////////////////////////////////////////////////////////////
4659   TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4660   TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4661   TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4662   TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4663   Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4664   Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4665   Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4666   Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
4667   char mountingblocksupportrapezoidowname[40];
4668   char mountingblocksupportrapezoidupname[40];
4669   Double_t scalefactor = 3./4.;
4670   for(Int_t i=0; i<fgklayernumber; i++){
4671   ////////////////////////////////////////////
4672   // Mounting Block Support Down Trapezoid Vertex
4673   ////////////////////////////////////////////
4674         mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4675         mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4676                                                                                                  - mountingsupportedge[i];
4677         mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4678         mountingblocksupportrapezoidownxvertex[i][1] =
4679                                                                                 mountingblocksupportrapezoidownxvertex[i][0];
4680         mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4681                                                                                                  + scalefactor*(mountingblockpiecedownyvertex[i][1]
4682                                                                                              - mountingblockpiecedownyvertex[i][0]);
4683         mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4684         mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4685         mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4686         mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4687         mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4688         mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
4689         mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4690                                                                                                                mountingblocksupportrapezoidownyvertex[i]);
4691         mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4692                                                                                                                         -fgkMountingBlockSupportWidth[0]);
4693         mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4694         sprintf(mountingblocksupportrapezoidowname,"MountingBlockSuppTrapezoidDownLay%d",i+5);
4695         mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
4696                                                                 mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
4697         mountingblocksupportrapezoidown[i]->SetLineColor(9);
4698   ////////////////////////////////////////////
4699   // Mounting Block Support Up Trapezoid Vertex
4700   ////////////////////////////////////////////
4701         mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4702         mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4703                                                                                                  - mountingsupportedge[i];
4704         mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4705         mountingblocksupportrapezoidupxvertex[i][1] =
4706                                                                                 mountingblocksupportrapezoidupxvertex[i][0];
4707         mountingblocksupportrapezoidupyvertex[i][1] =
4708                                                                                                mountingblockpieceupyvertex[i][0]
4709                                                                                                  + scalefactor*(mountingblockpieceupyvertex[i][1]
4710                                                                                              - mountingblockpieceupyvertex[i][0]);
4711         mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4712         mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4713         mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4714         mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4715         mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4716         mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
4717         mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4718                                                                                                                mountingblocksupportrapezoidupyvertex[i]);
4719         mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4720                                                                                                                         -fgkMountingBlockSupportWidth[0]);
4721         mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4722         sprintf(mountingblocksupportrapezoidupname,"MountingBlockSuppTrapezoidUpLay%d",i+5);
4723         mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
4724                                                                 mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
4725         mountingblocksupportrapezoidup[i]->SetLineColor(9);
4726   }
4727   ///////////////////////////////////////////////////////////////////
4728   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4729   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4730   Double_t boxoriginup[fgklayernumber][2][3];
4731   Double_t boxorigindown[fgklayernumber][2][3];
4732   char mountingblocksupportboxdownname[34];
4733   char mountingblocksupportboxupname[34];
4734   TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4735   mountingblocksupportrot->SetAngles(90.,180.,-90);
4736   TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4737   globalrefladdersupportrot->SetAngles(0.,90.,0.);
4738   TGeoHMatrix* laddersupportmatrix[2];
4739   laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4740   laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4741   /////////////////////////////////////////////////////////////
4742   // Creating Mother Volume for Containment
4743   /////////////////////////////////////////////////////////////
4744   Double_t *xmothervertex[fgklayernumber];
4745   Double_t *ymothervertex[fgklayernumber];
4746   for(Int_t i=0; i<fgklayernumber; i++){
4747         xmothervertex[i] = new Double_t[8];
4748         ymothervertex[i] = new Double_t[8];
4749   }
4750   TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4751   TGeoVolume* downmotherladdersupport[fgklayernumber];
4752   TGeoXtru* upmotherladdersupportshape[fgklayernumber];
4753   TGeoVolume* upmotherladdersupport[fgklayernumber];
4754   char upmotheladdersupportname[30];
4755   char downmotheladdersupportname[30];
4756   for(Int_t i=0; i<fgklayernumber; i++){
4757         xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4758                                                     -  mountingsupportedge[i];
4759         ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4760         xmothervertex[i][1] = xmothervertex[i][0];
4761         ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4762                                                         + fgkMountingBlockSupportWidth[0];
4763         xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4764         ymothervertex[i][2] = ymothervertex[i][1];
4765         xmothervertex[i][3] = xmothervertex[i][2];
4766         ymothervertex[i][3] = -ymothervertex[i][0];
4767         xmothervertex[i][4] = -xmothervertex[i][0];
4768         ymothervertex[i][4] = ymothervertex[i][3];
4769         xmothervertex[i][5] = xmothervertex[i][4];
4770         ymothervertex[i][5] = -ymothervertex[i][1];
4771         xmothervertex[i][6] = -xmothervertex[i][2];
4772         ymothervertex[i][6] = ymothervertex[i][5];
4773         xmothervertex[i][7] = xmothervertex[i][6];
4774         ymothervertex[i][7] = ymothervertex[i][0];
4775         sprintf(downmotheladdersupportname,"LadderSupportDownLay%d",i+5);
4776         sprintf(upmotheladdersupportname,"LadderSupportUpLay%d",i+5);
4777     downmotherladdersupportshape[i] = new TGeoXtru(2);
4778         downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4779         downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4780     downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4781                                                                    +                       fgkMountingBlockSupportDownHeight
4782                                                                    +                       fgkSSDMountingBlockHeight[1]
4783                                                                    -                       0.5*fgkCoolingTubeSupportHeight
4784                                                                    -                       fgkSSDModuleCoolingBlockToSensor
4785                                                                    -                       2.*fgkSSDModuleVerticalDisalignment);
4786     downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4787                                                                           downmotherladdersupportshape[i],fSSDAir);
4788     upmotherladdersupportshape[i] = new TGeoXtru(2);
4789         upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4790         upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4791     upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4792                                                                    +                       fgkMountingBlockSupportUpHeight[i]
4793                                                                    +                       fgkSSDMountingBlockHeight[1]
4794                                                                    -                       0.5*fgkCoolingTubeSupportHeight
4795                                                                    -                       fgkSSDModuleCoolingBlockToSensor
4796                                                                    -               2.*fgkSSDModuleVerticalDisalignment);
4797     upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4798                                                                                           upmotherladdersupportshape[i],fSSDAir);
4799   }
4800   for(Int_t i=0; i<fgklayernumber; i++){
4801         /////////////////////////
4802         // Setting the box origin
4803         /////////////////////////
4804         boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4805         boxorigindown[i][0][1] =  fgkMountingBlockSupportRadius[i]
4806                                                    +  0.5*fgkMountingBlockSupportDownHeight;
4807         boxorigindown[i][0][2] =  fgkMountingBlockSupportWidth[1]
4808                                                    -  0.5*fgkMountingBlockSupportWidth[0];
4809
4810         boxorigindown[i][1][0] = 0.0;
4811         boxorigindown[i][1][1] = boxorigindown[i][0][1];
4812         boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4813                                                    -      fgkMountingBlockSupportWidth[0]);
4814
4815         boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4816         boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
4817                                                  + 0.5*fgkMountingBlockSupportUpHeight[i];
4818         boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4819                                                  - 0.5*fgkMountingBlockSupportWidth[0];
4820
4821         boxoriginup[i][1][0] = 0.0;
4822         boxoriginup[i][1][1] = fgkMountingBlockSupportRadius[i]
4823                                                  + 0.5*fgkMountingBlockSupportUpHeight[i];
4824         boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4825                                                  - fgkMountingBlockSupportWidth[0]);
4826
4827         /////////////////////////
4828     // Setting the boxes
4829         /////////////////////////
4830         mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4831                                                                                  +  fgkSSDMountingBlockLength[0]),
4832                                                                                         0.5*fgkMountingBlockSupportDownHeight,
4833                                                                                         0.5*fgkMountingBlockSupportWidth[0],
4834                                                                                         boxorigindown[i][0]);
4835     mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4836                                                                                         0.5*fgkMountingBlockSupportDownHeight,
4837                                                                                         0.5*(fgkMountingBlockSupportWidth[1]
4838                                                                                  -  fgkMountingBlockSupportWidth[0]),
4839                                                                                         boxorigindown[i][1]);
4840
4841         mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4842                                                                                  +  fgkSSDMountingBlockLength[0]),
4843                                                                                         0.5*fgkMountingBlockSupportUpHeight[i],
4844                                                                                         0.5*fgkMountingBlockSupportWidth[0],
4845                                                                                         boxoriginup[i][0]);
4846
4847         mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4848                                                                                         0.5*fgkMountingBlockSupportUpHeight[i],
4849                                                                                         0.5*(fgkMountingBlockSupportWidth[1]
4850                                                                      -  fgkMountingBlockSupportWidth[0]),
4851                                                                                         boxoriginup[i][1]);
4852         ///////////////////////////////////////
4853     // Adding the Volumes to Mother Volume
4854         ///////////////////////////////////////
4855         for(Int_t j=0; j<2; j++){
4856                 sprintf(mountingblocksupportboxdownname,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4857                 sprintf(mountingblocksupportboxupname,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4858                 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4859                                                                                   mountingblocksupportboxdownshape[i][j],
4860                                                                                   fSSDCarbonFiberMedium);
4861                 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4862                                                                                   mountingblocksupportboxupshape[i][j],
4863                                                                                   fSSDCarbonFiberMedium);
4864                 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4865                 mountingblocksupportboxup[i][j]->SetLineColor(9);
4866                 for(Int_t k=0; k<2; k++){
4867                         downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
4868                         upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
4869                 }
4870         }
4871         for(Int_t k=0; k<2; k++){
4872                 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4873                 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4874                 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4875                 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4876             downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
4877                 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4878                 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4879                 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4880                 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4881                 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4882                 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4883                 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
4884         }
4885   }
4886   TList* laddersupportlist = new TList();
4887   laddersupportlist->Add(downmotherladdersupport[0]);
4888   laddersupportlist->Add(upmotherladdersupport[0]);
4889   laddersupportlist->Add(downmotherladdersupport[1]);
4890   laddersupportlist->Add(upmotherladdersupport[1]);
4891   /////////////////////////////////////////////////////////////
4892   // Deallocating memory
4893   /////////////////////////////////////////////////////////////
4894   for(Int_t i=0; i<fgklayernumber; i++){
4895         for(Int_t j=0; j<nedges+1; j++)
4896                 delete vertex[i][j];
4897         delete mountingsupportedgevector[i];
4898         delete [] vertex[i];
4899         delete vertexlist[i];
4900         delete [] xsidevertex[i];
4901         delete [] ysidevertex[i];
4902         delete [] xcentervertex[i];
4903         delete [] ycentervertex[i];
4904         delete [] xsidelowervertex[i];
4905         delete [] ysidelowervertex[i];
4906         delete [] xcenterlowervertex[i];
4907         delete [] ycenterlowervertex[i];
4908   }
4909   delete xsidevertex;
4910   delete ysidevertex;
4911   delete xcentervertex;
4912   delete ycentervertex;
4913   delete xsidelowervertex;
4914   delete ysidelowervertex;
4915   delete xcenterlowervertex;
4916   delete ycenterlowervertex;
4917   delete globalrefladdersupportrot;
4918   delete mountingblocksupportrot;
4919   /////////////////////
4920   return laddersupportlist;
4921 }
4922  ////////////////////////////////////////////////////////////////////////////////
4923 void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4924 //////////////////////////////////////////
4925 // Method Generating Ladder Support Ring
4926 //////////////////////////////////////////
4927   if(!fCreateMaterials) CreateMaterials();
4928   if(!fTransformationMatrices) CreateTransformationMatrices();
4929   if(!fBasicObjects) CreateBasicObjects();
4930   fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4931   fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4932     const Int_t kssdlayladdernumber[fgklayernumber] =
4933                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4934   Double_t mountingsupportedge[fgklayernumber];
4935   Double_t mountingblockratio[fgklayernumber];
4936   Double_t theta[fgklayernumber];
4937   Double_t phi[fgklayernumber];
4938   for(Int_t i=0; i<fgklayernumber; i++){
4939         mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4940     mountingsupportedge[i]    = 0.5*fgkMountingBlockSupportRadius[i]
4941                                                           *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
4942                                                           * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4943                                                           - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4944                                                           / kssdlayladdernumber[i])));
4945     theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4946                          / fgkMountingBlockSupportRadius[i]);
4947     phi[i]   = TMath::ASin(0.5*mountingblockratio[i]);
4948   }
4949   TGeoRotation* globalrot = new TGeoRotation();
4950   globalrot->SetAngles(0.,-90.,0.);
4951   TGeoRotation** laddersupportrot[fgklayernumber];
4952   TGeoHMatrix**  laddersupportmatrix[fgklayernumber];
4953   for(Int_t i=0; i<fgklayernumber; i++){
4954         laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
4955         laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
4956         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4957                 laddersupportrot[i][j] = new TGeoRotation();
4958                 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
4959                 switch(i){
4960                         case 0: //Ladder of Layer5
4961                                 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4962                                 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
4963                                                                             laddersupportmatrix[i][j]);
4964                         break;
4965                         case 1: //Ladder of Layer6
4966                                 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4967                                 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
4968                                                                               laddersupportmatrix[i][j]);
4969                         break;
4970                 }
4971     }
4972   }
4973   /////////////////////////////////////////////////////////////
4974   // Creating Lower Ladder Support
4975   /////////////////////////////////////////////////////////////
4976   TVector3** ringsupportvertex[fgklayernumber];
4977   Double_t angle = 360./nedges;
4978   for(Int_t i=0; i<fgklayernumber; i++){
4979     ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
4980         ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
4981                                                         *                          TMath::Cos(theta[i]));
4982         ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
4983                                                         -                          mountingsupportedge[i],
4984                                                                                    ringsupportvertex[i][0]->Y());
4985         ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
4986                                                                                    ringsupportvertex[i][1]->Y());
4987     ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
4988         for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4989            ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
4990            ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
4991            ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
4992            ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
4993         }
4994         ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
4995     for(Int_t j=0; j<nedges+1; j++){
4996                 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
4997                         new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*CosD(90.0-j*angle),
4998                                                  (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*SinD(90.0-j*angle));
4999         }
5000   }
5001   Double_t **xmothervertex = new Double_t*[fgklayernumber];
5002   Double_t **ymothervertex = new Double_t*[fgklayernumber];
5003   for(Int_t i=0; i<fgklayernumber; i++){
5004         xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5005         ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5006         for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
5007                 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
5008                 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
5009         }
5010   }
5011   char lowerladdersupportname[30];
5012   TGeoXtru* lowerladdersupportshape[fgklayernumber];
5013   TGeoVolume* lowerladdersupport[fgklayernumber];
5014   TGeoRotation* lowerladdersupportrot = new TGeoRotation();
5015   lowerladdersupportrot->SetAngles(90.,180.,-90);
5016   for(Int_t i=0; i<fgklayernumber; i++){
5017         lowerladdersupportshape[i] = new TGeoXtru(2);
5018         lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
5019                                                                                           xmothervertex[i],ymothervertex[i]);
5020         lowerladdersupportshape[i]->DefineSection(0,0.);
5021     lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
5022         sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
5023     lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
5024                                                         lowerladdersupportshape[i],fSSDSupportRingAl);
5025         lowerladdersupport[i]->SetLineColor(fColorAl);
5026         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
5027         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
5028   }
5029   /////////////////////////////////////////////////////////////
5030   // Deallocating memory
5031   /////////////////////////////////////////////////////////////
5032   for(Int_t i=0; i<fgklayernumber; i++){
5033         for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
5034                 delete ringsupportvertex[i][j];
5035         delete [] ringsupportvertex[i];
5036   }
5037   for(Int_t i=0; i<fgklayernumber; i++){
5038         delete [] xmothervertex[i];
5039         delete [] ymothervertex[i];
5040   }
5041   delete xmothervertex;
5042   delete ymothervertex;
5043   delete globalrot;
5044   for(Int_t i=0; i<fgklayernumber; i++){
5045         for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
5046                 delete laddersupportrot[i][j];
5047         delete [] laddersupportrot[i];
5048   }
5049  }
5050  ////////////////////////////////////////////////////////////////////////////////
5051  TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
5052   /////////////////////////////////////////////////////////////
5053   // Method generating Endcap CoverPlate
5054   /////////////////////////////////////////////////////////////
5055   // Holes Definition
5056   ///////////////////
5057   Int_t nendcapcoverplateholedges = 30;
5058   const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
5059   Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
5060                                                           0.5*fgkEndCapCoverPlateThickness};
5061   TGeoXtru* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
5062                                                                                                               nendcapcoverplateholedges,holesection);
5063   TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
5064                                                                                   endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
5065   endcapcoverplatesmallhole->SetLineColor(6);
5066   TGeoXtru* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
5067                                                                                                               nendcapcoverplateholedges,holesection);
5068   TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
5069                                                                                   endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
5070   endcapcoverplatebighole->SetLineColor(6);
5071   //////////////////////////
5072   // Screw Piece Definition
5073   //////////////////////////
5074   Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
5075   TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
5076                                                                                                       CosD(0.5*smallscrewangle),
5077                                                                                                       0.5*fgkEndCapCoverPlateThickness);
5078   TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
5079                                                                                                 endcapsmallscrewpieceshape,
5080                                                                                                 fSSDCoolingTubePhynox);
5081   endcapsmallscrewpiece->SetLineColor(fColorPhynox);
5082   ///////////////////
5083   // Box Definition
5084   ///////////////////
5085   TGeoBBox* endcapcoverplateboxshape[4];
5086   TGeoVolume* endcapcoverplatebox[4];
5087   Double_t boxorigin[5][3];
5088   boxorigin[0][0] = 0.;
5089   boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
5090   boxorigin[0][2] = 0.;
5091
5092   boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
5093   boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
5094   boxorigin[1][2] = 0.;
5095
5096   boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
5097                                   + fgkEndCapCoverPlateSmallHoleSeparation[1];
5098   boxorigin[2][1] = boxorigin[1][1];
5099   boxorigin[2][2] = 0.;
5100
5101   boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
5102                                   + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
5103   boxorigin[3][1] = boxorigin[1][1];
5104   boxorigin[3][2] = 0.;
5105
5106   endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5107                                                                                 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
5108                                                  -              2.*fgkEndCapCoverPlateSmallHoleRadius),
5109                                                                             0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
5110
5111   endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5112                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
5113                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5114                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
5115                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
5116
5117   endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5118                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
5119                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5120                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
5121                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
5122
5123   endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
5124                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
5125                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5126                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
5127                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
5128
5129   endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
5130                                                                            fSSDAlCoolBlockMedium);
5131   endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
5132                                                                            fSSDAlCoolBlockMedium);
5133   endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
5134                                                                            fSSDAlCoolBlockMedium);
5135   endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
5136                                                                            fSSDAlCoolBlockMedium);
5137   endcapcoverplatebox[0]->SetLineColor(6);
5138   endcapcoverplatebox[1]->SetLineColor(6);
5139   endcapcoverplatebox[2]->SetLineColor(6);
5140   endcapcoverplatebox[3]->SetLineColor(6);
5141   Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
5142   TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5143                                                                                         fgkEndCapCoverPlateSmallHoleRadius,
5144                                                                                         0.5*fgkEndCapCoverPlateThickness,
5145                                                                                         endcapfillingboxorigin);
5146   TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
5147                                                                            fSSDAlCoolBlockMedium);
5148   endcapfillingbox->SetLineColor(6);
5149   ////////////////////////////
5150   // Contour Xtru Definition
5151   ////////////////////////////
5152   const Int_t kcontourvertexnumber = 10;
5153   Double_t xcontourvertex[kcontourvertexnumber];
5154   Double_t ycontourvertex[kcontourvertexnumber];
5155   xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
5156   xcontourvertex[1] = xcontourvertex[0];
5157   xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5158   xcontourvertex[3] = xcontourvertex[2];
5159   xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
5160   xcontourvertex[5] = xcontourvertex[4];
5161   xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5162   xcontourvertex[7] = xcontourvertex[6];
5163   xcontourvertex[8] = xcontourvertex[4];
5164   xcontourvertex[9] = xcontourvertex[8];
5165   ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5166                                         - (kendcapcoverplatesmallholenumber[1]-1)
5167                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5168   ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
5169                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5170   ycontourvertex[2] = ycontourvertex[1];
5171   ycontourvertex[3] = ycontourvertex[0];
5172   ycontourvertex[4] = ycontourvertex[3];
5173   ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
5174   ycontourvertex[6] = ycontourvertex[5];
5175   ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
5176                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]
5177                                         + fgkEndCapCoverPlateSmallHoleRadius;
5178   ycontourvertex[8] = ycontourvertex[7];
5179   ycontourvertex[9] = ycontourvertex[0];
5180   TGeoXtru* contourshape = new TGeoXtru(2);
5181   contourshape->DefinePolygon(kcontourvertexnumber,xcontourvertex,ycontourvertex);
5182   contourshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5183   contourshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5184   TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5185                                                                            fSSDAlCoolBlockMedium);
5186   contour->SetLineColor(6);
5187   /////////////////////////////
5188   // Hole Contour Xtru Definition
5189   ////////////////////////////
5190   const Int_t kholecontourvertexnumber = 10;
5191   Double_t xholecontourvertex[2][kcontourvertexnumber];
5192   Double_t yholecontourvertex[2][kcontourvertexnumber];
5193   xholecontourvertex[0][0] = xcontourvertex[0];
5194   xholecontourvertex[0][1] = xholecontourvertex[0][0];
5195   xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5196   xholecontourvertex[0][3] = xholecontourvertex[0][2];
5197   xholecontourvertex[0][4] = xholecontourvertex[0][0]
5198                                                    + 0.5*(fgkEndCapCoverPlateLength[2]
5199                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5200   xholecontourvertex[0][5] = xholecontourvertex[0][4];
5201   xholecontourvertex[0][6] = xholecontourvertex[0][5]
5202                                                    + 2.*fgkEndCapCoverPlateBigHoleRadius;
5203   xholecontourvertex[0][7] = xholecontourvertex[0][6];
5204   xholecontourvertex[0][8] = xholecontourvertex[0][4];
5205   xholecontourvertex[0][9] = xholecontourvertex[0][8];
5206
5207   yholecontourvertex[0][0] = ycontourvertex[1];
5208   yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5209   yholecontourvertex[0][2] = yholecontourvertex[0][1];
5210   yholecontourvertex[0][3] = yholecontourvertex[0][0];
5211   yholecontourvertex[0][4] = yholecontourvertex[0][3];
5212   yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5213                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5214   yholecontourvertex[0][6] = yholecontourvertex[0][5];
5215   yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5216   yholecontourvertex[0][8] = yholecontourvertex[0][7];
5217   yholecontourvertex[0][9] = yholecontourvertex[0][0];
5218
5219   xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5220   xholecontourvertex[1][1] = xholecontourvertex[1][0];
5221   xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5222   xholecontourvertex[1][3] = xholecontourvertex[1][2];
5223   xholecontourvertex[1][4] = xholecontourvertex[1][0]
5224                                                    + 0.5*(fgkEndCapCoverPlateLength[2]
5225                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5226   xholecontourvertex[1][5] = xholecontourvertex[1][4];
5227   xholecontourvertex[1][6] = xholecontourvertex[1][5]
5228                                                    + 2.*fgkEndCapCoverPlateBigHoleRadius;
5229   xholecontourvertex[1][7] = xholecontourvertex[1][6];
5230   xholecontourvertex[1][8] = xholecontourvertex[1][4];
5231   xholecontourvertex[1][9] = xholecontourvertex[1][8];
5232
5233   yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5234                                                    - fgkEndCapCoverPlateWidth[0]);
5235   yholecontourvertex[1][1] = ycontourvertex[0];
5236   yholecontourvertex[1][2] = yholecontourvertex[1][1];
5237   yholecontourvertex[1][3] = yholecontourvertex[1][0];
5238   yholecontourvertex[1][4] = yholecontourvertex[1][3];
5239   yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5240                                                    - fgkEndCapCoverPlateWidth[0]
5241                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5242   yholecontourvertex[1][6] = yholecontourvertex[1][5];
5243   yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5244   yholecontourvertex[1][8] = yholecontourvertex[1][7];
5245   yholecontourvertex[1][9] = yholecontourvertex[1][0];
5246
5247   TGeoXtru* holecontourshape[2];
5248   holecontourshape[0] = new TGeoXtru(2);
5249   holecontourshape[0]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[0],
5250                                                                   yholecontourvertex[0]);
5251   holecontourshape[0]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5252   holecontourshape[0]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5253
5254   holecontourshape[1] = new TGeoXtru(2);
5255   holecontourshape[1]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[1],
5256                                                                   yholecontourvertex[1]);
5257   holecontourshape[1]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5258   holecontourshape[1]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5259
5260   TGeoVolume* holecontour[2];
5261   holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",holecontourshape[0],
5262                                                                   fSSDAlCoolBlockMedium);
5263   holecontour[0]->SetLineColor(6);
5264   holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",holecontourshape[1],
5265                                                                   fSSDAlCoolBlockMedium);
5266   holecontour[1]->SetLineColor(6);
5267   TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5268                                                                         +     fgkEndCapCoverPlateLength[2],0.,0.);
5269   TGeoTranslation*  bigholetrans[3];
5270   bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5271                                                                                 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5272   bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5273                                   +                     fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5274                                   -                                             fgkEndCapCoverPlateBigHoleRadius,0.0);
5275   bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5276                                                                                 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5277   /////////////////////////////////
5278   // Mother Volume Xtru Definition
5279   /////////////////////////////////
5280   const Int_t kmothervertexnumber = 12;
5281   Double_t xmothervertex[kmothervertexnumber];
5282   Double_t ymothervertex[kmothervertexnumber];
5283   xmothervertex[0]  = xcontourvertex[0];
5284   xmothervertex[1]  = xmothervertex[0];
5285   xmothervertex[2]  = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5286   xmothervertex[3]  = xmothervertex[2];
5287   xmothervertex[4]  = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5288   xmothervertex[5]  = xmothervertex[4];
5289   xmothervertex[6]  = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5290   xmothervertex[7]  = xmothervertex[6];
5291   xmothervertex[8]  = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5292                                         + fgkEndCapCoverPlateLength[2];
5293   xmothervertex[9]  = xmothervertex[8];
5294   xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5295   xmothervertex[11] = xmothervertex[10];
5296
5297   ymothervertex[0]  = ycontourvertex[0];
5298   ymothervertex[1]  = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5299   ymothervertex[2]  = ymothervertex[1];
5300   ymothervertex[3]  = ycontourvertex[1];
5301   ymothervertex[4]  = ymothervertex[3];
5302   ymothervertex[5]  = ymothervertex[1];
5303   ymothervertex[6]  = ymothervertex[5];
5304   ymothervertex[7]  = ymothervertex[0];
5305   ymothervertex[8]  = ymothervertex[7];
5306   ymothervertex[9]  = ymothervertex[8]
5307                                    - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5308   ymothervertex[10] = ymothervertex[9];
5309   ymothervertex[11] = ymothervertex[8];
5310   TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5311   mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5312   mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5313   mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5314   TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5315   ////////////////////////////////////////
5316   // Adding Nodes
5317   ////////////////////////////////////////
5318 //  TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5319   TGeoTranslation*** endcapcoverplatesmallholetrans;
5320   endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5321   Double_t transx[4] = {0,
5322                                                 fgkEndCapCoverPlateSmallHoleSeparation[0],
5323                                                 fgkEndCapCoverPlateSmallHoleSeparation[0]
5324                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1],
5325                                          2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5326                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1]};
5327   Int_t index = 0;
5328   for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5329         endcapcoverplatesmallholetrans[i] =
5330                                         new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5331     for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5332                 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5333             endcapcoverplatesmallholetrans[i][j] =
5334                 new TGeoTranslation(transx[i],
5335                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5336             if(index!=10){
5337                         mothercoverplate->AddNode(endcapcoverplatesmallhole,
5338                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5339                         mothercoverplate->AddNode(endcapsmallscrewpiece,
5340                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5341                 }
5342                 if(j<kendcapcoverplatesmallholenumber[1]-1)
5343                         mothercoverplate->AddNode(endcapcoverplatebox[0],
5344                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5345     }
5346   }
5347   mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5348   mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5349   mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5350   mothercoverplate->AddNode(endcapfillingbox,1);
5351   mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5352   mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5353   mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5354   mothercoverplate->AddNode(holecontour[0],1);
5355   mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5356   mothercoverplate->AddNode(holecontour[1],1);
5357   mothercoverplate->AddNode(contour,1);
5358   /////////////////////////////////
5359   return mothercoverplate;
5360  }
5361  ////////////////////////////////////////////////////////////////////////////////
5362  TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5363   /////////////////////////////////////////////////////////////
5364   // Getting EndCap Cooling Tube
5365   /////////////////////////////////////////////////////////////
5366   TGeoTorus* endcapcoolingtubetorushape[5];
5367   TGeoVolume* endcapcoolingtubetorus[5];
5368   TGeoTube* endcapcoolingtubeshape[4];
5369   TGeoVolume* endcapcoolingtube[4];
5370   char endcapcoolingtubetorusname[30];
5371   char endcapcoolingtubename[30];
5372   TGeoTorus* endcapcoolingwatertubetorushape[5];
5373   TGeoVolume* endcapcoolingwatertubetorus[5];
5374   TGeoTube* endcapcoolingwatertubeshape[4];
5375   TGeoVolume* endcapcoolingwatertube[4];
5376   char endcapcoolingwatertubetorusname[30];
5377   char endcapcoolingwatertubename[30];
5378   for(Int_t i=0; i<5; i++){
5379         sprintf(endcapcoolingtubetorusname,"EndCapCoolingTubeTorus%d",i+1);
5380         sprintf(endcapcoolingtubename,"EndCapCoolingTube%d",i+1);
5381         sprintf(endcapcoolingwatertubetorusname,"EndCapCoolingWaterTubeTorus%d",i+1);
5382         sprintf(endcapcoolingwatertubename,"EndCapCoolingWaterTube%d",i+1);
5383         if(i==3){
5384                 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5385                                                                                 fgkEndCapCoolingTubeRadiusMin,
5386                                                                                 fgkEndCapCoolingTubeRadiusMax,
5387                                                                                 90.0,fgkEndCapCoolingTubeAngle[3]);
5388                 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5389                                                                                 0.,fgkEndCapCoolingTubeRadiusMin,
5390                                                                                 90.0,fgkEndCapCoolingTubeAngle[3]);
5391     }
5392         else{
5393                 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5394                                                                           :fgkEndCapCoolingTubeAxialRadius[1],
5395                                                                            fgkEndCapCoolingTubeRadiusMin,
5396                                                                            fgkEndCapCoolingTubeRadiusMax,
5397                                                                     0.,fgkEndCapCoolingTubeAngle[i]);
5398                 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5399                                                                                :fgkEndCapCoolingTubeAxialRadius[1],
5400                                                                                  0.,fgkEndCapCoolingTubeRadiusMin,
5401                                                                          0.,fgkEndCapCoolingTubeAngle[i]);
5402         }
5403         endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5404                                                                                            endcapcoolingtubetorushape[i],
5405                                                                                            fSSDCoolingTubePhynox);
5406         endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5407                                                                                                         endcapcoolingwatertubetorushape[i],
5408                                                                                                         fSSDCoolingTubeWater);
5409     endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5410     endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5411     if(i<4){
5412                 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5413                                                                   fgkEndCapCoolingTubeRadiusMax,
5414                                                           0.5*fgkEndCapCoolingTubeLength[i]);
5415                 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5416                                                           0.5*fgkEndCapCoolingTubeLength[i]);
5417         endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5418                                                          endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5419         endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5420                                                          endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5421                 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5422                 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5423         }
5424   }
5425   TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5426   /////////////////////////////////////////
5427   // Transformation for Volume Positioning
5428   /////////////////////////////////////////
5429   TGeoCombiTrans* coolingtubecombitrans[6];
5430   TGeoRotation* coolingtuberot[8];
5431   TGeoTranslation* coolingtubetrans[6];
5432   TGeoHMatrix* coolingtubematrix[4];
5433   TGeoCombiTrans* torustubecombitrans[4];
5434   TGeoRotation* torustuberot[7];
5435   TGeoTranslation* torustubetrans[4];
5436   TGeoHMatrix* torustubematrix[5];
5437   TGeoCombiTrans* coolingwatertubecombitrans[6];
5438   TGeoRotation* coolingwatertuberot[8];
5439   TGeoTranslation* coolingwatertubetrans[6];
5440   TGeoHMatrix* coolingwatertubematrix[4];
5441   TGeoCombiTrans* toruswatertubecombitrans[4];
5442   TGeoRotation* toruswatertuberot[7];
5443   TGeoTranslation* toruswatertubetrans[4];
5444   TGeoHMatrix* toruswatertubematrix[5];
5445   for(Int_t i=0; i<8; i++){
5446     if(i<6){
5447          coolingtubetrans[i] = new TGeoTranslation();
5448          coolingwatertubetrans[i] = new TGeoTranslation();
5449     }
5450     if(i<8){
5451          coolingtuberot[i] = new TGeoRotation();
5452          coolingwatertuberot[i] = new TGeoRotation();
5453     }
5454     if(i<4){
5455          torustubetrans[i] = new TGeoTranslation();
5456          toruswatertubetrans[i] = new TGeoTranslation();
5457     }
5458     if(i<7){
5459          torustuberot[i] = new TGeoRotation();
5460          toruswatertuberot[i] = new TGeoRotation();
5461         }
5462   }
5463   /////////////////////////////////////////
5464   // Transformation for Inox Volume Positioning
5465   /////////////////////////////////////////
5466   coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5467                                                                           -endcapcoolingtubeshape[0]->GetDz(),0.);
5468   coolingtuberot[0]->SetAngles(0.,90.,0.);
5469   coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5470                                                                                                 *coolingtuberot[0]);
5471
5472   coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5473   coolingtuberot[1]->SetAngles(0.,90.,0.);
5474   coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5475                                                                                                 *coolingtuberot[1]);
5476
5477   coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5478                                                                          *CosD(fgkEndCapCoolingTubeAngle[0]),
5479                                                                           fgkEndCapCoolingTubeAxialRadius[0]
5480                                                                          *SinD(fgkEndCapCoolingTubeAngle[0]),
5481                                                                           0.);
5482   coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5483   coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5484                                                                                                 *coolingtuberot[2]);
5485
5486   coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5487                                            *                             (*coolingtubecombitrans[1]));
5488
5489   torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5490                                                                          endcapcoolingtubeshape[1]->GetDz());
5491   torustuberot[0]->SetAngles(0.,90.,0.);
5492   torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5493
5494   torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5495
5496   coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5497                                                                           -endcapcoolingtubeshape[2]->GetDz(),0.);
5498   coolingtuberot[3]->SetAngles(0.,90.,0.);
5499   coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5500                                                                                                 *coolingtuberot[3]);
5501   coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5502   coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5503   coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5504
5505   torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5506                                                                         endcapcoolingtubeshape[2]->GetDz());
5507   torustuberot[1]->SetAngles(0.,90.,0.);
5508   torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5509   torustuberot[2]->SetAngles(180.,0.,0.);
5510   torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5511   torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5512
5513   torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5514                                                                         -fgkEndCapCoolingTubeAxialRadius[0]);
5515   torustuberot[3]->SetAngles(0.,90.,0.);
5516   torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5517   torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5518   torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5519   torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5520
5521   coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5522                                                                           fgkEndCapCoolingTubeAxialRadius[0],0.);
5523   coolingtuberot[5]->SetAngles(90.,90.,-90.);
5524   coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5525                                                                                                 *coolingtuberot[5]);
5526   coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5527   coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5528   coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5529
5530   torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5531                                                                         endcapcoolingtubeshape[0]->GetDz());
5532   torustuberot[5]->SetAngles(0.,90.,0.);
5533   torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5534   torustuberot[6]->SetAngles(-90.,0.,0.);
5535   torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5536   torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5537
5538   coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5539                                                                           endcapcoolingtubeshape[3]->GetDz(),0.);
5540   coolingtuberot[6]->SetAngles(0.,90.,0.);
5541   coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5542                                                                                                 *coolingtuberot[6]);
5543   coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5544   coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5545   coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5546     /////////////////////////////////////////
5547   // Transformation for Water Volume Positioning
5548   /////////////////////////////////////////
5549   coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5550                                                                           -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5551   coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5552   coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5553                                                                                                      *coolingwatertuberot[0]);
5554
5555   coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5556   coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5557   coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5558                                                                                                      *coolingwatertuberot[1]);
5559
5560   coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5561                                                                                   *CosD(fgkEndCapCoolingTubeAngle[0]),
5562                                                                                   fgkEndCapCoolingTubeAxialRadius[0]
5563                                                                                   *SinD(fgkEndCapCoolingTubeAngle[0]),
5564                                                                               0.);
5565   coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5566   coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5567                                                                                                     *coolingwatertuberot[2]);
5568
5569   coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5570                                            *                                 (*coolingwatertubecombitrans[1]));
5571
5572   toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5573                                                                          endcapcoolingwatertubeshape[1]->GetDz());
5574   toruswatertuberot[0]->SetAngles(0.,90.,0.);
5575   toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5576                                                                                                    *toruswatertuberot[0]);
5577
5578   toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5579                                                   *                                     (*toruswatertubecombitrans[0]));
5580
5581   coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5582                                                                           -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5583   coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5584   coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5585                                                                                                      *coolingwatertuberot[3]);
5586   coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5587   coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5588                                                         *                                 (*coolingwatertubecombitrans[3]));
5589   coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5590
5591   toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5592                                                                         endcapcoolingwatertubeshape[2]->GetDz());
5593   toruswatertuberot[1]->SetAngles(0.,90.,0.);
5594   toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5595                                                                                                    *toruswatertuberot[1]);
5596   toruswatertuberot[2]->SetAngles(180.,0.,0.);
5597   toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5598                                                   *                 (*toruswatertubecombitrans[1]));
5599   toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5600
5601   toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5602                                                                                    -fgkEndCapCoolingTubeAxialRadius[0]);
5603   toruswatertuberot[3]->SetAngles(0.,90.,0.);
5604   toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5605                                                                                                    *toruswatertuberot[3]);
5606   toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5607   toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5608                                                   *                                     (*toruswatertubecombitrans[2]));
5609   toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5610
5611   coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5612                                                                                 fgkEndCapCoolingTubeAxialRadius[0],0.);
5613   coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5614   coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5615                                                                                                      *coolingwatertuberot[5]);
5616   coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5617   coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5618                                                         *                                 (*coolingwatertubecombitrans[4]));
5619   coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5620
5621   toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5622                                                                               endcapcoolingwatertubeshape[0]->GetDz());
5623   toruswatertuberot[5]->SetAngles(0.,90.,0.);
5624   toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5625                                                                                                    *toruswatertuberot[5]);
5626   toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5627   toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5628                                                   *                 (*toruswatertubecombitrans[3]));
5629   toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5630
5631   coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5632                                                                           endcapcoolingwatertubeshape[3]->GetDz(),0.);
5633   coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5634   coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5635                                                                                                      *coolingwatertuberot[6]);
5636   coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5637   coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5638                                                         *                                 (*coolingwatertubecombitrans[5]));
5639   coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5640   /////////////////////////////////////////
5641   // Positioning Volumes
5642   /////////////////////////////////////////
5643   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5644   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5645
5646   endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5647   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5648
5649   endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5650   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5651
5652   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5653   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5654
5655   endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5656   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5657
5658   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5659   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5660
5661   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5662   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5663
5664   endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5665   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5666
5667   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5668   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5669
5670   endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5671   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5672   /////////////////////////////////////////////////////////////
5673   // Deallocating memory
5674   /////////////////////////////////////////////////////////////
5675   for(Int_t i=0; i<8; i++){
5676     if(i<6){
5677          delete coolingtubetrans[i];
5678          delete coolingwatertubetrans[i];
5679          if(i!=0){
5680           delete coolingtubecombitrans[i];
5681           delete coolingwatertubecombitrans[i];
5682          }
5683         }
5684     if(i<8){
5685           delete coolingtuberot[i];
5686           delete coolingwatertuberot[i];
5687     }
5688     if(i<4){
5689                 delete torustubetrans[i];
5690                 delete toruswatertubetrans[i];
5691                 delete torustubecombitrans[i];
5692                 delete toruswatertubecombitrans[i];
5693         }
5694     if(i<7){
5695          delete torustuberot[i];
5696          delete toruswatertuberot[i];
5697         }
5698   }
5699   /////////////////////////////////////////////////////////////
5700   return endcapcoolingtubemother;
5701  }
5702  ////////////////////////////////////////////////////////////////////////////////
5703  TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5704   /////////////////////////////////////////////////////////////
5705   // Getting EndCap Cover Side
5706   /////////////////////////////////////////////////////////////
5707   const Int_t kendcapcoverholenumber[2] = {7,5};
5708   const Int_t kvertexnumber = 15;
5709   Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5710   xvertex[0]  = 0.0;
5711   xvertex[1]  = xvertex[0];
5712   xvertex[2]  = fgkEndCapSideCoverLength[0];
5713   xvertex[3]  = fgkEndCapSideCoverLength[1];
5714   xvertex[4]  = xvertex[3];
5715   xvertex[5]  = fgkEndCapSideCoverLength[2];
5716   xvertex[6]  = xvertex[5];
5717   xvertex[7]  = xvertex[2];
5718   xvertex[8]  = xvertex[7];
5719   xvertex[9]  = xvertex[6]-fgkEndCapSideCoverLength[0];
5720   xvertex[10] = xvertex[9];
5721   xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5722                           * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5723                           * fgkEndCapSideCoverLength[4];
5724   xvertex[12] = xvertex[11];
5725   xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5726                           * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5727                           * fgkEndCapSideCoverLength[4];
5728   xvertex[14] = xvertex[13];
5729   yvertex[0]  = 0.0;
5730   yvertex[1]  = fgkEndCapSideCoverWidth[0];
5731   yvertex[2]  = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5732   yvertex[3]  = yvertex[2];
5733   yvertex[4]  = fgkEndCapSideCoverWidth[1];
5734   yvertex[5]  = yvertex[4];
5735   yvertex[6]  = yvertex[0];
5736   yvertex[7]  = yvertex[6];
5737   yvertex[8]  = fgkEndCapSideCoverWidth[6];
5738   yvertex[9]  = yvertex[8];
5739   yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5740   yvertex[11] = yvertex[10];
5741   yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5742   yvertex[13] = yvertex[12];
5743   yvertex[14] = yvertex[6];
5744   TGeoXtru* endcapsidecovershape = new TGeoXtru(2);
5745   endcapsidecovershape->DefinePolygon(kvertexnumber,xvertex,yvertex);
5746   endcapsidecovershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5747   endcapsidecovershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5748   TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5749                                                                 endcapsidecovershape,fSSDCoolingTubePhynox);
5750   endcapsidecover->SetLineColor(fColorPhynox);
5751   ////////////////////////////////////////////
5752   // Defininition of Mother Volume
5753   ////////////////////////////////////////////
5754   const Int_t kmothervertexnumber = 7;
5755   Double_t xmothervertex[kmothervertexnumber];
5756   Double_t ymothervertex[kmothervertexnumber];
5757   for(Int_t i=0; i<kmothervertexnumber; i++){
5758         xmothervertex[i] = xvertex[i];
5759         ymothervertex[i] = yvertex[i];
5760   }
5761   TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5762   endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5763   endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5764   endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5765   TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5766                                                                 endcapsidecovermothershape,fSSDAir);
5767   ////////////////////////////////////////////
5768   endcapsidecovermother->AddNode(endcapsidecover,1);
5769   TGeoBBox* endcapsidecoverboxshape[4];
5770   endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5771                                                          +     (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5772                                                                0.5*fgkEndCapSideCoverLength[4],
5773                                                                    0.5*fgkEndCapSideCoverThickness);
5774   endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5775                                                          +     (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5776                                                                0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5777                                                          -     fgkEndCapSideCoverLength[4]),
5778                                                                    0.5*fgkEndCapSideCoverThickness);
5779   endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5780                                                                0.5*fgkEndCapSideCoverLength[4],
5781                                                                    0.5*fgkEndCapSideCoverThickness);
5782   endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5783                                                                0.5*fgkEndCapSideCoverWidth[5],
5784                                                                    0.5*fgkEndCapSideCoverThickness);
5785   TGeoVolume* endcapsidecoverbox[4];
5786   endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5787   endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5788   endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5789   endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5790   for(Int_t i=0; i<4; i++)   endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5791 //  TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5792   TGeoTranslation** endcapsidecoverboxtrans;
5793   endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5794   endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5795                                                          +                                         fgkEndCapSideCoverLength[0],
5796                                                                                                    endcapsidecoverboxshape[0]->GetDY()
5797                                                          +                     yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5798   endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5799                                                          +                     xvertex[11],
5800                                                                                                    endcapsidecoverboxshape[1]->GetDY()
5801                                                          +                     yvertex[12],0.);
5802   endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5803                                                          +                     xvertex[11],
5804                                                                                                    endcapsidecoverboxshape[2]->GetDY()
5805                                                          +                     yvertex[12]
5806                                                          +                                         2.*endcapsidecoverboxshape[1]->GetDY()
5807                                                          +                     fgkEndCapSideCoverWidth[5],0.);
5808   endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5809   endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5810   endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5811   for(Int_t i=0; i<2; i++)
5812         for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5813                 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5814                         new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5815                                                                 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5816                                                                 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5817                                                                 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5818                 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5819                                                                 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5820         }
5821   for(Int_t i=0; i<2; i++)
5822         for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5823                 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5824                 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5825                                                         +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5826                                                         endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5827                                                         +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5828                                                         +fgkEndCapSideCoverLength[4]),0.0);
5829                 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5830                                                                 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5831                                                                 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5832                                                                 +i*(kendcapcoverholenumber[1]-1)+j]);
5833         }
5834         return endcapsidecovermother;
5835  }
5836  ////////////////////////////////////////////////////////////////////////////////
5837  TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5838  ////////////////////////////////////////////////////////////////////////////////
5839  // Method returning Interface Card A, Interface Card B, Supply Card
5840  ////////////////////////////////////////////////////////////////////////////////
5841  /////////////////////
5842  // Supply Card
5843  /////////////////////
5844  // Electronic Board Back Al Plane
5845  const Int_t kelectboardbackvertexnumber = 8;
5846  Double_t xelectboardback[kelectboardbackvertexnumber];
5847  Double_t yelectboardback[kelectboardbackvertexnumber];
5848  xelectboardback[0] = 0.0;
5849  xelectboardback[1] = xelectboardback[0];
5850  xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5851  xelectboardback[3] = xelectboardback[2];
5852  xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5853  xelectboardback[5] = xelectboardback[4];
5854  xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5855  xelectboardback[7] = xelectboardback[6];
5856
5857  yelectboardback[0] = 0.0;
5858  yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5859  yelectboardback[2] = yelectboardback[1];
5860  yelectboardback[3] = yelectboardback[0];
5861  yelectboardback[4] = yelectboardback[3];
5862  yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5863  yelectboardback[6] = yelectboardback[5];
5864  yelectboardback[7] = yelectboardback[4];
5865  TGeoXtru* electboardbackshape = new TGeoXtru(2);
5866  electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5867                                                                         xelectboardback,yelectboardback);
5868  electboardbackshape->DefineSection(0,0.0);
5869  electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5870  TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5871                                                                                          electboardbackshape,fSSDSupportRingAl);
5872  electboardback->SetLineColor(fColorAl);
5873  // Electronic Board Kapton Layer
5874  const Int_t kelectlayervertexnumber = 8;
5875  Double_t xelectlayer[kelectlayervertexnumber];
5876  Double_t yelectlayer[kelectlayervertexnumber];
5877  xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5878  xelectlayer[1] = xelectlayer[0];
5879  xelectlayer[2] = fgkEndCapCardElectBoardLength;
5880  xelectlayer[3] = xelectlayer[2];
5881  for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5882
5883  yelectlayer[0] = 0.0;
5884  yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5885  yelectlayer[2] = yelectlayer[1];
5886  yelectlayer[3] = yelectlayer[0];
5887  yelectlayer[4] = yelectlayer[3];
5888  yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5889  yelectlayer[6] = yelectlayer[5];
5890  yelectlayer[7] = yelectlayer[4];
5891  TGeoXtru* electlayershape = new TGeoXtru(2);
5892  electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5893  electlayershape->DefineSection(0,0.0);
5894  electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5895  TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5896                                                                                          electlayershape,fSSDKaptonFlexMedium);
5897  electlayer->SetLineColor(fColorKapton);
5898  // JMD Connector Female
5899  const Int_t kjmdconnectorvertexnumber = 6;
5900  Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5901  Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5902  xjmdconnectorvertex[0] = 0.0;
5903  xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5904  xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5905  xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5906  xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5907  xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5908
5909  yjmdconnectorvertex[0] = 0.0;
5910  yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5911  yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5912  yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5913  yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5914  yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5915  TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5916  jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5917                                                                   yjmdconnectorvertex);
5918  jmdconnectorshape->DefineSection(0,0.0);
5919  jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
5920  TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
5921                                                                                    jmdconnectorshape,fSSDMountingBlockMedium);
5922  jmdconnector->SetLineColor(fColorG10);
5923  // Top Cable Connector
5924  const Int_t kcableconnectorvertexnumber = 8;
5925  Double_t xconnectorvertex[kcableconnectorvertexnumber];
5926  Double_t yconnectorvertex[kcableconnectorvertexnumber];
5927  xconnectorvertex[0] = 0.0;
5928  xconnectorvertex[1] = xconnectorvertex[0];
5929  xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
5930  xconnectorvertex[3] = xconnectorvertex[2];
5931  xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
5932                                          - fgkEndCapCardCableConnectorLength[2];
5933  xconnectorvertex[5] = xconnectorvertex[4];
5934  xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
5935  xconnectorvertex[7] = xconnectorvertex[6];
5936
5937  yconnectorvertex[0] = 0.0;
5938  yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
5939  yconnectorvertex[2] = yconnectorvertex[1];
5940  yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
5941  yconnectorvertex[4] = yconnectorvertex[3];
5942  yconnectorvertex[5] = yconnectorvertex[1];
5943  yconnectorvertex[6] = yconnectorvertex[5];
5944  yconnectorvertex[7] = yconnectorvertex[0];
5945  TGeoXtru* cableconnectorshape = new TGeoXtru(2);
5946  cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
5947                                                                     yconnectorvertex);
5948  cableconnectorshape->DefineSection(0,0.0);
5949  cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
5950  TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
5951                                                                                    cableconnectorshape,fSSDMountingBlockMedium);
5952  cableconnector->SetLineColor(fColorG10);
5953  // Strip Connection
5954  TGeoBBox* endcapstripconnectionshape =
5955                                                                 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
5956                                                                                          0.5*fgkEndCapStripConnectionThickness,
5957                                                                                          0.5*fgkEndCapStripConnectionWidth);
5958  TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
5959                                                                                                         endcapstripconnectionshape,
5960                                                                                                         fSSDSupportRingAl);
5961  endcapstripconnection->SetLineColor(fColorAl);
5962  // Interface Card B
5963  const Int_t kcardBvertexnumber = 12;
5964  Double_t xcardBvertexnumber[kcardBvertexnumber];
5965  Double_t ycardBvertexnumber[kcardBvertexnumber];
5966
5967  xcardBvertexnumber[0]  = 0.0;
5968  xcardBvertexnumber[1]  = xcardBvertexnumber[0];
5969  xcardBvertexnumber[2]  = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
5970  xcardBvertexnumber[3]  = xcardBvertexnumber[2];
5971  xcardBvertexnumber[4]  = xcardBvertexnumber[1];
5972  xcardBvertexnumber[5]  = xcardBvertexnumber[4];
5973  xcardBvertexnumber[6]  = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
5974  xcardBvertexnumber[7]  = xcardBvertexnumber[6];
5975  xcardBvertexnumber[8]  = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
5976  xcardBvertexnumber[9]  = xcardBvertexnumber[8];
5977  xcardBvertexnumber[10] = xcardBvertexnumber[7];
5978  xcardBvertexnumber[11] = xcardBvertexnumber[10];
5979
5980  ycardBvertexnumber[0]  = 0.0;
5981  ycardBvertexnumber[1]  = fgkEndCapInterfaceCardBWidth[0];
5982  ycardBvertexnumber[2]  = ycardBvertexnumber[1];
5983  ycardBvertexnumber[3]  = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
5984  ycardBvertexnumber[4]  = ycardBvertexnumber[3];
5985  ycardBvertexnumber[5]  = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
5986  ycardBvertexnumber[6]  = ycardBvertexnumber[5];
5987  ycardBvertexnumber[7]  = ycardBvertexnumber[4];
5988  ycardBvertexnumber[8]  = ycardBvertexnumber[7];
5989  ycardBvertexnumber[9]  = ycardBvertexnumber[1];
5990  ycardBvertexnumber[10] = ycardBvertexnumber[9];
5991  ycardBvertexnumber[11] = ycardBvertexnumber[0];
5992
5993  TGeoXtru* interfacecardBshape = new TGeoXtru(2);
5994  interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
5995  interfacecardBshape->DefineSection(0,0.);
5996  interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
5997  TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
5998                                                                                          fSSDMountingBlockMedium);
5999  interfacecardB->SetLineColor(46);
6000  // Interface Card B Electronic Board
6001  const Int_t kelectboardcardBvertexnumber = 14;
6002  Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
6003  Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
6004
6005  xelectboardcardBvertex[0]  = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
6006  xelectboardcardBvertex[1]  = xelectboardcardBvertex[0];
6007  xelectboardcardBvertex[2]  = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
6008  xelectboardcardBvertex[3]  = xelectboardcardBvertex[2];
6009  xelectboardcardBvertex[4]  = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
6010  xelectboardcardBvertex[5]  = xelectboardcardBvertex[4];
6011  xelectboardcardBvertex[6]  = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
6012  xelectboardcardBvertex[7]  = xelectboardcardBvertex[6];
6013  xelectboardcardBvertex[8]  = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
6014  xelectboardcardBvertex[9]  = xelectboardcardBvertex[8];
6015  xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
6016  xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
6017  xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
6018  xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
6019
6020  yelectboardcardBvertex[0]  = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
6021  yelectboardcardBvertex[1]  = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
6022  yelectboardcardBvertex[2]  = yelectboardcardBvertex[1];
6023  yelectboardcardBvertex[3]  = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
6024  yelectboardcardBvertex[4]  = yelectboardcardBvertex[3];
6025  yelectboardcardBvertex[5]  = yelectboardcardBvertex[2];
6026  yelectboardcardBvertex[6]  = yelectboardcardBvertex[5];
6027  yelectboardcardBvertex[7]  = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
6028  yelectboardcardBvertex[8]  = yelectboardcardBvertex[7];
6029  yelectboardcardBvertex[9]  = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
6030  yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
6031  yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
6032  yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
6033  yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
6034
6035  TGeoXtru* electboardcardBshape = new TGeoXtru(2);
6036  electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
6037                                                                          xelectboardcardBvertex,yelectboardcardBvertex);
6038  electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
6039  electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
6040                                                                          + fgkEndCapInterfaceElectBoardCardBThickness);
6041  TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
6042                                                                                           fSSDSupportRingAl);
6043  electboardcardB->SetLineColor(fColorAl);
6044  // Generating Stiffener 2
6045  TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
6046                                                                                            0.5*fgkEndCapStiffenerThickness,
6047                                                                                            0.5*fgkEndCapStiffenerLength);
6048  TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
6049  endcapstiffener->SetLineColor(fColorAl);
6050  // Generating Mother Interface Card B Container
6051  const Int_t kinterfacecardBmothervertexnumber = 10;
6052  Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6053  Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6054
6055  xinterfacecardBmothervertex[0] = 0.0;
6056  xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
6057  xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
6058                                                                 + fgkEndCapInterfaceCardBThickness;
6059  xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
6060  xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
6061                                                                 + fgkEndCapInterfaceElectBoardCardBThickness;
6062  xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
6063  xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
6064  xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
6065  xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
6066                                                                 + fgkEndCapCardJMDConnectorLength[0];
6067  xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
6068
6069  yinterfacecardBmothervertex[0] = 0.0;
6070  yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
6071                                                                 + fgkEndCapInterfaceCardBWidth[1]
6072                                                                 + fgkEndCapInterfaceCardBWidth[2];
6073  yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
6074  yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
6075  yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
6076  yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
6077  yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
6078  yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
6079                                                                 + fgkEndCapCardJMDConnectorWidth[0]
6080                                                                 + fgkEndCapCardJMDConnectorWidth[1];
6081  yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
6082  yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
6083  TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
6084  interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
6085                                                                                   xinterfacecardBmothervertex,
6086                                                                                   yinterfacecardBmothervertex);
6087  interfacecardBmothershape->DefineSection(0,-1.e-15);
6088  interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
6089  TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
6090                                                                                                    interfacecardBmothershape,fSSDAir);
6091  electboardcardB->SetLineColor(fColorAl);
6092  // Positioning Volumes Mother Interface Card B Container
6093  TGeoRotation* interfacecardBrot = new TGeoRotation();
6094  TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
6095  interfacecardBrot->SetAngles(90.,-90.,-90.);
6096  interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
6097  TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
6098  TGeoRotation* electboardcardBrot = new TGeoRotation();
6099  TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
6100  electboardcardBrot->SetAngles(90.,90.,-90.);
6101  electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
6102  TGeoCombiTrans* electboardcardBcombitrans =
6103                                   new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6104  interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6105  interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6106  TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6107  jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6108  TGeoTranslation* jmdconnectorcardBtrans[3];
6109  TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6110  for(Int_t i=0; i<3; i++){
6111    jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6112                                                          + fgkEndCapCardJMDConnectorLength[0],
6113                                                            fgkEndCapCardElectBoardLayerWidth[1],
6114                                                            0.5*fgkEndCapCardJMDConnectorThickness
6115                                                          + 0.5*(fgkEndCapInterfaceCardBLength[1]
6116                                                          - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6117                                                          + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6118    jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6119                                                                                                            *jmdconnectorcardBrot);
6120    interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6121  }
6122  // Mother Supply Card Container
6123  TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6124  // Interface Card Container
6125  TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6126  // Placing Volumes in Mother Supply Card Container
6127  // JMD Connector Positioning
6128  TGeoTranslation* jmdconnectortrans[2];
6129  for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6130  jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6131                                                                                         fgkEndCapCardElectBoardBackLength[0]
6132                                           -                                             fgkEndCapCardJMDConnectorThickness
6133                                           -                                             fgkEndCapCardJMDConnectorToLayer);
6134  TGeoRotation* jmdconnectorot = new TGeoRotation();
6135  jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6136                                                                  + 2.*fgkEndCapCardJMDConnectorLength[0]
6137                                                                  + 2.*fgkEndCapCardElectBoardLayerThickness,
6138                                                                           fgkEndCapCardElectBoardLayerWidth[1],
6139                                                                       fgkEndCapCardJMDConnectorThickness
6140                                                                  +    fgkEndCapCardJMDConnectorToLayer);
6141  jmdconnectorot->SetAngles(90.,180.,-90);
6142  TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6143                                                                                 * jmdconnectorot);
6144  mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6145  mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6146  // Top Cable Connector Placing
6147  TGeoRotation* cableconnectorot[2];
6148  for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6149  TGeoTranslation* cableconnectortrans[3];
6150  for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6151  cableconnectorot[0]->SetAngles(90.,0.,0.);
6152  cableconnectorot[1]->SetAngles(0.,-90.,0.);
6153  cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6154  TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6155                                                                                                                            *cableconnectorot[0]);
6156  TGeoHMatrix* cableconnectormatrix[2];
6157  for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6158                                                         new TGeoHMatrix((*cableconnectorot[1])
6159                                                                                    *(*cableconnectorcombitrans));
6160  cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6161                                            -                               fgkEndCapCardCableConnectorThickness,
6162                                                                                 fgkEndCapCardCableConnectorLength[0]
6163                                            +                            fgkEndCapCardCableConnectorToLayer);
6164  cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6165                                            -                2.*fgkEndCapCardCableConnectorThickness
6166                                            -                            fgkEndCapCardCableConnectorDistance,
6167                                                                                 fgkEndCapCardCableConnectorLength[0]
6168                                            +                            fgkEndCapCardCableConnectorToLayer);
6169  for(Int_t i=0; i<2; i++){
6170         cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6171     mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6172  }
6173  TGeoRotation* electboardbackrot = new TGeoRotation();
6174  TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6175  electboardbackrot->SetAngles(90.,-90.,-90.);
6176  electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6177                                                         +                fgkEndCapCardJMDConnectorLength[0]
6178                                                         +                fgkEndCapCardElectBoardLayerThickness,0.,0.);
6179  TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6180                                                                                                                            *electboardbackrot);
6181  mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6182  // Electronic Board Kapton Layer Positioning
6183  TGeoRotation* electlayerrot = new TGeoRotation();
6184  TGeoTranslation* electlayertrans[2];
6185  TGeoCombiTrans* electlayercombitrans[2];
6186  for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6187  electlayerrot->SetAngles(90.,-90.,-90.);
6188  electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6189                                                                  + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6190  electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6191                                                                  + 2.*fgkEndCapCardElectBoardLayerThickness
6192                                                                  + fgkEndCapCardElectBoardBackThickness,0.,0.);
6193  for(Int_t i=0; i<2; i++){
6194         electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6195         mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6196  }
6197  // Placing Volumes in Mother Interface Card Container
6198  motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6199  motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6200  for(Int_t i=0; i<2; i++){
6201         motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6202  }
6203  /////////////////////////////////////////////////////////////
6204  // Generation of Card Interface Container
6205  /////////////////////////////////////////////////////////////
6206  Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6207                                                   - fgkEndCapCardJMDConnectorLength[0]
6208                                                   - fgkEndCapInterfaceCardBThickness
6209                                                   - 9.*fgkEndCapStripConnectionThickness
6210                                                   - 8.*fgkEndCapCardElectBoardBackThickness;
6211  const Int_t kcardinterfacecontainervertexnumber = 14;
6212  Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6213  Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6214  xcardinterfacecontainervertex[0]  =-6.5*fgkEndCapCardElectBoardBackThickness
6215                                                                    - 7.0*fgkEndCapStripConnectionThickness;
6216  xcardinterfacecontainervertex[1]  = xcardinterfacecontainervertex[0];
6217  xcardinterfacecontainervertex[2]  = xcardinterfacecontainervertex[1]
6218                                                                    + fgkEndCapStripConnectionThickness
6219                                                                    - fgkEndCapCardElectBoardLayerThickness
6220                                                                    - fgkEndCapCardCableConnectorWidth[0];
6221  xcardinterfacecontainervertex[3]  = xcardinterfacecontainervertex[2];
6222  xcardinterfacecontainervertex[4]  = xcardinterfacecontainervertex[1];
6223  xcardinterfacecontainervertex[5]  = xcardinterfacecontainervertex[4];
6224  xcardinterfacecontainervertex[6]  = 1.5*fgkEndCapCardElectBoardBackThickness
6225                                                                    + 2.0*fgkEndCapStripConnectionThickness;
6226  xcardinterfacecontainervertex[7]  = xcardinterfacecontainervertex[6];
6227  xcardinterfacecontainervertex[8]  = xcardinterfacecontainervertex[7]
6228                                                                    + fgkEndCapInterfaceCardBThickness;
6229  xcardinterfacecontainervertex[9]  = xcardinterfacecontainervertex[8];
6230  xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6231                                                                    + fgkEndCapInterfaceElectBoardCardBThickness;
6232  xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6233  xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6234                                    - fgkEndCapInterfaceElectBoardCardBThickness
6235                                                                    + fgkEndCapCardJMDConnectorLength[0]
6236                                                                    + stiffenertransx+fgkEndCapStiffenerWidth;
6237  xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6238
6239  ycardinterfacecontainervertex[0]  = 0.;
6240  ycardinterfacecontainervertex[1]  = fgkEndCapCardElectBoardLayerWidth[1]
6241                                                                    + fgkEndCapCardJMDConnectorWidth[0]
6242                                                                    + fgkEndCapCardJMDConnectorWidth[1];
6243  ycardinterfacecontainervertex[2]  = ycardinterfacecontainervertex[1];
6244  ycardinterfacecontainervertex[3]  = fgkEndCapCardElectBoardBackWidth[0]
6245                                                                    - fgkEndCapStripConnectionWidth;
6246  ycardinterfacecontainervertex[4]  = ycardinterfacecontainervertex[3];
6247  ycardinterfacecontainervertex[5]  = fgkEndCapCardElectBoardBackWidth[0];
6248  ycardinterfacecontainervertex[6]  = ycardinterfacecontainervertex[5];
6249  ycardinterfacecontainervertex[7]  = fgkEndCapInterfaceCardBWidth[0]
6250                                                                    + fgkEndCapInterfaceCardBWidth[1]
6251                                                                    + fgkEndCapInterfaceCardBWidth[2];
6252  ycardinterfacecontainervertex[8]  = ycardinterfacecontainervertex[7];
6253  ycardinterfacecontainervertex[9]  = yelectboardcardBvertex[3];
6254  ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6255  ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6256  ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6257  ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6258
6259  TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6260  interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6261                                                                                   xcardinterfacecontainervertex,
6262                                                                                   ycardinterfacecontainervertex);
6263  interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6264                                                                            -    fgkEndCapCardElectBoardBackLength[0]));
6265  interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6266                                                                            +    fgkEndCapCardElectBoardBackLength[0]));
6267  TGeoVolume** cardinterfacecontainer;
6268  cardinterfacecontainer = new TGeoVolume*[4];
6269  cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6270                                                                                         interfacecardmothershape,fSSDAir);
6271  cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6272                                                                                         interfacecardmothershape,fSSDAir);
6273  cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6274                                                                                         interfacecardmothershape,fSSDAir);
6275  cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6276                                                                                         interfacecardmothershape,fSSDAir);
6277  /////////////////////////////////
6278  // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6279  // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6280  // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6281  // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6282  /////////////////////////////////
6283  TGeoRotation* endcapstripconnectionrot[2];
6284  for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6285  endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6286  endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6287  TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6288                                                                         *                                 (*endcapstripconnectionrot[0]));
6289  TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6290  endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6291                                                                                         -0.5*fgkEndCapCardElectBoardBackThickness,
6292                                                                                          fgkEndCapCardElectBoardBackWidth[0]
6293                                                                                         -endcapstripconnectionshape->GetDZ(),
6294                                                                                          0.5*fgkEndCapCardElectBoardBackLength[0]);
6295  endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6296  TGeoTranslation* cardinterfacetrans[9];
6297  TGeoHMatrix* cardinterfacematrix[9];
6298  for(Int_t i=0; i<7; i++){
6299         cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6300                                                   +                                                     fgkEndCapCardElectBoardBackThickness),
6301                                                                                                 0.0,0.0);
6302         cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6303                                                    *                             (*endcapstripconnectionmatrix));
6304  }
6305  cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6306                                                   +                                             fgkEndCapCardElectBoardBackThickness),
6307                                                                                                 0.0,0.0);
6308  cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6309                                                 *                                 (*endcapstripconnectionmatrix));
6310  cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6311                                                   +                                             fgkEndCapCardElectBoardBackThickness),
6312                                                                                                 0.0,0.0);
6313  cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6314                                                 *                                 (*endcapstripconnectionmatrix));
6315
6316  for(Int_t i=0; i<4; i++){
6317         cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6318                                                                            cardinterfacematrix[7]);
6319         cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6320                                                                            cardinterfacematrix[8]);
6321  }
6322  TGeoTranslation* mothersupplycardtrans =
6323                                         new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6324                                                                                 + 2.*fgkEndCapCardJMDConnectorLength[0]
6325                                                                                 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6326  TGeoHMatrix* mothersupplycardmatrix[7];
6327  Int_t index[4] = {1,1,1,1};
6328  for(Int_t i=0; i<7; i++){
6329         mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6330                                                         *                                 (*mothersupplycardtrans));
6331         for(Int_t j=0; j<4; j++){
6332                 switch(j){
6333                         case 0: //Layer5 EndCap Left Side
6334                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6335                                                                                                    cardinterfacematrix[i]);
6336                                 if(i!=0){
6337                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6338                                                                                                            mothersupplycardmatrix[i]);
6339                                         index[j]++;
6340
6341                                 }
6342                         break;
6343                         case 1: //Layer5 EndCap Rigth Side
6344                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6345                                                                                                    cardinterfacematrix[i]);
6346                                 if(i>0&&i<6){
6347                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6348                                                                                                            mothersupplycardmatrix[i]);
6349                                         index[j]++;
6350                                 }
6351                         break;
6352                         case 2: //Layer6 EndCap Left Side
6353                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6354                                                                                                    cardinterfacematrix[i]);
6355                                 if(i!=6){
6356                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6357                                                                                                            mothersupplycardmatrix[i]);
6358                                         index[j]++;
6359                                 }
6360                         break;
6361                         case 3: //Layer6 EndCap Right Side
6362                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6363                                                                                                    cardinterfacematrix[i]);
6364                                 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6365                                                                                                    mothersupplycardmatrix[i]);
6366                                 index[j]++;
6367                         break;
6368                 }
6369         }
6370  }
6371  // Positioning Interface
6372  TGeoTranslation* motherinterfacecardtrans =
6373                 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6374                                                          +0.5*fgkEndCapCardElectBoardBackThickness
6375                                                          -fgkEndCapCardElectBoardLayerThickness
6376                                                          +fgkEndCapStripConnectionThickness,0.,0.);
6377  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6378                                         motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6379  // Positioning Interface Card B
6380  TGeoTranslation* interfacecardBmothertrans =
6381                                         new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6382                                                                                 + 2.*fgkEndCapStripConnectionThickness
6383                                                                                         + fgkEndCapCardElectBoardBackThickness,0.,
6384                                                                            -0.5 * (fgkEndCapInterfaceCardBLength[1]
6385                                                                                         -  fgkEndCapCardElectBoardBackLength[0]));
6386  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6387                                                                                                                          interfacecardBmothertrans);
6388  // Positioning Stiffener
6389  TGeoTranslation* endcapstiffenertrans =
6390                                                 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6391                                                                            +    2.0*fgkEndCapStripConnectionThickness
6392                                                                            +    fgkEndCapInterfaceCardBThickness
6393                                                                            +    fgkEndCapCardJMDConnectorLength[0]
6394                                                                            +    stiffenertransx
6395                                                                            +    endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6396                                                                                         endcapstiffenershape->GetDZ()
6397                                                                            -    0.5*(fgkEndCapStiffenerLength
6398                                                                            -    fgkEndCapCardElectBoardBackLength[0]));
6399  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6400  /////////////////////////////////////////////////////////////
6401  // Deallocating memory
6402  /////////////////////////////////////////////////////////////
6403  delete interfacecardBrot;
6404  delete interfacecardBtrans;
6405  delete electboardcardBtrans;
6406  delete electboardcardBrot;
6407  delete jmdconnectorcardBrot;
6408  for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6409  delete jmdconnectorot;
6410  delete jmdconnectortrans[1];
6411  for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6412  delete cableconnectorcombitrans;
6413  delete electboardbacktrans;
6414  delete electboardbackrot;
6415  delete electlayerrot;
6416  for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6417  for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6418  delete mothersupplycardtrans;
6419  for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6420  /////////////////////////////////////////////////////////////
6421  return cardinterfacecontainer;
6422  }
6423  ////////////////////////////////////////////////////////////////////////////////
6424  TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6425   /////////////////////////////////////////////////////////////
6426   // Method returning EndCap Mother Volume
6427   /////////////////////////////////////////////////////////////
6428   const Int_t kendcapcoverplatesmallholenumber = 9;
6429   Double_t endcapmotherorigin[3];
6430   endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6431                                                 +  0.5 *(fgkEndCapCoverPlateLength[3]
6432                                             +  2.0 * fgkEndCapCoverPlateLength[2]);
6433   endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6434                                           -                      fgkEndCapCoverPlateWidth[2]
6435                                           -       (kendcapcoverplatesmallholenumber-1)
6436                                           *        fgkEndCapCoverPlateSmallHoleSeparation[2])
6437                                           +  0.5*(fgkEndCapSideCoverLength[2]
6438                                           +               fgkEndCapCoverPlateWidth[1]
6439                                           -       fgkEndCapCoverPlateWidth[0])
6440                                           -      (fgkEndCapCoverPlateWidth[1]
6441                                           -       fgkEndCapCoverPlateWidth[0]);
6442   endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6443                                                 + 2.*fgkEndCapCoolingTubeRadiusMax
6444                                                 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6445                                                 +      fgkEndCapSideCoverWidth[1]
6446                                                 +      fgkEndCapSideCoverThickness
6447                                                 +      fgkEndCapKaptonFoilThickness);
6448   TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6449                                                           +                              2.0* fgkEndCapCoverPlateLength[2]
6450                                                           +              2.0* fgkEndCapSideCoverThickness),
6451                                                                          0.5* (fgkEndCapSideCoverLength[2]
6452                                                           +                    fgkEndCapCoverPlateWidth[1]
6453                                                           -                                        fgkEndCapCoverPlateWidth[0]),
6454                                                                                          0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6455                                                       +                                    fgkEndCapSideCoverWidth[1]
6456                                                           +                                       fgkEndCapSideCoverThickness
6457                                                       +                                   fgkEndCapKaptonFoilThickness),
6458                                                                                          endcapmotherorigin);
6459   TGeoVolume** endcapassembly;
6460   endcapassembly = new TGeoVolume*[4];
6461   endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6462                                                                                         endcapmothershape,fSSDAir);
6463   endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6464                                                                                         endcapmothershape,fSSDAir);
6465   endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6466                                                                                         endcapmothershape,fSSDAir);
6467   endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6468                                                                                         endcapmothershape,fSSDAir);
6469  /////////////////////////////////
6470  // endcapassembly[0]:  Container End Cap Layer 5 Bellegarde Side
6471  // endcapassembly[1]:  Container End Cap Layer 5 Gex Side
6472  // endcapassembly[2]:  Container End Cap Layer 6 Bellegarde Side
6473  // endcapassembly[3]:  Container End Cap Layer 6 Gex Side
6474  /////////////////////////////////
6475   /////////////////////////////////////////////////////
6476   // Placing Endcap Cover Plate
6477   /////////////////////////////////////////////////////
6478   TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6479   TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6480   endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6481   TGeoCombiTrans* endcapcoverplatecombitrans =
6482                                                   new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6483                                                                                          endcapcoverplaterot);
6484   TGeoTranslation* endcapcoverplatetrans =
6485                                                   new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6486   TGeoHMatrix* endcapcoverplatematrix =
6487                                                   new TGeoHMatrix((*endcapcoverplatetrans)
6488                                                                           *       (*endcapcoverplatecombitrans));
6489   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6490   /////////////////////////////////////////////////////
6491   // Placing Endcap Side Cover
6492   /////////////////////////////////////////////////////
6493   TGeoVolume* endcapsidecover = GetEndCapSideCover();
6494   TGeoRotation* endcapsidecoverot[2];
6495   TGeoCombiTrans* endcapsidecovercombitrans[3];
6496   for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6497   endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6498   endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6499                                                                                         - 0.5*(fgkEndCapCoverPlateWidth[0]
6500                                                                                         - fgkEndCapCoverPlateWidth[2]
6501                                                                                     - (kendcapcoverplatesmallholenumber-1)
6502                                                                                         * fgkEndCapCoverPlateSmallHoleSeparation[2])
6503                                                                                         + 0.*fgkEndCapCoverPlateWidth[0]
6504                                                                                         + fgkEndCapSideCoverLength[2],
6505                                                                                           0.5*(fgkEndCapSideCoverThickness
6506                                                                                         + fgkEndCapCoverPlateThickness)
6507                                                                                         - 0.5*fgkEndCapCoverPlateThickness,
6508                                                                                           endcapsidecoverot[0]);
6509   endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6510   endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6511                                                                                                         0.5*fgkEndCapCoverPlateThickness
6512                                                                                                         -fgkEndCapSideCoverWidth[1],
6513                                                                                                         endcapsidecoverot[1]);
6514   endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6515                                                                                                         +fgkEndCapCoverPlateLength[3]
6516                                                                                                         +2.*fgkEndCapCoverPlateLength[2]
6517                                                                                                         +fgkEndCapSideCoverThickness,0.0,
6518                                                                                                         0.5*fgkEndCapCoverPlateThickness
6519                                                                                                         -fgkEndCapSideCoverWidth[1],
6520                                                                                                         endcapsidecoverot[1]);
6521   TGeoHMatrix* endcapsidecovermatrix[2];
6522   for(Int_t i=0; i<2; i++){
6523    endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6524                                                         *                                 (*endcapsidecovercombitrans[0]));
6525         for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6526                                                                                                                 endcapsidecovermatrix[i]);
6527   }
6528   /////////////////////////////////////////////////////
6529   // Placing Endcap Cooling Tube
6530   /////////////////////////////////////////////////////
6531   TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6532   TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6533   endcapcoolingtuberot->SetAngles(0.,180.,0.);
6534   TGeoCombiTrans* endcapccolingtubecombitrans
6535                                                 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6536                                                 + fgkEndCapCoolingTubeAxialRadius[1])
6537                                                 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6538                                                 - fgkEndCapCoolingTubeToCoverSide,
6539                                                   fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6540                                                 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6541   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6542                                                                                                           endcapccolingtubecombitrans);
6543   /////////////////////////////////////////////////////
6544   // Placing Screws
6545   /////////////////////////////////////////////////////
6546   Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6547                                                                            fgkEndCapCoverPlateScrewRadiusMin};
6548   Int_t screwcoverplatedgesnumber[2] = {20,20};
6549   Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6550                                                                                 fgkEndCapCoverPlateThickness
6551                                                                          +  fgkEndCapCoolingTubeRadiusMax};
6552   TGeoXtru* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
6553                                                                                                  screwcoverplatedgesnumber,
6554                                                                                                  screwcoverplatesection);
6555   TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6556                                                                                            screwcoverplateshape,
6557                                                                                            fSSDCoolingTubePhynox);
6558   screwcoverplate->SetLineColor(12);
6559   Double_t transx[4] = {0,
6560                                                 fgkEndCapCoverPlateSmallHoleSeparation[0],
6561                                                 fgkEndCapCoverPlateSmallHoleSeparation[0]
6562                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1],
6563                                          2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6564                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1]};
6565   const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6566 //  TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6567   TGeoTranslation*** endcapcoverplatescrewtrans;
6568   endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6569   Int_t index = 0;
6570   for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6571         endcapcoverplatescrewtrans[i] =
6572                                         new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6573     for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6574                 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6575         if(index==1||index==9||index==28||index==36){
6576                         endcapcoverplatescrewtrans[i][j] =
6577                                 new TGeoTranslation(transx[i],
6578                                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6579                                                                         fgkEndCapSideCoverThickness);
6580                 }
6581                 else{
6582                         endcapcoverplatescrewtrans[i][j] =
6583                                 new TGeoTranslation(transx[i],
6584                                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6585                                                                         0.);
6586                 }
6587             if(index!=19)
6588                 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6589                                                                                           endcapcoverplatescrewtrans[i][j]);
6590         }
6591   }
6592   /////////////////////////////////////////////////////
6593   // Placing Cover Plate Clips
6594   /////////////////////////////////////////////////////
6595   TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6596                                                                                                          0.5*fgkEndCapCoverPlateClipWidth,
6597                                                                                                          0.5*fgkEndCapSideCoverThickness);
6598   TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6599                                                                                                         endcapcoverplateclipshape,
6600                                                                                                         fSSDCoolingTubePhynox);
6601   TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6602                                                                                                          0.5*fgkEndCapCoverPlateDownClipWidth,
6603                                                                                                          0.5*fgkEndCapSideCoverThickness);
6604   TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6605                                                                                                         endcapcoverplatedownclipshape,
6606                                                                                                         fSSDCoolingTubePhynox);
6607   TGeoTranslation* endcapcoverplatecliptrans[4];
6608   endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6609                                                            -                     fgkEndCapCoverPlateLength[0]
6610                                                            -                     fgkEndCapSideCoverThickness,
6611                                                                                                          0.0,
6612                                                                                                  0.5*(fgkEndCapSideCoverThickness
6613                                                            +                                              fgkEndCapCoverPlateThickness));
6614   endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6615                                                            -                     fgkEndCapCoverPlateLength[0]
6616                                                            -                     fgkEndCapSideCoverThickness,
6617                                                                                                          (kendcapcoverplatescrewnumber[1]-1)
6618                                                            *                                     fgkEndCapSideCoverWidth[5],
6619                                                                                                  0.5*(fgkEndCapSideCoverThickness
6620                                                            +                                              fgkEndCapCoverPlateThickness));
6621   endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6622                                                            -                     fgkEndCapCoverPlateLength[0]
6623                                                            +                                     fgkEndCapCoverPlateLength[1]
6624                                                            +                              2.*fgkEndCapCoverPlateLength[0]
6625                                                            -                                     fgkEndCapCoverPlateClipLength
6626                                                            +                                 fgkEndCapSideCoverThickness,
6627                                                                                                          0.0,
6628                                                                                                  0.5*(fgkEndCapSideCoverThickness
6629                                                            +                                              fgkEndCapCoverPlateThickness));
6630   endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6631                                                            -                     fgkEndCapCoverPlateLength[0]
6632                                                            +                                     fgkEndCapCoverPlateLength[1]
6633                                                            +                              2.*fgkEndCapCoverPlateLength[0]
6634                                                            -                                     fgkEndCapCoverPlateClipLength
6635                                                            +                                 fgkEndCapSideCoverThickness,
6636                                                                                                          (kendcapcoverplatescrewnumber[1]-1)
6637                                                            *                                     fgkEndCapSideCoverWidth[5],
6638                                                                                                  0.5*(fgkEndCapSideCoverThickness
6639                                                            +                                              fgkEndCapCoverPlateThickness));
6640   endcapcoverplateclip->SetLineColor(fColorPhynox);
6641   endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6642   for(Int_t i=0; i<4; i++)
6643         for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6644                                                                                                    endcapcoverplatecliptrans[i]);
6645   TGeoTranslation* endcapcoverplatedowncliptrans[4];
6646   endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6647                                                                    -                     fgkEndCapCoverPlateLength[0]
6648                                                                    -                     fgkEndCapSideCoverThickness,
6649                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6650                                                                    -                                 fgkEndCapCoverPlateClipWidth),
6651                                                                                                         0.5*(fgkEndCapSideCoverThickness
6652                                                                +                                         fgkEndCapCoverPlateThickness)
6653                                                                    -                     fgkEndCapSideCoverWidth[1]
6654                                                                    -                                     fgkEndCapSideCoverThickness);
6655   endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6656                                                                    -                     fgkEndCapCoverPlateLength[0]
6657                                                                    -                     fgkEndCapSideCoverThickness,
6658                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6659                                                                    -                                 fgkEndCapCoverPlateClipWidth)
6660                                                                    +                            fgkEndCapSideCoverLength[2]
6661                                                                    -                            fgkEndCapCoverPlateDownClipWidth,
6662                                                                                                         0.5*(fgkEndCapSideCoverThickness
6663                                                                +                                         fgkEndCapCoverPlateThickness)
6664                                                                    -                     fgkEndCapSideCoverWidth[1]
6665                                                                    -                                     fgkEndCapSideCoverThickness);
6666   endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6667                                                                    -                     fgkEndCapCoverPlateLength[0]
6668                                                                    +                     fgkEndCapSideCoverThickness
6669                                                                    +                     fgkEndCapCoverPlateLength[1]
6670                                                                    +                 2.0*fgkEndCapCoverPlateLength[0]
6671                                                                    -                     fgkEndCapCoverPlateDownClipLength,
6672                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6673                                                                    -                                 fgkEndCapCoverPlateClipWidth),
6674                                                                                                         0.5*(fgkEndCapSideCoverThickness
6675                                                                +                                         fgkEndCapCoverPlateThickness)
6676                                                                    -                     fgkEndCapSideCoverWidth[1]
6677                                                                    -                                     fgkEndCapSideCoverThickness);
6678   endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6679                                                                    -                     fgkEndCapCoverPlateLength[0]
6680                                                                    +                     fgkEndCapSideCoverThickness
6681                                                                    +                     fgkEndCapCoverPlateLength[1]
6682                                                                    +                 2.0*fgkEndCapCoverPlateLength[0]
6683                                                                    -                     fgkEndCapCoverPlateDownClipLength,
6684                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6685                                                                    -                                 fgkEndCapCoverPlateClipWidth)
6686                                                                    +                                 fgkEndCapSideCoverLength[2]
6687                                                                    -                                 fgkEndCapCoverPlateDownClipWidth,
6688                                                                                                         0.5*(fgkEndCapSideCoverThickness
6689                                                                +                                         fgkEndCapCoverPlateThickness)
6690                                                                    -                     fgkEndCapSideCoverWidth[1]
6691                                                                    -                                     fgkEndCapSideCoverThickness);
6692   for(Int_t i=0; i<4; i++)
6693         for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6694                                                                                                    endcapcoverplatedowncliptrans[i]);
6695   /////////////////////////////////////////////////////
6696   // Placing Kapton Foil
6697   /////////////////////////////////////////////////////
6698   TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6699                                                                                                  0.5*fgkEndCapKaptonFoilWidth,
6700                                                                                                  0.5*fgkEndCapKaptonFoilThickness);
6701   TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6702                                                                                                 endcapkaptonfoilshape,
6703                                                                                                 fSSDKaptonFlexMedium);
6704   endcapkaptonfoil->SetLineColor(8);
6705   TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6706                                                                                                                            0.5*fgkEndCapKaptonFoilWidth
6707                                                                                  -                     0.5*fgkEndCapCoverPlateClipWidth,
6708                                                                                                                            0.5*fgkEndCapCoverPlateThickness
6709                                                                                  -                     0.5*fgkEndCapKaptonFoilThickness
6710                                                                              -                     fgkEndCapSideCoverWidth[1]
6711                                                                                  -                     fgkEndCapSideCoverThickness);
6712   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6713   /////////////////////////////////////////////////////////////
6714   // Placing Electronic Tubes
6715   /////////////////////////////////////////////////////////////
6716   Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6717                                                                              - fgkEndCapInterfaceCardBThickness
6718                                                                              - 9.*fgkEndCapStripConnectionThickness
6719                                                                              - 8.*fgkEndCapCardElectBoardBackThickness,
6720                                                                                fgkEndCapKaptonFoilWidth
6721                                                                              - fgkEndCapInterfaceCardBThickness
6722                                                                              - 9.*fgkEndCapStripConnectionThickness
6723                                                                              - 8.*fgkEndCapCardElectBoardBackThickness
6724                                                                                  - fgkEndCapInterfaceElectBoardCardBThickness};
6725   TGeoVolume* endcapeffectivecables[2];
6726   endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6727                                                                                          fgkEndCapEffectiveCableRadiusMax,
6728                                                                                          endcapeffectivecableswidth[0],
6729                                                                                          10,"EndCapEffectiveCables1");
6730   endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6731                                                                                          fgkEndCapEffectiveCableRadiusMax,
6732                                                                                          endcapeffectivecableswidth[1],
6733                                                                                          25,"EndCapEffectiveCables2");
6734   TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6735   TGeoTranslation* endcapeffectivecablestrans[2];
6736   endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6737                                           -                                                        0.5*endcapeffectivecableswidth[0]
6738                                           -                            0.5*(fgkEndCapCoverPlateWidth[0]
6739                                           -                                                               fgkEndCapCoverPlateWidth[2]
6740                                           -                                             (kendcapcoverplatesmallholenumber-1)
6741                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6742                                           +                                             fgkEndCapSideCoverLength[2],
6743                                           -                     0.5*fgkEndCapCoverPlateThickness
6744                                           -                                             (fgkEndCapCardElectBoardBackWidth[0]
6745                                           -                                              fgkEndCapInterfaceCardBWidth[0]
6746                                           -                                              fgkEndCapInterfaceCardBWidth[1]));
6747   endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6748                                           -                                                        0.5*endcapeffectivecableswidth[1]
6749                                           -                            0.5*(fgkEndCapCoverPlateWidth[0]
6750                                           -                                                               fgkEndCapCoverPlateWidth[2]
6751                                           -                                             (kendcapcoverplatesmallholenumber-1)
6752                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6753                                           +                                         fgkEndCapSideCoverLength[2],
6754                                           -                     0.5*fgkEndCapCoverPlateThickness
6755                                           -                                             (fgkEndCapCardElectBoardBackWidth[0]
6756                                           -                                              fgkEndCapInterfaceCardBWidth[0])
6757                                           -                     0.5*fgkEndCapInterfaceCardBWidth[2]);
6758   endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6759   TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6760   endcapeffectivecablescombitrans[0]  = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6761                                                                                                                    *endcapeffectivecablesrot);
6762   endcapeffectivecablescombitrans[1]  = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6763                                                                                                                    *endcapeffectivecablesrot);
6764   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6765                                                                                                           endcapeffectivecablescombitrans[0]);
6766   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6767                                                                                                           endcapeffectivecablescombitrans[1]);
6768   /////////////////////////////////////////////////////////////
6769   // Placing End Cap Cards
6770   /////////////////////////////////////////////////////////////
6771   TGeoVolume** endcapcards = GetEndCapCards();
6772   TGeoRotation* endcapcardsrot[2];
6773   for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6774   endcapcardsrot[0]->SetAngles(90.,0.,0.);
6775   TGeoTranslation* endcapcardstrans[2];
6776   endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6777                                                                                         -  fgkEndCapCardElectBoardBackLength[0]));
6778   TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6779   endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6780   TGeoHMatrix* endcapcardsmatrix[2];
6781   endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6782   Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6783                                                   - fgkEndCapCardJMDConnectorLength[0]
6784                                                   - fgkEndCapInterfaceCardBThickness
6785                                                   - 9.*fgkEndCapStripConnectionThickness
6786                                                   - 8.*fgkEndCapCardElectBoardBackThickness;
6787   endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6788                                           -                                             fgkEndCapCoverPlateLength[0]
6789                                           + 0.5 *              (fgkEndCapCoverPlateLength[3]
6790                                           + 2.0 *                               fgkEndCapCoverPlateLength[2]),
6791                                           -                                                     stiffenertransx-fgkEndCapStiffenerWidth
6792                                           -                                                               fgkEndCapCardJMDConnectorLength[0]
6793                                           -                                                               fgkEndCapInterfaceCardBThickness
6794                                           -     2.0 *                                             fgkEndCapStripConnectionThickness
6795                                           - 1.5 *                                             fgkEndCapInterfaceCardBThickness
6796                                           - 0.5 *                                                (fgkEndCapCoverPlateWidth[0]
6797                                           -                                                               fgkEndCapCoverPlateWidth[2]
6798                                           -                                             (kendcapcoverplatesmallholenumber-1)
6799                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6800                                           +                     fgkEndCapKaptonFoilWidth,
6801                                                                                           0.5*fgkEndCapCoverPlateThickness
6802                                           -                                                     fgkEndCapSideCoverWidth[1]);
6803   endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6804   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6805    /////////////////////////////////////////////////////////////
6806   // Deallocating memory
6807   /////////////////////////////////////////////////////////////
6808   delete endcapcoverplaterot;
6809   delete endcapcoverplatecombitrans;
6810   delete endcapcoverplatetrans;
6811   for(Int_t i=0; i<3; i++){
6812    delete endcapsidecovercombitrans[i];
6813    if(i<2) delete endcapsidecoverot[i];
6814   }
6815   for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6816   for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6817   delete endcapcardsmatrix[0];
6818   return endcapassembly;
6819  }
6820  ////////////////////////////////////////////////////////////////////////////////
6821  TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6822                                                                                                                         Double_t radiusmax,
6823                                                                                                                         Double_t width,
6824                                                                                                                         Int_t ncables,
6825                                                                                                                         char* volname){
6826   /////////////////////////////////////////////////////////////
6827   // Generating EndCap High Voltage Tubes
6828   /////////////////////////////////////////////////////////////
6829   Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
6830   Double_t effectiveouteradius = TMath::Sqrt(TMath::Power(effectiveinneradius,2.)
6831                                                            +             TMath::Power(radiusmax,2.)
6832                                -             TMath::Power(radiusmin,2.));
6833   TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6834   TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6835                                                                                                    effectiveouteradius,0.5*width);
6836   TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6837                                                                                                 effectiveinnertubeshape,
6838                                                                                                 fSSDStiffenerConnectorMedium);
6839   effectiveinnertube->SetLineColor(41);
6840   TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6841                                                                                                 effectiveoutertubeshape,
6842                                                                                                 fSSDKaptonChipCableMedium);
6843   effectiveoutertube->SetLineColor(39);
6844   TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6845   TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6846   effectivemothertube->AddNode(effectiveinnertube,1);
6847   effectivemothertube->AddNode(effectiveoutertube,1);
6848   return effectivemothertube;
6849  }
6850  ////////////////////////////////////////////////////////////////////////////////
6851  TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6852   /////////////////////////////////////////////////////////////
6853   // Generating EndCap Support Layer 5 and Layer 6
6854   /////////////////////////////////////////////////////////////
6855   const Int_t knedges = 5;
6856   ///////////////////////////////////////////////
6857   // Setting the vertices for TGeoXtru Up Volume
6858   ///////////////////////////////////////////////
6859   const Int_t klayernumber = 2;
6860   Double_t xupvertex[klayernumber][knedges+3];
6861   Double_t yupvertex[klayernumber][knedges+3];
6862   Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6863   Double_t middledgeangle[klayernumber] = {0.0,0.0};
6864   Double_t middlepsi[klayernumber] = {0.0,0.0};
6865   for(Int_t i=0; i<klayernumber; i++){
6866         xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6867         xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6868         xupvertex[i][2] = -xupvertex[i][1];
6869         xupvertex[i][3] = -xupvertex[i][0];
6870
6871         yupvertex[i][0] =  fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6872         yupvertex[i][1] =  0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6873         yupvertex[i][2] =  yupvertex[i][1];
6874         yupvertex[i][3] =  yupvertex[i][0];
6875
6876     middledgeangle[i] = upedgeangle[i]/knedges;
6877     middlepsi[i] = 90.0-0.5*upedgeangle[i];
6878     for(Int_t j=1; j<knedges; j++){
6879                 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6880                 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6881         }
6882   }
6883   ////////////////////////////////////
6884   // Generating Up TGeoXtru
6885   ////////////////////////////////////
6886   TGeoXtru* upendcapsupportshape[klayernumber];
6887   TGeoVolume* upendcapsupport[klayernumber];
6888   char upendcapsupportname[30];
6889   for(Int_t i=0; i<klayernumber; i++){
6890    upendcapsupportshape[i] = new TGeoXtru(2);
6891    sprintf(upendcapsupportname,"UpEndCapSupportPieceLayer%i",i+5);
6892    upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6893    upendcapsupportshape[i]->DefineSection(0,0.);
6894    upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6895    upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
6896                                                                         fSSDSupportRingAl);
6897    upendcapsupport[i]->SetLineColor(5);
6898   }
6899   ///////////////////////////////////////////////
6900   // Setting the vertices for TGeoXtru Down Volume
6901   ///////////////////////////////////////////////
6902   Double_t xdownvertex[klayernumber][2*(knedges+1)];
6903   Double_t ydownvertex[klayernumber][2*(knedges+1)];
6904   for(Int_t i=0; i<klayernumber; i++){
6905         xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6906         xdownvertex[i][1] =  xupvertex[i][0];
6907         ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6908         ydownvertex[i][1] =  yupvertex[i][0];
6909         for(Int_t j=0; j<knedges; j++){
6910                 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6911                 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6912         }
6913         for(Int_t j=0; j<knedges; j++){
6914                 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6915                                                                         * CosD(middlepsi[i]+j*middledgeangle[i]);
6916                 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6917                                                                         * SinD(middlepsi[i]+j*middledgeangle[i]);
6918         }
6919   }
6920   ////////////////////////////////////
6921   // Generating Down TGeoXtru
6922   ////////////////////////////////////
6923   TGeoXtru* downendcapsupportshape[klayernumber];
6924   TGeoVolume* downendcapsupport[klayernumber];
6925   char downendcapsupportname[30];
6926   for(Int_t i=0; i<klayernumber; i++){
6927         downendcapsupportshape[i] = new TGeoXtru(2);
6928     sprintf(downendcapsupportname,"DownEndCapSupportPieceLayer%i",i+5);
6929         downendcapsupportshape[i] = new TGeoXtru(2);
6930         downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
6931     if(i==0){
6932                 downendcapsupportshape[i]->DefineSection(0,0.);
6933                 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
6934     }
6935         else{
6936                 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
6937                                                                  -                 fgkEndCapSupportLowWidth[i]);
6938                 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6939         }
6940     downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
6941                                                                 downendcapsupportshape[i],fSSDSupportRingAl);
6942         downendcapsupport[i]->SetLineColor(5);
6943   }
6944   ///////////////////////////////////////////////
6945   // Setting TGeoPgon Volume
6946   ///////////////////////////////////////////////
6947   const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6948                                                                                                    fgkSSDLay6LadderNumber};
6949   TGeoPgon* endcapsupportmothershape[klayernumber];
6950   TGeoVolume** endcapsupportmother;
6951   endcapsupportmother = new TGeoVolume*[klayernumber];
6952   char endcapsupportmothername[30];
6953   for(Int_t i=0; i<klayernumber; i++){
6954         endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6955     sprintf(endcapsupportmothername,"EndCapSupportMotherLayer%i",i+5);
6956         endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
6957     endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
6958                                                                                           ydownvertex[i][0],yupvertex[i][1]);
6959     endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
6960                                                                                         fSSDAir);
6961   }
6962   ////////////////////////////////////
6963   TGeoRotation** endcapsupportrot[klayernumber];
6964   for(Int_t i=0; i<2; i++){
6965         endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
6966         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6967            endcapsupportrot[i][j] = new TGeoRotation();
6968            endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
6969        endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
6970        endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
6971         }
6972   }
6973   return endcapsupportmother;
6974  }
6975  ////////////////////////////////////////////////////////////////////////////////
6976  void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
6977   /////////////////////////////////////////////////////////////
6978   // Setting End Cap Support Layer 5 and 6.
6979   /////////////////////////////////////////////////////////////
6980   const Int_t kendcapcoverplatesmallholenumber = 9;
6981   const Int_t klayernumber = 2;
6982   const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6983                                                                                                    fgkSSDLay6LadderNumber};
6984   Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
6985                                                                                 360.0/kssdlayladdernumber[1]};
6986   TGeoVolume** endcapsupport = EndCapSupport();
6987   TGeoVolume** endcapassembly = GetEndCapAssembly();
6988   TGeoPgon* endcapsupportshape[klayernumber];
6989   Double_t* radiusmin[klayernumber];
6990   Double_t* radiusmax[klayernumber];
6991   for(Int_t i=0; i<klayernumber; i++){
6992     endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
6993         radiusmin[i] = endcapsupportshape[i]->GetRmin();
6994         radiusmax[i] = endcapsupportshape[i]->GetRmax();
6995   }
6996   TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
6997   Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
6998                                                                           endcapassemblyshape->GetDY(),
6999                                                                           endcapassemblyshape->GetDZ()};
7000   ///////////////////////////////////////////////
7001   // Setting TGeoPgon Volume for Mother Container
7002   ///////////////////////////////////////////////
7003   TGeoPgon* endcapsupportsystemshape[klayernumber];
7004   char endcapsupportsystemothername[30];
7005   for(Int_t i=0; i<klayernumber; i++){
7006         endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
7007     sprintf(endcapsupportsystemothername,"EndCapSupportSystemLayer%i",i+5);
7008         endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
7009                                                                                              - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
7010                                                                                           (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7011                                                                                            +2.*endcapassemblycenter[2])
7012                                                                                            /CosD(0.5*upedgeangle[i]));
7013     endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
7014                                                                                                  -(fgkEndCapCoverPlateWidth[1]
7015                                                                                              - fgkEndCapCoverPlateWidth[0]),
7016                                                                                            *radiusmin[i],
7017                                                                                           (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7018                                                                                            +2.*endcapassemblycenter[2])
7019                                                                                            /CosD(0.5*upedgeangle[i]));
7020   }
7021   fgkEndCapSupportSystem = new TGeoVolume*[4];
7022   fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
7023                                                                           endcapsupportsystemshape[0],fSSDAir);
7024   fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
7025                                                                           endcapsupportsystemshape[0],fSSDAir);
7026   fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
7027                                                                           endcapsupportsystemshape[1],fSSDAir);
7028   fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
7029                                                                           endcapsupportsystemshape[1],fSSDAir);
7030   ///////////////////////////////////////////////
7031   TGeoTranslation* endcapassemblytrans[klayernumber];
7032   for(Int_t i=0; i<klayernumber; i++)
7033         endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
7034                                                                            -  fgkEndCapSideCoverThickness
7035                                                                            +  endcapassemblycenter[0],
7036                                                                            -  0.5*fgkEndCapCoverPlateThickness
7037                                                                            -  2.0*fgkEndCapCoolingTubeRadiusMax
7038                                                                            +  2.0*endcapassemblycenter[2]
7039                                                                            +  0.5*fgkEndCapSupportLength[i]
7040                                                                            /  TanD(0.5*upedgeangle[i]),
7041                                                                                   0.5*(fgkEndCapCoverPlateWidth[0]
7042                                                                            -  fgkEndCapCoverPlateWidth[2]
7043                                                                            - (kendcapcoverplatesmallholenumber-1)
7044                                                                            *  fgkEndCapCoverPlateSmallHoleSeparation[2]));
7045   TGeoRotation** endcapassemblyrot[klayernumber];
7046   TGeoHMatrix** endcapassemblymatrix[klayernumber];
7047   for(Int_t i=0; i<klayernumber; i++){
7048    endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
7049    endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
7050    for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
7051    endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
7052    endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
7053    endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
7054    endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
7055    for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
7056         endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
7057         endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
7058    }
7059   }
7060   TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
7061                                                         fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
7062   for(Int_t i=0; i<2*klayernumber; i++){
7063         for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
7064                 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
7065                                                                                                                                            endcapassemblymatrix[1][j+2]);
7066         }
7067         fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
7068   }
7069    /////////////////////////////////////////////////////////////
7070   // Deallocating memory
7071   /////////////////////////////////////////////////////////////
7072   for(Int_t i=0; i<klayernumber; i++){
7073         for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
7074                 delete endcapassemblyrot[i][j];
7075         }
7076         delete endcapassemblyrot[i];
7077         delete endcapassemblymatrix[i][0];
7078         delete endcapassemblymatrix[i][1];
7079   }
7080   /////////////////////////////////////////////////////////////
7081   }
7082   void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
7083   /////////////////////////////////////////////////////////////
7084   // Setting End Cap Support + End Cap Assembly of Layer 5.
7085   /////////////////////////////////////////////////////////////
7086   if (! moth) {
7087     printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer5, mother is null!\n");
7088     return;
7089   };
7090   if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
7091   TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7092   endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7093                                                                                                 fgkEndCapSupportCenterLay5ITSPosition
7094                                                                            +            fgkEndCapSupportCenterLay5Position
7095                                                                            -            fgkEndCapSideCoverLength[2]);
7096   endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7097                                                                                                 fgkEndCapSideCoverLength[2]
7098                                                                            -        fgkEndCapSupportCenterLay5Position
7099                                                                            -        fgkEndCapSupportCenterLay5ITSPosition);
7100   TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7101   endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7102   TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7103         new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7104   moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7105   moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7106    /////////////////////////////////////////////////////////////
7107   // Deallocating memory
7108   /////////////////////////////////////////////////////////////
7109   delete endcapsupportsystemrot;
7110   delete endcapsupportsystemITSCentertrans[1];
7111  }
7112   /////////////////////////////////////////////////////////////
7113   void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7114   /////////////////////////////////////////////////////////////
7115   // Setting End Cap Support + End Cap Assembly of Layer 6.
7116   /////////////////////////////////////////////////////////////
7117   if (! moth) {
7118     printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer6, mother is null!\n");
7119     return;
7120   };
7121   if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
7122   TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7123   endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7124                                                                                                 fgkEndCapSupportCenterLay6ITSPosition
7125                                                                            +            fgkEndCapSupportCenterLay6Position
7126                                                                            -            fgkEndCapSideCoverLength[2]);
7127   endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7128                                                                                                 fgkEndCapSideCoverLength[2]
7129                                                                            -        fgkEndCapSupportCenterLay6Position
7130                                                                            -        fgkEndCapSupportCenterLay6ITSPosition);
7131   TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7132   endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7133   TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7134         new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7135   moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7136   moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7137    /////////////////////////////////////////////////////////////
7138   // Deallocating memory
7139   /////////////////////////////////////////////////////////////
7140   delete endcapsupportsystemrot;
7141   delete endcapsupportsystemITSCentertrans[1];
7142  }
7143  ////////////////////////////////////////////////////////////////////////////////
7144  void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7145   /////////////////////////////////////////////////////////////
7146   // Setting Ladder Support of Layer 5.
7147   /////////////////////////////////////////////////////////////
7148   if (! moth) {
7149     printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer5, mother is null!\n");
7150     return;
7151   };
7152   if(!fLay5LadderSupportRing) SetLadderSupport(100);
7153   fMotherVol = moth;
7154   TGeoTranslation* centerITSRingSupportLay5trans[2];
7155   for(Int_t i=0; i<2; i++){
7156         centerITSRingSupportLay5trans[i] =
7157                 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7158     moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7159   }
7160  }
7161  ////////////////////////////////////////////////////////////////////////////////
7162  void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7163   /////////////////////////////////////////////////////////////
7164   // Setting Ladder Support of Layer 6.
7165   /////////////////////////////////////////////////////////////
7166   if (! moth) {
7167     printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer6, mother is null!\n");
7168     return;
7169   };
7170   if(!fLay6LadderSupportRing) SetLadderSupport(100);
7171   fMotherVol = moth;
7172   TGeoTranslation* centerITSRingSupportLay6trans[2];
7173   for(Int_t i=0; i<2; i++){
7174         centerITSRingSupportLay6trans[i] =
7175                 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7176     moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7177   }
7178  }
7179  ////////////////////////////////////////////////////////////////////////////////
7180 TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
7181                                                                         Double_t height, char* shapename, Int_t isign) const{
7182   /////////////////////////////////////////////////////////////
7183   // Method generating an Arb shape
7184   /////////////////////////////////////////////////////////////
7185   const Int_t kvertexnumber = 8;
7186   const Int_t ktransvectnumber = 2;
7187   TVector3* vertex[kvertexnumber];
7188   TVector3* transvector[2];
7189   for(Int_t i=0; i<ktransvectnumber; i++) transvector[i] = new TVector3(0.,width[i]);
7190   /////////////////////////////////////////////////////////////
7191   //Setting the vertices for TGeoArb8
7192   /////////////////////////////////////////////////////////////
7193   vertex[0] = new TVector3(*vertexpos[0]);
7194   vertex[1] = new TVector3(*vertexpos[1]);
7195   vertex[2] = new TVector3(*vertex[1]+isign*(*transvector[0]));
7196   vertex[3] = new TVector3(*vertex[0]+isign*(*transvector[0]));
7197   vertex[4] = new TVector3(*vertexpos[2]);
7198   vertex[5] = new TVector3(*vertexpos[3]);
7199   vertex[6] = new TVector3(*vertex[5]+isign*(*transvector[1]));
7200   vertex[7] = new TVector3(*vertex[4]+isign*(*transvector[1]));
7201   /////////////////////////////////////////////////////////////
7202   TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
7203   for(Int_t i = 0; i<kvertexnumber;i++)
7204                                                         arbshape->SetVertex(i,vertex[i]->X(),vertex[i]->Y());
7205   /////////////////////////////////////////////////////////////
7206   // Deallocating memory
7207   /////////////////////////////////////////////////////////////
7208   for(Int_t i=0; i< kvertexnumber; i++) delete vertex[i];
7209   for(Int_t i=0; i< ktransvectnumber; i++) delete transvector[i];
7210   /////////////////////////////////////////////////////////////
7211   return arbshape;
7212 }
7213 ///////////////////////////////////////////////////////////////////////////////
7214 TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
7215                                                                 Double_t rmax, Int_t nedges, Double_t height){
7216   /////////////////////////////////////////////////////////////
7217   // Method generating Arc shape
7218   /////////////////////////////////////////////////////////////
7219         const Int_t kvertexnumber = 2*nedges+2;
7220         TGeoXtru* arcshape = new TGeoXtru(2);
7221         TVector3** vertexposition[2];
7222         for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
7223         Double_t angle = 0.;
7224     for(Int_t i=0; i<nedges+1; i++){
7225                 angle = 90.+0.5*phi-i*(phi/nedges);
7226                 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
7227                 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
7228         }
7229         Double_t *xvertexpoints = new Double_t[kvertexnumber];
7230         Double_t *yvertexpoints = new Double_t[kvertexnumber];
7231         for(Int_t i=0; i<kvertexnumber; i++){
7232                 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
7233                                   yvertexpoints[i] = vertexposition[0][i]->Y();
7234                 }
7235                 else if(i>=1&&i<nedges+2)
7236                 {
7237                         xvertexpoints[i] = vertexposition[1][i-1]->X();
7238                         yvertexpoints[i] = vertexposition[1][i-1]->Y();
7239                 }
7240         else
7241                 {
7242                         xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
7243                         yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
7244                 }
7245     }
7246   arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
7247   arcshape->DefineSection(0,-0.5*height);
7248   arcshape->DefineSection(1,0.5*height);
7249   /////////////////////////////////////////////////////////////
7250   // Deallocating memory
7251   /////////////////////////////////////////////////////////////
7252   for(Int_t i=0; i<2; i++){
7253         for(Int_t j=0; j<nedges+1; j++)
7254                 delete vertexposition[i][j];
7255         delete [] vertexposition[i];
7256   }
7257   delete [] xvertexpoints;
7258   delete [] yvertexpoints;
7259   /////////////////////////////////////////////////////////////
7260         return arcshape;
7261 }
7262 ////////////////////////////////////////////////////////////////////////////////
7263 TGeoXtru* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
7264   ///////////////////////////////////////////////////////////////////////
7265   // Method Generating the Screw Shape
7266   // radius[0]: outer radius
7267   // radius[1]: inner radius
7268   // edgesnumber[0]: outer number of edges
7269   // edgesnumber[1]: inner number of edges
7270   // section[0]: lower section position
7271   // section[1]: higher section position
7272   ///////////////////////////////////////////////////////////////////////
7273   Double_t outradius = radius[0];
7274   Double_t inradius = radius[1];
7275   Int_t outvertexnumber = edgesnumber[0];
7276   Int_t invertexnumber = edgesnumber[1];
7277   Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
7278   Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
7279   for(Int_t i=0; i<outvertexnumber+1; i++){
7280         xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
7281         yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
7282   }
7283   for(Int_t i=0; i<invertexnumber+1; i++){
7284         xscrewvertex[outvertexnumber+i+1] = inradius*CosD(90.-i*360./invertexnumber);
7285         yscrewvertex[outvertexnumber+i+1] = inradius*SinD(90.-i*360./invertexnumber);
7286   }
7287   TGeoXtru* screwshape = new TGeoXtru(2);
7288   screwshape->DefinePolygon(outvertexnumber+invertexnumber+2,xscrewvertex,yscrewvertex);
7289   screwshape->DefineSection(0,section[0]);
7290   screwshape->DefineSection(1,section[1]);
7291   delete [] xscrewvertex;
7292   delete [] yscrewvertex;
7293   return screwshape;
7294 }
7295 ////////////////////////////////////////////////////////////////////////////////
7296 TGeoXtru* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
7297   ///////////////////////////////////////////////////////////////////////
7298   // Method Generating the Hole Shape
7299   // radius of the Hole
7300   // nedges: number of edges to approximate the circle
7301   ///////////////////////////////////////////////////////////////////////
7302   Int_t vertexnumber = nedges+6;
7303   Double_t* xholevertex = new Double_t[vertexnumber];
7304   Double_t* yholevertex = new Double_t[vertexnumber];
7305   xholevertex[0] = radius;
7306   xholevertex[1] = xholevertex[0];
7307   xholevertex[2] = -xholevertex[1];
7308   xholevertex[3] = xholevertex[2];
7309   xholevertex[4] = xholevertex[0];
7310   yholevertex[0] = 0.;
7311   yholevertex[1] = -radius;
7312   yholevertex[2] = yholevertex[1];
7313   yholevertex[3] = -yholevertex[1];
7314   yholevertex[4] = yholevertex[3];
7315   for(Int_t i=0; i<nedges+1; i++){
7316         xholevertex[i+5] = radius*CosD(i*360./nedges);
7317         yholevertex[i+5] = radius*SinD(i*360./nedges);
7318   }
7319   TGeoXtru* holeshape = new TGeoXtru(2);
7320   holeshape->DefinePolygon(vertexnumber,xholevertex,yholevertex);
7321   holeshape->DefineSection(0,section[0]);
7322   holeshape->DefineSection(1,section[1]);
7323   delete [] xholevertex;
7324   delete [] yholevertex;
7325   return holeshape;
7326 }
7327 ////////////////////////////////////////////////////////////////////////////////
7328 TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
7329   /////////////////////////////////////////////////////////////
7330   // Given an axis specified by param, it gives the reflection of the point
7331   // respect to the axis
7332   /////////////////////////////////////////////////////////////
7333   TVector3* n = new TVector3(param[0],param[1],param[2]);
7334   Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
7335   TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
7336   /////////////////////////////////////////////////////////////
7337   // Deallocating memory
7338   /////////////////////////////////////////////////////////////
7339   delete n;
7340   /////////////////////////////////////////////////////////////
7341   return reflectedvector;
7342 }
7343 ////////////////////////////////////////////////////////////////////////////////
7344 TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct,
7345                                                        Double_t dx,
7346                                                        Double_t dy,
7347                                                        Double_t dz) const{
7348   /////////////////////////////////////////////////////////////
7349   // Add a dx,dy,dz translation to the initial TGeoCombiTrans
7350   /////////////////////////////////////////////////////////////
7351   TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
7352   const Double_t *vect = hmatrix->GetTranslation();
7353   Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
7354   hmatrix->SetTranslation(newvect);
7355   TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
7356   delete hmatrix;
7357   return matrix;
7358 }
7359 ////////////////////////////////////////////////////////////////////////////////
7360 TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
7361   /////////////////////////////////////////////////////////////
7362   // Method returning the Medium type
7363   /////////////////////////////////////////////////////////////
7364   char ch[30];
7365   sprintf(ch, "ITS_%s",mediumName);
7366   TGeoMedium* medium =  gGeoManager->GetMedium(ch);
7367   if (! medium)
7368     printf("Error(AliITSv11GeometrySSD)::medium %s not found !\n", mediumName);
7369   return medium;
7370 }
7371 ////////////////////////////////////////////////////////////////////////////////
7372 void AliITSv11GeometrySSD::CreateMaterials(){
7373 ///////////////////////////////////
7374 // This part has to be modified
7375 ///////////////////////////////////
7376   ///////////////////////////////////
7377   // Silicon for Sensor
7378   ///////////////////////////////////
7379   fSSDSensorMedium = GetMedium("SI$");
7380   ///////////////////////////////////
7381   // Silicon Mixture for Sensor
7382   ///////////////////////////////////
7383   fSSDChipMedium = GetMedium("SPD SI CHIP$");
7384   fSSDChipGlueMedium = GetMedium("EPOXY$");
7385   ///////////////////////////////////
7386   // Stiffener Components Materials
7387   ///////////////////////////////////
7388   fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
7389   ///////////////////////////
7390   // Stiffener Connectors
7391   ///////////////////////////
7392   fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
7393   ////////////////////////////////
7394   // Stiffener 0603-1812 Capacitor
7395   ////////////////////////////////
7396   fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
7397   fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
7398   ///////////////////////////
7399   // Stiffener Hybrid Wire
7400   ///////////////////////////
7401   fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
7402   ///////////////////////////
7403   // Al for Cooling Block
7404   ///////////////////////////
7405   fSSDAlCoolBlockMedium = GetMedium("AL$");
7406   //////////////////////////////////////////////////////
7407   // Kapton and Al for Chip Cable Flex and Ladder Cables
7408   //////////////////////////////////////////////////////
7409   fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
7410   fSSDAlTraceChipCableMedium = GetMedium("AL$");
7411   fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
7412   fSSDAlTraceFlexMedium = GetMedium("AL$");
7413   fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
7414   fSSDAlTraceLadderCableMedium = GetMedium("AL$");
7415   /////////////////////////////////////////////////////////////////
7416   // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
7417   //////////////////////////////////////////////////////////////////
7418   fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
7419   /////////////////////////////////////////////////////////////////
7420   // G10 for Detector Leg, TubeHolder
7421   //////////////////////////////////////////////////////////////////
7422   fSSDTubeHolderMedium = GetMedium("G10FR4$");
7423   fSSDSensorSupportMedium = GetMedium("G10FR4$");
7424   fSSDMountingBlockMedium = GetMedium("G10FR4$");
7425   fSSDMountingBlockMedium = GetMedium("G10FR4$");
7426   /////////////////////////////////////////////////////////////////
7427   // Water and Phynox for Cooling Tube
7428   //////////////////////////////////////////////////////////////////
7429   fSSDCoolingTubeWater = GetMedium("WATER$");
7430   fSSDCoolingTubePhynox = GetMedium("INOX$");
7431   /////////////////////////////////////////////////////////////////////
7432   // Material for Support Rings
7433   /////////////////////////////////////////////////////////////////////
7434   fSSDSupportRingAl = GetMedium("AL$");
7435   /////////////////////////////////////////////////////////////////////
7436   fSSDAir = GetMedium("SDD AIR$");
7437   fCreateMaterials = kTRUE;
7438 }
7439 /////////////////////////////////////////////////////////////////////